@asgardeo/browser 0.0.1 → 0.1.0

package/dist/index.js

@@ -1914,13 +1914,16 @@ var require_browser = __commonJS({
 
 // src/__legacy__/client.ts
 import {
-  AsgardeoAuthException as AsgardeoAuthException5
+  AsgardeoAuthException as AsgardeoAuthException4
 } from "@asgardeo/javascript";
 
-// src/__legacy__/helpers/authentication-helper.ts
+// src/__legacy__/clients/main-thread-client.ts
 import {
-  AsgardeoAuthException,
-  extractPkceStorageKeyFromState
+  AsgardeoAuthClient as AsgardeoAuthClient5,
+  OIDCRequestConstants as OIDCRequestConstants3,
+  extractPkceStorageKeyFromState as extractPkceStorageKeyFromState2,
+  initializeApplicationNativeAuthentication,
+  handleApplicationNativeAuthentication
 } from "@asgardeo/javascript";
 
 // src/__legacy__/constants/messages-types.ts
@@ -1991,6 +1994,12 @@ var STATE_QUERY = "state";
 // src/__legacy__/constants/errors.ts
 var ACCESS_TOKEN_INVALID = "Access token is invalid";
 
+// src/__legacy__/helpers/authentication-helper.ts
+import {
+  AsgardeoAuthException,
+  extractPkceStorageKeyFromState
+} from "@asgardeo/javascript";
+
 // src/__legacy__/utils/message-utils.ts
 var MessageUtils = class {
   // eslint-disable-next-line @typescript-eslint/no-empty-function
@@ -2046,15 +2055,15 @@ var _SPAUtils = class _SPAUtils {
   static setPKCE(pkceKey, pkce) {
     sessionStorage.setItem(pkceKey, pkce);
   }
-  static setSignOutURL(url, clientID, instanceID) {
+  static setSignOutURL(url, clientId, instanceID) {
     sessionStorage.setItem(
-      `${OIDCRequestConstants.SignOut.Storage.StorageKeys.SIGN_OUT_URL}-instance_${instanceID}-${clientID}`,
+      `${OIDCRequestConstants.SignOut.Storage.StorageKeys.SIGN_OUT_URL}-instance_${instanceID}-${clientId}`,
       url
     );
   }
-  static getSignOutURL(clientID, instanceID) {
+  static getSignOutUrl(clientId, instanceID) {
     return sessionStorage.getItem(
-      `${OIDCRequestConstants.SignOut.Storage.StorageKeys.SIGN_OUT_URL}-instance_${instanceID}-${clientID}`
+      `${OIDCRequestConstants.SignOut.Storage.StorageKeys.SIGN_OUT_URL}-instance_${instanceID}-${clientId}`
     ) ?? "";
   }
   static removePKCE(pkceKey) {
@@ -2108,7 +2117,7 @@ var _SPAUtils = class _SPAUtils {
     if (AsgardeoAuthClient.isSignOutSuccessful(window.location.href)) {
       const newUrl = window.location.href.split("?")[0];
       history.pushState({}, document.title, newUrl);
-      await AsgardeoAuthClient.clearUserSessionData();
+      await AsgardeoAuthClient.clearSession();
       return true;
     }
     return false;
@@ -2207,14 +2216,14 @@ var SPAUtils = _SPAUtils;
 var AuthenticationHelper = class {
   constructor(authClient, spaHelper) {
     __publicField(this, "_authenticationClient");
-    __publicField(this, "_dataLayer");
+    __publicField(this, "_storageManager");
     __publicField(this, "_spaHelper");
     __publicField(this, "_instanceID");
     __publicField(this, "_isTokenRefreshing");
     this._authenticationClient = authClient;
-    this._dataLayer = this._authenticationClient.getDataLayer();
+    this._storageManager = this._authenticationClient.getStorageManager();
     this._spaHelper = spaHelper;
-    this._instanceID = this._authenticationClient.getInstanceID();
+    this._instanceID = this._authenticationClient.getInstanceId();
     this._isTokenRefreshing = false;
   }
   enableHttpHandler(httpClient) {
@@ -2225,22 +2234,22 @@ var AuthenticationHelper = class {
   }
   initializeSessionManger(config, oidcEndpoints, getSessionState, getAuthzURL, sessionManagementHelper) {
     sessionManagementHelper.initialize(
-      config.clientID,
+      config.clientId,
       oidcEndpoints.checkSessionIframe ?? "",
       getSessionState,
       config.checkSessionInterval ?? 3,
       config.sessionRefreshInterval ?? 300,
-      config.signInRedirectURL,
+      config.afterSignInUrl,
       getAuthzURL
     );
   }
-  async requestCustomGrant(config, enableRetrievingSignOutURLFromSession) {
+  async exchangeToken(config, enableRetrievingSignOutURLFromSession) {
     let useDefaultEndpoint = true;
     let matches = false;
     if (config?.tokenEndpoint) {
       useDefaultEndpoint = false;
       for (const baseUrl of [
-        ...(await this._dataLayer.getConfigData())?.resourceServerURLs ?? [],
+        ...(await this._storageManager.getConfigData())?.resourceServerURLs ?? [],
         config.baseUrl
       ]) {
         if (baseUrl && config.tokenEndpoint?.startsWith(baseUrl)) {
@@ -2250,16 +2259,16 @@ var AuthenticationHelper = class {
       }
     }
     if (config.shouldReplayAfterRefresh) {
-      this._dataLayer.setTemporaryDataParameter(CUSTOM_GRANT_CONFIG, JSON.stringify(config));
+      this._storageManager.setTemporaryDataParameter(CUSTOM_GRANT_CONFIG, JSON.stringify(config));
     }
     if (useDefaultEndpoint || matches) {
-      return this._authenticationClient.requestCustomGrant(config).then(async (response) => {
+      return this._authenticationClient.exchangeToken(config).then(async (response) => {
         if (enableRetrievingSignOutURLFromSession && typeof enableRetrievingSignOutURLFromSession === "function") {
           enableRetrievingSignOutURLFromSession(config);
         }
         if (config.returnsSession) {
           this._spaHelper.refreshAccessTokenAutomatically(this);
-          return this._authenticationClient.getBasicUserInfo();
+          return this._authenticationClient.getUser();
         } else {
           return response;
         }
@@ -2277,7 +2286,7 @@ var AuthenticationHelper = class {
     }
   }
   async getCustomGrantConfigData() {
-    const configString = await this._dataLayer.getTemporaryDataParameter(CUSTOM_GRANT_CONFIG);
+    const configString = await this._storageManager.getTemporaryDataParameter(CUSTOM_GRANT_CONFIG);
     if (configString) {
       return JSON.parse(configString);
     } else {
@@ -2289,10 +2298,10 @@ var AuthenticationHelper = class {
       await this._authenticationClient.refreshAccessToken();
       const customGrantConfig = await this.getCustomGrantConfigData();
       if (customGrantConfig) {
-        await this.requestCustomGrant(customGrantConfig, enableRetrievingSignOutURLFromSession);
+        await this.exchangeToken(customGrantConfig, enableRetrievingSignOutURLFromSession);
       }
       this._spaHelper.refreshAccessTokenAutomatically(this);
-      return this._authenticationClient.getBasicUserInfo();
+      return this._authenticationClient.getUser();
     } catch (error) {
       const refreshTokenError = {
         type: REFRESH_ACCESS_TOKEN_ERR0R
@@ -2325,7 +2334,7 @@ var AuthenticationHelper = class {
   }
   async httpRequest(httpClient, requestConfig, isHttpHandlerEnabled, httpErrorCallback, httpFinishCallback, enableRetrievingSignOutURLFromSession) {
     let matches = false;
-    const config = await this._dataLayer.getConfigData();
+    const config = await this._storageManager.getConfigData();
     for (const baseUrl of [...await config?.resourceServerURLs ?? [], config.baseUrl]) {
       if (baseUrl && requestConfig?.url?.startsWith(baseUrl)) {
         matches = true;
@@ -2410,7 +2419,7 @@ var AuthenticationHelper = class {
   }
   async httpRequestAll(requestConfigs, httpClient, isHttpHandlerEnabled, httpErrorCallback, httpFinishCallback) {
     let matches = true;
-    const config = await this._dataLayer.getConfigData();
+    const config = await this._storageManager.getConfigData();
     for (const requestConfig of requestConfigs) {
       let urlMatches = false;
       for (const baseUrl of [...(await config)?.resourceServerURLs ?? [], config.baseUrl]) {
@@ -2489,7 +2498,7 @@ var AuthenticationHelper = class {
     }
   }
   async requestAccessToken(authorizationCode, sessionState, checkSession, pkce, state, tokenRequestConfig) {
-    const config = await this._dataLayer.getConfigData();
+    const config = await this._storageManager.getConfigData();
     if (config.storage === "browserMemory" /* BrowserMemory */ && config.enablePKCE && sessionState) {
       const pkce2 = SPAUtils.getPKCE(extractPkceStorageKeyFromState(sessionState));
       await this._authenticationClient.setPKCECode(extractPkceStorageKeyFromState(sessionState), pkce2);
@@ -2499,7 +2508,7 @@ var AuthenticationHelper = class {
     if (authorizationCode) {
       return this._authenticationClient.requestAccessToken(authorizationCode, sessionState ?? "", state ?? "", void 0, tokenRequestConfig).then(async () => {
         if (config.storage !== "webWorker" /* WebWorker */) {
-          SPAUtils.setSignOutURL(await this._authenticationClient.getSignOutURL(), config.clientID, this._instanceID);
+          SPAUtils.setSignOutURL(await this._authenticationClient.getSignOutUrl(), config.clientId, this._instanceID);
           if (this._spaHelper) {
             this._spaHelper.clearRefreshTokenTimeout();
             this._spaHelper.refreshAccessTokenAutomatically(this);
@@ -2512,7 +2521,7 @@ var AuthenticationHelper = class {
             this._spaHelper.refreshAccessTokenAutomatically(this);
           }
         }
-        return this._authenticationClient.getBasicUserInfo();
+        return this._authenticationClient.getUser();
       }).catch((error) => {
         return Promise.reject(error);
       });
@@ -2575,7 +2584,7 @@ var AuthenticationHelper = class {
     });
   }
   async handleSignIn(shouldStopAuthn, checkSession, tryRetrievingUserInfo) {
-    const config = await this._dataLayer.getConfigData();
+    const config = await this._storageManager.getConfigData();
     if (await shouldStopAuthn()) {
       return Promise.resolve({
         allowedScopes: "",
@@ -2588,13 +2597,13 @@ var AuthenticationHelper = class {
       });
     }
     if (config.storage !== "webWorker" /* WebWorker */) {
-      if (await this._authenticationClient.isAuthenticated()) {
+      if (await this._authenticationClient.isSignedIn()) {
         this._spaHelper.clearRefreshTokenTimeout();
         this._spaHelper.refreshAccessTokenAutomatically(this);
         if (config.enableOIDCSessionManagement) {
           checkSession();
         }
-        return Promise.resolve(await this._authenticationClient.getBasicUserInfo());
+        return Promise.resolve(await this._authenticationClient.getUser());
       }
     }
     const error = new URL(window.location.href).searchParams.get(ERROR);
@@ -2630,35 +2639,35 @@ var AuthenticationHelper = class {
       }
     }
   }
-  async getBasicUserInfo() {
-    return this._authenticationClient.getBasicUserInfo();
+  async getUser() {
+    return this._authenticationClient.getUser();
   }
-  async getDecodedIDToken() {
-    return this._authenticationClient.getDecodedIDToken();
+  async getDecodedIdToken() {
+    return this._authenticationClient.getDecodedIdToken();
   }
   async getDecodedIDPIDToken() {
-    return this._authenticationClient.getDecodedIDToken();
+    return this._authenticationClient.getDecodedIdToken();
   }
-  async getCryptoHelper() {
-    return this._authenticationClient.getCryptoHelper();
+  async getCrypto() {
+    return this._authenticationClient.getCrypto();
   }
-  async getIDToken() {
-    return this._authenticationClient.getIDToken();
+  async getIdToken() {
+    return this._authenticationClient.getIdToken();
   }
-  async getOIDCServiceEndpoints() {
-    return this._authenticationClient.getOIDCServiceEndpoints();
+  async getOpenIDProviderEndpoints() {
+    return this._authenticationClient.getOpenIDProviderEndpoints();
   }
   async getAccessToken() {
     return this._authenticationClient.getAccessToken();
   }
   async getIDPAccessToken() {
-    return (await this._dataLayer.getSessionData())?.access_token;
+    return (await this._storageManager.getSessionData())?.access_token;
   }
-  getDataLayer() {
-    return this._dataLayer;
+  getStorageManager() {
+    return this._storageManager;
   }
-  async isAuthenticated() {
-    return this._authenticationClient.isAuthenticated();
+  async isSignedIn() {
+    return this._authenticationClient.isSignedIn();
   }
 };
 
@@ -2667,32 +2676,32 @@ import { TokenConstants } from "@asgardeo/javascript";
 var SPAHelper = class {
   constructor(authClient) {
     __publicField(this, "_authenticationClient");
-    __publicField(this, "_dataLayer");
+    __publicField(this, "_storageManager");
     this._authenticationClient = authClient;
-    this._dataLayer = this._authenticationClient.getDataLayer();
+    this._storageManager = this._authenticationClient.getStorageManager();
   }
   async refreshAccessTokenAutomatically(authenticationHelper) {
-    const shouldRefreshAutomatically = (await this._dataLayer.getConfigData())?.periodicTokenRefresh ?? false;
+    const shouldRefreshAutomatically = (await this._storageManager.getConfigData())?.periodicTokenRefresh ?? false;
     if (!shouldRefreshAutomatically) {
       return;
     }
-    const sessionData = await this._dataLayer.getSessionData();
+    const sessionData = await this._storageManager.getSessionData();
     if (sessionData.refresh_token) {
       const expiryTime = parseInt(sessionData.expires_in);
       const time = expiryTime <= 10 ? expiryTime : expiryTime - 10;
       const timer = setTimeout(async () => {
         await authenticationHelper.refreshAccessToken();
       }, time * 1e3);
-      await this._dataLayer.setTemporaryDataParameter(
+      await this._storageManager.setTemporaryDataParameter(
         TokenConstants.Storage.StorageKeys.REFRESH_TOKEN_TIMER,
         JSON.stringify(timer)
       );
     }
   }
   async getRefreshTimeoutTimer() {
-    if (await this._dataLayer.getTemporaryDataParameter(TokenConstants.Storage.StorageKeys.REFRESH_TOKEN_TIMER)) {
+    if (await this._storageManager.getTemporaryDataParameter(TokenConstants.Storage.StorageKeys.REFRESH_TOKEN_TIMER)) {
       return JSON.parse(
-        await this._dataLayer.getTemporaryDataParameter(
+        await this._storageManager.getTemporaryDataParameter(
           TokenConstants.Storage.StorageKeys.REFRESH_TOKEN_TIMER
         )
       );
@@ -2725,15 +2734,15 @@ var SessionManagementHelper = /* @__PURE__ */ (() => {
   let _checkSessionIntervalTimeout;
   let _storage;
   let _setSessionState;
-  let _getAuthorizationURL;
-  const initialize = (clientID, checkSessionEndpoint, getSessionState, interval, sessionRefreshInterval, redirectURL, getAuthorizationURL) => {
-    _clientID = clientID;
+  let _getSignInUrl;
+  const initialize = (clientId, checkSessionEndpoint, getSessionState, interval, sessionRefreshInterval, redirectURL, getSignInUrl) => {
+    _clientID = clientId;
     _checkSessionEndpoint = checkSessionEndpoint;
     _sessionState = getSessionState;
     _interval = interval;
     _redirectURL = redirectURL;
     _sessionRefreshInterval = sessionRefreshInterval;
-    _getAuthorizationURL = getAuthorizationURL;
+    _getSignInUrl = getSignInUrl;
     if (_interval > -1) {
       initiateCheckSession();
     }
@@ -2799,7 +2808,7 @@ var SessionManagementHelper = /* @__PURE__ */ (() => {
       if (_storage === "browserMemory" /* BrowserMemory */ || _storage === "webWorker" /* WebWorker */) {
         window?.addEventListener("message", receiveMessageListener);
       }
-      const promptNoneURL = await _getAuthorizationURL({
+      const promptNoneURL = await _getSignInUrl({
         prompt: "none",
         response_mode: "query",
         state: STATE
@@ -2857,7 +2866,7 @@ var SessionManagementHelper = /* @__PURE__ */ (() => {
         }
         SPAUtils.setPromptNoneRequestSent(false);
         const signOutURL = await _signOut();
-        await AsgardeoAuthClient4.clearUserSessionData();
+        await AsgardeoAuthClient4.clearSession();
         parent.location.href = signOutURL;
         window.location.href = "about:blank";
         await SPAUtils.waitTillPageRedirect();
@@ -2906,15 +2915,6 @@ var SessionManagementHelper = /* @__PURE__ */ (() => {
   };
 })();
 
-// src/__legacy__/worker/worker-receiver.ts
-import { AsgardeoAuthException as AsgardeoAuthException3 } from "@asgardeo/javascript";
-
-// src/__legacy__/worker/worker-core.ts
-import {
-  AsgardeoAuthClient as AsgardeoAuthClient5,
-  OIDCRequestConstants as OIDCRequestConstants3
-} from "@asgardeo/javascript";
-
 // src/__legacy__/http-client/clients/axios-http-client.ts
 import axios from "axios";
 
@@ -3166,10 +3166,10 @@ var SPACryptoUtils = class {
   generateRandomBytes(length) {
     return (0, import_randombytes.default)(length);
   }
-  verifyJwt(idToken, jwk, algorithms, clientID, issuer, subject, clockTolerance, validateJwtIssuer) {
+  verifyJwt(idToken, jwk, algorithms, clientId, issuer, subject, clockTolerance, validateJwtIssuer) {
     const jwtVerifyOptions = {
       algorithms,
-      audience: clientID,
+      audience: clientId,
       clockTolerance,
       subject
     };
@@ -3196,19 +3196,42 @@ var SPACryptoUtils = class {
   }
 };
 
-// src/__legacy__/worker/worker-core.ts
-var WebWorkerCore = async (config, getAuthHelper) => {
-  const _store = new MemoryStore();
+// src/__legacy__/clients/main-thread-client.ts
+var initiateStore = (store) => {
+  switch (store) {
+    case "localStorage" /* LocalStorage */:
+      return new LocalStore();
+    case "sessionStorage" /* SessionStorage */:
+      return new SessionStore();
+    case "browserMemory" /* BrowserMemory */:
+      return new MemoryStore();
+    default:
+      return new SessionStore();
+  }
+};
+var MainThreadClient = async (instanceID, config, getAuthHelper) => {
+  const _store = initiateStore(config.storage);
   const _cryptoUtils = new SPACryptoUtils();
   const _authenticationClient = new AsgardeoAuthClient5();
-  await _authenticationClient.initialize(config, _store, _cryptoUtils);
+  await _authenticationClient.initialize(config, _store, _cryptoUtils, instanceID);
   const _spaHelper = new SPAHelper(_authenticationClient);
-  const _authenticationHelper = getAuthHelper(
-    _authenticationClient,
-    _spaHelper
+  const _dataLayer = _authenticationClient.getStorageManager();
+  const _sessionManagementHelper = await SessionManagementHelper(
+    async () => {
+      return _authenticationClient.getSignOutUrl();
+    },
+    config.storage ?? "sessionStorage" /* SessionStorage */,
+    (sessionState) => _dataLayer.setSessionDataParameter(
+      OIDCRequestConstants3.Params.SESSION_STATE,
+      sessionState ?? ""
+    )
   );
-  const _dataLayer = _authenticationClient.getDataLayer();
+  const _authenticationHelper = getAuthHelper(_authenticationClient, _spaHelper);
+  let _getSignOutURLFromSessionStorage = false;
   const _httpClient = HttpClient.getInstance();
+  let _isHttpHandlerEnabled = true;
+  let _httpErrorCallback;
+  let _httpFinishCallback;
   const attachToken = async (request) => {
     await _authenticationHelper.attachTokenToRequestConfig(request);
   };
@@ -3222,47 +3245,156 @@ var WebWorkerCore = async (config, getAuthHelper) => {
   const setHttpRequestFinishCallback = (callback) => {
     _httpClient?.setHttpRequestFinishCallback && _httpClient.setHttpRequestFinishCallback(callback);
   };
+  const setHttpRequestErrorCallback = (callback) => {
+    _httpErrorCallback = callback;
+  };
   const httpRequest = async (requestConfig) => {
-    return await _authenticationHelper.httpRequest(_httpClient, requestConfig);
+    return await _authenticationHelper.httpRequest(
+      _httpClient,
+      requestConfig,
+      _isHttpHandlerEnabled,
+      _httpErrorCallback,
+      _httpFinishCallback
+    );
   };
   const httpRequestAll = async (requestConfigs) => {
-    return await _authenticationHelper.httpRequestAll(requestConfigs, _httpClient);
+    return await _authenticationHelper.httpRequestAll(
+      requestConfigs,
+      _httpClient,
+      _isHttpHandlerEnabled,
+      _httpErrorCallback,
+      _httpFinishCallback
+    );
+  };
+  const getHttpClient = () => {
+    return _httpClient;
   };
   const enableHttpHandler = () => {
     _authenticationHelper.enableHttpHandler(_httpClient);
+    _isHttpHandlerEnabled = true;
+    return true;
   };
   const disableHttpHandler = () => {
     _authenticationHelper.disableHttpHandler(_httpClient);
+    _isHttpHandlerEnabled = false;
+    return true;
   };
-  const getAuthorizationURL = async (params) => {
-    return _authenticationClient.getAuthorizationURL(params).then(async (url) => {
-      const urlObject = new URL(url);
-      const state = urlObject.searchParams.get(OIDCRequestConstants3.Params.STATE) ?? "";
-      const pkce = await _authenticationClient.getPKCECode(state);
-      return { authorizationURL: url, pkce };
-    }).catch((error) => Promise.reject(error));
+  const checkSession = async () => {
+    const oidcEndpoints = await _authenticationClient.getOpenIDProviderEndpoints();
+    const config2 = await _dataLayer.getConfigData();
+    _authenticationHelper.initializeSessionManger(
+      config2,
+      oidcEndpoints,
+      async () => (await _authenticationClient.getUserSession()).sessionState,
+      async (params) => _authenticationClient.getSignInUrl(params),
+      _sessionManagementHelper
+    );
   };
-  const startAutoRefreshToken = async () => {
-    _spaHelper.clearRefreshTokenTimeout();
-    _spaHelper.refreshAccessTokenAutomatically(_authenticationHelper);
-    return;
+  const shouldStopAuthn = async () => {
+    return await _sessionManagementHelper.receivePromptNoneResponse(async (sessionState) => {
+      await _dataLayer.setSessionDataParameter(
+        OIDCRequestConstants3.Params.SESSION_STATE,
+        sessionState ?? ""
+      );
+      return;
+    });
   };
-  const requestAccessToken = async (authorizationCode, sessionState, pkce, state) => {
-    return await _authenticationHelper.requestAccessToken(authorizationCode, sessionState, void 0, pkce, state);
+  const setSessionStatus = async (sessionStatus) => {
+    await _dataLayer.setSessionStatus(sessionStatus);
+  };
+  const signIn = async (signInConfig, authorizationCode, sessionState, state, tokenRequestConfig) => {
+    if (signInConfig["flow"]) {
+      return handleApplicationNativeAuthentication({
+        url: signInConfig["flow"]["requestConfig"]["url"],
+        payload: signInConfig["flow"]["payload"]
+      });
+    }
+    const basicUserInfo = await _authenticationHelper.handleSignIn(shouldStopAuthn, checkSession, void 0);
+    if (basicUserInfo) {
+      return basicUserInfo;
+    } else {
+      let resolvedAuthorizationCode;
+      let resolvedSessionState;
+      let resolvedState;
+      let resolvedTokenRequestConfig = { params: {} };
+      if (config?.responseMode === "form_post" && authorizationCode) {
+        resolvedAuthorizationCode = authorizationCode;
+        resolvedSessionState = sessionState ?? "";
+        resolvedState = state ?? "";
+      } else {
+        resolvedAuthorizationCode = new URL(window.location.href).searchParams.get(OIDCRequestConstants3.Params.AUTHORIZATION_CODE) ?? "";
+        resolvedSessionState = new URL(window.location.href).searchParams.get(OIDCRequestConstants3.Params.SESSION_STATE) ?? "";
+        resolvedState = new URL(window.location.href).searchParams.get(OIDCRequestConstants3.Params.STATE) ?? "";
+        SPAUtils.removeAuthorizationCode();
+      }
+      if (resolvedAuthorizationCode && resolvedState) {
+        setSessionStatus("true");
+        const storedTokenRequestConfig = await _dataLayer.getTemporaryDataParameter(TOKEN_REQUEST_CONFIG_KEY);
+        if (storedTokenRequestConfig && typeof storedTokenRequestConfig === "string") {
+          resolvedTokenRequestConfig = JSON.parse(storedTokenRequestConfig);
+        }
+        return requestAccessToken(
+          resolvedAuthorizationCode,
+          resolvedSessionState,
+          resolvedState,
+          resolvedTokenRequestConfig
+        );
+      }
+      return _authenticationClient.getSignInUrl(signInConfig).then(async (url) => {
+        if (config.storage === "browserMemory" /* BrowserMemory */ && config.enablePKCE) {
+          const pkceKey = extractPkceStorageKeyFromState2(resolvedState);
+          SPAUtils.setPKCE(pkceKey, await _authenticationClient.getPKCECode(resolvedState));
+        }
+        if (tokenRequestConfig) {
+          _dataLayer.setTemporaryDataParameter(TOKEN_REQUEST_CONFIG_KEY, JSON.stringify(tokenRequestConfig));
+        }
+        if (signInConfig["response_mode"] === "direct") {
+          const authorizeUrl = new URL(url);
+          return initializeApplicationNativeAuthentication({
+            url: `${authorizeUrl.origin}${authorizeUrl.pathname}`,
+            payload: Object.fromEntries(authorizeUrl.searchParams.entries())
+          });
+        } else {
+          location.href = url;
+        }
+        await SPAUtils.waitTillPageRedirect();
+        return Promise.resolve({
+          allowedScopes: "",
+          displayName: "",
+          email: "",
+          sessionState: "",
+          sub: "",
+          tenantDomain: "",
+          username: ""
+        });
+      });
+    }
   };
   const signOut = async () => {
+    if (await _authenticationClient.isSignedIn() && !_getSignOutURLFromSessionStorage) {
+      location.href = await _authenticationClient.getSignOutUrl();
+    } else {
+      location.href = SPAUtils.getSignOutUrl(config.clientId, instanceID);
+    }
     _spaHelper.clearRefreshTokenTimeout();
-    return await _authenticationClient.getSignOutURL();
+    await _dataLayer.removeOIDCProviderMetaData();
+    await _dataLayer.removeTemporaryData();
+    await _dataLayer.removeSessionData();
+    await _dataLayer.removeSessionStatus();
+    await SPAUtils.waitTillPageRedirect();
+    return true;
   };
-  const getSignOutURL = async () => {
-    return await _authenticationClient.getSignOutURL();
+  const enableRetrievingSignOutURLFromSession = (config2) => {
+    if (config2.preventSignOutURLUpdate) {
+      _getSignOutURLFromSessionStorage = true;
+    }
   };
-  const requestCustomGrant = async (config2) => {
-    return await _authenticationHelper.requestCustomGrant(config2);
+  const exchangeToken = async (config2) => {
+    return await _authenticationHelper.exchangeToken(config2, enableRetrievingSignOutURLFromSession);
   };
   const refreshAccessToken = async () => {
     try {
-      return await _authenticationHelper.refreshAccessToken();
+      return await _authenticationHelper.refreshAccessToken(enableRetrievingSignOutURLFromSession);
     } catch (error) {
       return Promise.reject(error);
     }
@@ -3270,300 +3402,127 @@ var WebWorkerCore = async (config, getAuthHelper) => {
   const revokeAccessToken = async () => {
     const timer = await _spaHelper.getRefreshTimeoutTimer();
     return _authenticationClient.revokeAccessToken().then(() => {
+      _sessionManagementHelper.reset();
       _spaHelper.clearRefreshTokenTimeout(timer);
       return Promise.resolve(true);
     }).catch((error) => Promise.reject(error));
   };
-  const getBasicUserInfo = async () => {
-    return _authenticationHelper.getBasicUserInfo();
+  const requestAccessToken = async (resolvedAuthorizationCode, resolvedSessionState, resolvedState, tokenRequestConfig) => {
+    return await _authenticationHelper.requestAccessToken(
+      resolvedAuthorizationCode,
+      resolvedSessionState,
+      checkSession,
+      void 0,
+      resolvedState,
+      tokenRequestConfig
+    );
+  };
+  const constructSilentSignInUrl = async (additionalParams = {}) => {
+    const config2 = await _dataLayer.getConfigData();
+    const urlString = await _authenticationClient.getSignInUrl({
+      prompt: "none",
+      state: SILENT_SIGN_IN_STATE,
+      ...additionalParams
+    });
+    const urlObject = new URL(urlString);
+    urlObject.searchParams.set("response_mode", "query");
+    const url = urlObject.toString();
+    if (config2.storage === "browserMemory" /* BrowserMemory */ && config2.enablePKCE) {
+      const state = urlObject.searchParams.get(OIDCRequestConstants3.Params.STATE);
+      SPAUtils.setPKCE(
+        extractPkceStorageKeyFromState2(state ?? ""),
+        await _authenticationClient.getPKCECode(state ?? "")
+      );
+    }
+    return url;
+  };
+  const trySignInSilently = async (additionalParams, tokenRequestConfig) => {
+    return await _authenticationHelper.trySignInSilently(
+      constructSilentSignInUrl,
+      requestAccessToken,
+      _sessionManagementHelper,
+      additionalParams,
+      tokenRequestConfig
+    );
   };
-  const getDecodedIDToken = async () => {
-    return _authenticationHelper.getDecodedIDToken();
+  const getUser = async () => {
+    return _authenticationHelper.getUser();
   };
-  const getCryptoHelper = async () => {
-    return _authenticationHelper.getCryptoHelper();
+  const getDecodedIdToken = async () => {
+    return _authenticationHelper.getDecodedIdToken();
   };
-  const getDecodedIDPIDToken = async () => {
-    return _authenticationHelper.getDecodedIDPIDToken();
+  const getCrypto = async () => {
+    return _authenticationHelper.getCrypto();
   };
-  const getIDToken = async () => {
-    return _authenticationHelper.getIDToken();
+  const getIdToken = async () => {
+    return _authenticationHelper.getIdToken();
   };
-  const getOIDCServiceEndpoints = async () => {
-    return _authenticationHelper.getOIDCServiceEndpoints();
+  const getOpenIDProviderEndpoints = async () => {
+    return _authenticationHelper.getOpenIDProviderEndpoints();
   };
-  const getAccessToken = () => {
+  const getAccessToken = async () => {
     return _authenticationHelper.getAccessToken();
   };
-  const isAuthenticated = () => {
-    return _authenticationHelper.isAuthenticated();
+  const getStorageManager = async () => {
+    return _authenticationHelper.getStorageManager();
   };
-  const setSessionState = async (sessionState) => {
-    await _dataLayer.setSessionDataParameter(
-      OIDCRequestConstants3.Params.SESSION_STATE,
-      sessionState
-    );
-    return;
+  const getConfigData = async () => {
+    return await _dataLayer.getConfigData();
   };
-  const updateConfig = async (config2) => {
-    await _authenticationClient.updateConfig(config2);
-    return;
+  const isSignedIn = async () => {
+    return _authenticationHelper.isSignedIn();
   };
-  const getConfigData = async () => {
-    return _dataLayer.getConfigData();
+  const isSessionActive = async () => {
+    return await _dataLayer.getSessionStatus() === "true";
+  };
+  const reInitialize = async (newConfig) => {
+    const existingConfig = await _dataLayer.getConfigData();
+    const isCheckSessionIframeDifferent = !(existingConfig && existingConfig.endpoints && existingConfig.endpoints.checkSessionIframe && newConfig && newConfig.endpoints && newConfig.endpoints.checkSessionIframe && existingConfig.endpoints.checkSessionIframe === newConfig.endpoints.checkSessionIframe);
+    const config2 = { ...existingConfig, ...newConfig };
+    await _authenticationClient.reInitialize(config2);
+    if (config2.enableOIDCSessionManagement && isCheckSessionIframeDifferent) {
+      _sessionManagementHelper.reset();
+      checkSession();
+    }
   };
   return {
     disableHttpHandler,
     enableHttpHandler,
     getAccessToken,
-    getAuthorizationURL,
-    getBasicUserInfo,
+    getUser,
     getConfigData,
-    getCryptoHelper,
-    getDecodedIDPIDToken,
-    getDecodedIDToken,
-    getIDToken,
-    getOIDCServiceEndpoints,
-    getSignOutURL,
+    getCrypto,
+    getStorageManager,
+    getDecodedIdToken,
+    getHttpClient,
+    getIdToken,
+    getOpenIDProviderEndpoints,
     httpRequest,
     httpRequestAll,
-    isAuthenticated,
+    isSignedIn,
+    isSessionActive,
     refreshAccessToken,
-    requestAccessToken,
-    requestCustomGrant,
+    exchangeToken,
     revokeAccessToken,
+    setHttpRequestErrorCallback,
     setHttpRequestFinishCallback,
     setHttpRequestStartCallback,
     setHttpRequestSuccessCallback,
-    setSessionState,
+    signIn,
     signOut,
-    startAutoRefreshToken,
-    updateConfig
+    trySignInSilently,
+    reInitialize
   };
 };
 
-// src/__legacy__/worker/worker-receiver.ts
-var workerReceiver = (getAuthHelper) => {
-  const ctx = self;
-  let webWorker;
-  ctx.onmessage = async ({ data, ports }) => {
-    const port = ports[0];
-    if (data.type !== INIT && !webWorker) {
-      port.postMessage(
-        MessageUtils.generateFailureMessage(
-          new AsgardeoAuthException3(
-            "SPA-CLIENT_WORKER-ONMSG-NF01",
-            "The web worker has not been initialized yet.",
-            "The initialize method needs to be called before the specified operation can be carried out."
-          )
-        )
-      );
-      return;
-    }
-    switch (data.type) {
-      case INIT:
-        try {
-          const config = { ...data.data };
-          webWorker = await WebWorkerCore(config, getAuthHelper);
-          webWorker.setHttpRequestFinishCallback(onRequestFinishCallback);
-          webWorker.setHttpRequestStartCallback(onRequestStartCallback);
-          webWorker.setHttpRequestSuccessCallback(onRequestSuccessCallback);
-          port.postMessage(MessageUtils.generateSuccessMessage());
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case GET_AUTH_URL:
-        webWorker.getAuthorizationURL(data?.data).then((response) => {
-          port.postMessage(MessageUtils.generateSuccessMessage(response));
-        }).catch((error) => {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        });
-        break;
-      case REQUEST_ACCESS_TOKEN:
-        webWorker.requestAccessToken(data?.data?.code, data?.data?.sessionState, data?.data?.pkce, data?.data?.state).then((response) => {
-          port.postMessage(MessageUtils.generateSuccessMessage(response));
-        }).catch((error) => {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        });
-        break;
-      case HTTP_REQUEST: {
-        const request = data.data;
-        const requestData = request?.data;
-        if (data.data?.data?.formData === true) {
-          const formData = new FormData();
-          for (const key in requestData) {
-            if (key === "formData") {
-              continue;
-            }
-            formData.append(key, requestData[key]);
-          }
-          request.data = formData;
-        }
-        webWorker.httpRequest(request).then((response) => {
-          port.postMessage(MessageUtils.generateSuccessMessage(response));
-        }).catch((error) => {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        });
-        break;
-      }
-      case HTTP_REQUEST_ALL:
-        webWorker.httpRequestAll(data.data).then((response) => {
-          port.postMessage(MessageUtils.generateSuccessMessage(response));
-        }).catch((error) => {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        });
-        break;
-      case SIGN_OUT:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.signOut()));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case REQUEST_CUSTOM_GRANT:
-        webWorker.requestCustomGrant(data.data).then((response) => {
-          port.postMessage(MessageUtils.generateSuccessMessage(response));
-        }).catch((error) => {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        });
-        break;
-      case REVOKE_ACCESS_TOKEN:
-        webWorker.revokeAccessToken().then((response) => {
-          port.postMessage(MessageUtils.generateSuccessMessage(response));
-        }).catch((error) => {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        });
-        break;
-      case GET_OIDC_SERVICE_ENDPOINTS:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getOIDCServiceEndpoints()));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case GET_BASIC_USER_INFO:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getBasicUserInfo()));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case GET_DECODED_ID_TOKEN:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getDecodedIDToken()));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case GET_CRYPTO_HELPER:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getCryptoHelper()));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case GET_ID_TOKEN:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getIDToken()));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case ENABLE_HTTP_HANDLER:
-        webWorker.enableHttpHandler();
-        port.postMessage(MessageUtils.generateSuccessMessage());
-        break;
-      case DISABLE_HTTP_HANDLER:
-        webWorker.disableHttpHandler();
-        port.postMessage(MessageUtils.generateSuccessMessage());
-        break;
-      case IS_AUTHENTICATED:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.isAuthenticated()));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case GET_SIGN_OUT_URL:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getSignOutURL()));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case REFRESH_ACCESS_TOKEN:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.refreshAccessToken()));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case START_AUTO_REFRESH_TOKEN:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(webWorker.startAutoRefreshToken()));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case SET_SESSION_STATE:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.setSessionState(data?.data)));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case UPDATE_CONFIG:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.updateConfig(data?.data)));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      case GET_CONFIG_DATA:
-        try {
-          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getConfigData()));
-        } catch (error) {
-          port.postMessage(MessageUtils.generateFailureMessage(error));
-        }
-        break;
-      default:
-        port?.postMessage(
-          MessageUtils.generateFailureMessage(
-            new AsgardeoAuthException3(
-              "SPA-CLIENT_WORKER-ONMSG-IV02",
-              "The message type is invalid.",
-              `The message type provided, ${data.type}, is invalid.`
-            )
-          )
-        );
-    }
-  };
-  const onRequestStartCallback = () => {
-    ctx.postMessage({ type: REQUEST_START });
-  };
-  const onRequestSuccessCallback = (response) => {
-    ctx.postMessage({ data: JSON.stringify(response ?? ""), type: REQUEST_SUCCESS });
-  };
-  const onRequestFinishCallback = () => {
-    ctx.postMessage({ type: REQUEST_FINISH });
-  };
-};
-
-// src/worker.ts
-workerReceiver((authClient, spaHelper) => {
-  return new AuthenticationHelper(authClient, spaHelper);
-});
-var worker_default = {};
-
-// src/__legacy__/clients/main-thread-client.ts
+// src/__legacy__/clients/web-worker-client.ts
 import {
-  AsgardeoAuthClient as AsgardeoAuthClient7,
-  ResponseMode,
+  AsgardeoAuthClient as AsgardeoAuthClient6,
+  AsgardeoAuthException as AsgardeoAuthException3,
   OIDCRequestConstants as OIDCRequestConstants4,
-  extractPkceStorageKeyFromState as extractPkceStorageKeyFromState2
+  extractPkceStorageKeyFromState as extractPkceStorageKeyFromState3
 } from "@asgardeo/javascript";
-var initiateStore = (store) => {
+var initiateStore2 = (store) => {
   switch (store) {
     case "localStorage" /* LocalStorage */:
       return new LocalStore();
@@ -3575,109 +3534,308 @@ var initiateStore = (store) => {
       return new SessionStore();
   }
 };
-var MainThreadClient = async (instanceID, config, getAuthHelper) => {
-  const _store = initiateStore(config.storage);
+var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
+  let httpClientHandlers;
+  const _requestTimeout = config?.requestTimeout ?? 6e4;
+  let _isHttpHandlerEnabled = true;
+  let _getSignOutURLFromSessionStorage = false;
+  const _store = initiateStore2(config.storage);
   const _cryptoUtils = new SPACryptoUtils();
-  const _authenticationClient = new AsgardeoAuthClient7();
+  const _authenticationClient = new AsgardeoAuthClient6();
   await _authenticationClient.initialize(config, _store, _cryptoUtils, instanceID);
   const _spaHelper = new SPAHelper(_authenticationClient);
-  const _dataLayer = _authenticationClient.getDataLayer();
   const _sessionManagementHelper = await SessionManagementHelper(
     async () => {
-      return _authenticationClient.getSignOutURL();
+      const message = {
+        type: SIGN_OUT
+      };
+      try {
+        const signOutURL = await communicate(message);
+        return signOutURL;
+      } catch {
+        return SPAUtils.getSignOutUrl(config.clientId, instanceID);
+      }
     },
-    config.storage ?? "sessionStorage" /* SessionStorage */,
-    (sessionState) => _dataLayer.setSessionDataParameter(
-      OIDCRequestConstants4.Params.SESSION_STATE,
-      sessionState ?? ""
-    )
+    config.storage,
+    (sessionState) => setSessionState(sessionState)
   );
-  const _authenticationHelper = getAuthHelper(_authenticationClient, _spaHelper);
-  let _getSignOutURLFromSessionStorage = false;
-  const _httpClient = HttpClient.getInstance();
-  let _isHttpHandlerEnabled = true;
-  let _httpErrorCallback;
-  let _httpFinishCallback;
-  const attachToken = async (request) => {
-    await _authenticationHelper.attachTokenToRequestConfig(request);
+  const _authenticationHelper = getAuthHelper(
+    _authenticationClient,
+    _spaHelper
+  );
+  const worker = new webWorker();
+  const communicate = (message) => {
+    const channel = new MessageChannel();
+    worker.postMessage(message, [channel.port2]);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(
+          new AsgardeoAuthException3(
+            "SPA-WEB_WORKER_CLIENT-COM-TO01",
+            "Operation timed out.",
+            "No response was received from the web worker for " + _requestTimeout / 1e3 + " since dispatching the request"
+          )
+        );
+      }, _requestTimeout);
+      return channel.port1.onmessage = ({ data }) => {
+        clearTimeout(timer);
+        channel.port1.close();
+        channel.port2.close();
+        if (data?.success) {
+          const responseData = data?.data ? JSON.parse(data?.data) : null;
+          if (data?.blob) {
+            responseData.data = data?.blob;
+          }
+          resolve(responseData);
+        } else {
+          reject(data.error ? JSON.parse(data.error) : null);
+        }
+      };
+    });
   };
-  _httpClient?.init && await _httpClient.init(true, attachToken);
-  const setHttpRequestStartCallback = (callback) => {
-    _httpClient?.setHttpRequestStartCallback && _httpClient.setHttpRequestStartCallback(callback);
-  };
-  const setHttpRequestSuccessCallback = (callback) => {
-    _httpClient?.setHttpRequestSuccessCallback && _httpClient.setHttpRequestSuccessCallback(callback);
+  const exchangeToken = (requestParams) => {
+    const message = {
+      data: requestParams,
+      type: REQUEST_CUSTOM_GRANT
+    };
+    return communicate(message).then((response) => {
+      if (requestParams.preventSignOutURLUpdate) {
+        _getSignOutURLFromSessionStorage = true;
+      }
+      return Promise.resolve(response);
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
   };
-  const setHttpRequestFinishCallback = (callback) => {
-    _httpClient?.setHttpRequestFinishCallback && _httpClient.setHttpRequestFinishCallback(callback);
+  const httpRequest = (config2) => {
+    if (config2?.data && config2?.data instanceof FormData) {
+      config2.data = { ...Object.fromEntries((config2?.data).entries()), formData: true };
+    }
+    const message = {
+      data: config2,
+      type: HTTP_REQUEST
+    };
+    return communicate(message).then((response) => {
+      return Promise.resolve(response);
+    }).catch(async (error) => {
+      if (_isHttpHandlerEnabled) {
+        if (typeof httpClientHandlers.requestErrorCallback === "function") {
+          await httpClientHandlers.requestErrorCallback(error);
+        }
+        if (typeof httpClientHandlers.requestFinishCallback === "function") {
+          httpClientHandlers.requestFinishCallback();
+        }
+      }
+      return Promise.reject(error);
+    });
   };
-  const setHttpRequestErrorCallback = (callback) => {
-    _httpErrorCallback = callback;
+  const httpRequestAll = (configs) => {
+    const message = {
+      data: configs,
+      type: HTTP_REQUEST_ALL
+    };
+    return communicate(message).then((response) => {
+      return Promise.resolve(response);
+    }).catch(async (error) => {
+      if (_isHttpHandlerEnabled) {
+        if (typeof httpClientHandlers.requestErrorCallback === "function") {
+          await httpClientHandlers.requestErrorCallback(error);
+        }
+        if (typeof httpClientHandlers.requestFinishCallback === "function") {
+          httpClientHandlers.requestFinishCallback();
+        }
+      }
+      return Promise.reject(error);
+    });
   };
-  const httpRequest = async (requestConfig) => {
-    return await _authenticationHelper.httpRequest(
-      _httpClient,
-      requestConfig,
-      _isHttpHandlerEnabled,
-      _httpErrorCallback,
-      _httpFinishCallback
-    );
+  const enableHttpHandler = () => {
+    const message = {
+      type: ENABLE_HTTP_HANDLER
+    };
+    return communicate(message).then(() => {
+      _isHttpHandlerEnabled = true;
+      return Promise.resolve(true);
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
   };
-  const httpRequestAll = async (requestConfigs) => {
-    return await _authenticationHelper.httpRequestAll(
-      requestConfigs,
-      _httpClient,
-      _isHttpHandlerEnabled,
-      _httpErrorCallback,
-      _httpFinishCallback
-    );
+  const disableHttpHandler = () => {
+    const message = {
+      type: DISABLE_HTTP_HANDLER
+    };
+    return communicate(message).then(() => {
+      _isHttpHandlerEnabled = false;
+      return Promise.resolve(true);
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
   };
-  const getHttpClient = () => {
-    return _httpClient;
+  const initialize = () => {
+    if (!httpClientHandlers) {
+      httpClientHandlers = {
+        requestErrorCallback: () => Promise.resolve(),
+        requestFinishCallback: () => null,
+        requestStartCallback: () => null,
+        requestSuccessCallback: () => null
+      };
+    }
+    worker.onmessage = ({ data }) => {
+      switch (data.type) {
+        case REQUEST_FINISH:
+          httpClientHandlers?.requestFinishCallback && httpClientHandlers?.requestFinishCallback();
+          break;
+        case REQUEST_START:
+          httpClientHandlers?.requestStartCallback && httpClientHandlers?.requestStartCallback();
+          break;
+        case REQUEST_SUCCESS:
+          httpClientHandlers?.requestSuccessCallback && httpClientHandlers?.requestSuccessCallback(data.data ? JSON.parse(data.data) : null);
+          break;
+      }
+    };
+    const message = {
+      data: config,
+      type: INIT
+    };
+    return communicate(message).then(() => {
+      return Promise.resolve(true);
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
   };
-  const enableHttpHandler = () => {
-    _authenticationHelper.enableHttpHandler(_httpClient);
-    _isHttpHandlerEnabled = true;
-    return true;
+  const setSessionState = (sessionState) => {
+    const message = {
+      data: sessionState,
+      type: SET_SESSION_STATE
+    };
+    return communicate(message);
   };
-  const disableHttpHandler = () => {
-    _authenticationHelper.disableHttpHandler(_httpClient);
-    _isHttpHandlerEnabled = false;
-    return true;
+  const startAutoRefreshToken = () => {
+    const message = {
+      type: START_AUTO_REFRESH_TOKEN
+    };
+    return communicate(message);
   };
   const checkSession = async () => {
-    const oidcEndpoints = await _authenticationClient.getOIDCServiceEndpoints();
-    const config2 = await _dataLayer.getConfigData();
+    const oidcEndpoints = await getOpenIDProviderEndpoints();
+    const config2 = await getConfigData();
     _authenticationHelper.initializeSessionManger(
       config2,
       oidcEndpoints,
-      async () => (await _authenticationClient.getBasicUserInfo()).sessionState,
-      async (params) => _authenticationClient.getAuthorizationURL(params),
+      async () => (await _authenticationClient.getUserSession()).sessionState,
+      async (params) => (await getSignInUrl(params)).authorizationURL,
       _sessionManagementHelper
     );
   };
+  const constructSilentSignInUrl = async (additionalParams = {}) => {
+    const config2 = await getConfigData();
+    const message = {
+      data: {
+        prompt: "none",
+        state: SILENT_SIGN_IN_STATE,
+        ...additionalParams
+      },
+      type: GET_AUTH_URL
+    };
+    const response = await communicate(
+      message
+    );
+    const pkceKey = extractPkceStorageKeyFromState3(
+      new URL(response.authorizationURL).searchParams.get(OIDCRequestConstants4.Params.STATE) ?? ""
+    );
+    response.pkce && config2.enablePKCE && SPAUtils.setPKCE(pkceKey, response.pkce);
+    const urlString = response.authorizationURL;
+    const urlObject = new URL(urlString);
+    urlObject.searchParams.set("response_mode", "query");
+    const url = urlObject.toString();
+    return url;
+  };
+  const trySignInSilently = async (additionalParams, tokenRequestConfig) => {
+    return await _authenticationHelper.trySignInSilently(
+      constructSilentSignInUrl,
+      requestAccessToken,
+      _sessionManagementHelper,
+      additionalParams,
+      tokenRequestConfig
+    );
+  };
+  const getSignInUrl = async (params) => {
+    const config2 = await getConfigData();
+    const message = {
+      data: params,
+      type: GET_AUTH_URL
+    };
+    return communicate(message).then(
+      async (response) => {
+        if (response.pkce && config2.enablePKCE) {
+          const pkceKey = extractPkceStorageKeyFromState3(
+            new URL(response.authorizationURL).searchParams.get(OIDCRequestConstants4.Params.STATE) ?? ""
+          );
+          SPAUtils.setPKCE(pkceKey, response.pkce);
+        }
+        return Promise.resolve(response);
+      }
+    );
+  };
+  const requestAccessToken = async (resolvedAuthorizationCode, resolvedSessionState, resolvedState, tokenRequestConfig) => {
+    const config2 = await getConfigData();
+    const pkceKey = extractPkceStorageKeyFromState3(resolvedState);
+    const message = {
+      data: {
+        code: resolvedAuthorizationCode,
+        pkce: config2.enablePKCE ? SPAUtils.getPKCE(pkceKey) : void 0,
+        sessionState: resolvedSessionState,
+        state: resolvedState,
+        tokenRequestConfig
+      },
+      type: REQUEST_ACCESS_TOKEN
+    };
+    config2.enablePKCE && SPAUtils.removePKCE(pkceKey);
+    return communicate(message).then((response) => {
+      const message2 = {
+        type: GET_SIGN_OUT_URL
+      };
+      return communicate(message2).then((url) => {
+        SPAUtils.setSignOutURL(url, config2.clientId, instanceID);
+        if (config2.enableOIDCSessionManagement) {
+          checkSession();
+        }
+        startAutoRefreshToken();
+        return Promise.resolve(response);
+      }).catch((error) => {
+        return Promise.reject(error);
+      });
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
+  };
   const shouldStopAuthn = async () => {
     return await _sessionManagementHelper.receivePromptNoneResponse(async (sessionState) => {
-      await _dataLayer.setSessionDataParameter(
-        OIDCRequestConstants4.Params.SESSION_STATE,
-        sessionState ?? ""
-      );
-      return;
+      return setSessionState(sessionState);
     });
   };
-  const setSessionStatus = async (sessionStatus) => {
-    await _dataLayer.setSessionStatus(sessionStatus);
+  const tryRetrievingUserInfo = async () => {
+    if (await isSignedIn()) {
+      await startAutoRefreshToken();
+      if (config.enableOIDCSessionManagement) {
+        checkSession();
+      }
+      return getUser();
+    }
+    return Promise.resolve(void 0);
   };
-  const signIn = async (signInConfig, authorizationCode, sessionState, state, tokenRequestConfig) => {
-    const basicUserInfo = await _authenticationHelper.handleSignIn(shouldStopAuthn, checkSession, void 0);
+  const signIn = async (params, authorizationCode, sessionState, state, tokenRequestConfig) => {
+    const basicUserInfo = await _authenticationHelper.handleSignIn(
+      shouldStopAuthn,
+      checkSession,
+      tryRetrievingUserInfo
+    );
     if (basicUserInfo) {
       return basicUserInfo;
     } else {
       let resolvedAuthorizationCode;
       let resolvedSessionState;
       let resolvedState;
-      let resolvedTokenRequestConfig = { params: {} };
-      if (config?.responseMode === ResponseMode.FormPost && authorizationCode) {
+      if (config?.responseMode === "form_post" && authorizationCode) {
         resolvedAuthorizationCode = authorizationCode;
         resolvedSessionState = sessionState ?? "";
         resolvedState = state ?? "";
@@ -3688,27 +3846,10 @@ var MainThreadClient = async (instanceID, config, getAuthHelper) => {
         SPAUtils.removeAuthorizationCode();
       }
       if (resolvedAuthorizationCode && resolvedState) {
-        setSessionStatus("true");
-        const storedTokenRequestConfig = await _dataLayer.getTemporaryDataParameter(TOKEN_REQUEST_CONFIG_KEY);
-        if (storedTokenRequestConfig && typeof storedTokenRequestConfig === "string") {
-          resolvedTokenRequestConfig = JSON.parse(storedTokenRequestConfig);
-        }
-        return requestAccessToken(
-          resolvedAuthorizationCode,
-          resolvedSessionState,
-          resolvedState,
-          resolvedTokenRequestConfig
-        );
+        return requestAccessToken(resolvedAuthorizationCode, resolvedSessionState, resolvedState, tokenRequestConfig);
       }
-      return _authenticationClient.getAuthorizationURL(signInConfig).then(async (url) => {
-        if (config.storage === "browserMemory" /* BrowserMemory */ && config.enablePKCE) {
-          const pkceKey = extractPkceStorageKeyFromState2(resolvedState);
-          SPAUtils.setPKCE(pkceKey, await _authenticationClient.getPKCECode(resolvedState));
-        }
-        if (tokenRequestConfig) {
-          _dataLayer.setTemporaryDataParameter(TOKEN_REQUEST_CONFIG_KEY, JSON.stringify(tokenRequestConfig));
-        }
-        location.href = url;
+      return getSignInUrl(params).then(async (response) => {
+        location.href = response.authorizationURL;
         await SPAUtils.waitTillPageRedirect();
         return Promise.resolve({
           allowedScopes: "",
@@ -3719,119 +3860,158 @@ var MainThreadClient = async (instanceID, config, getAuthHelper) => {
           tenantDomain: "",
           username: ""
         });
+      }).catch((error) => {
+        return Promise.reject(error);
       });
     }
   };
-  const signOut = async () => {
-    if (await _authenticationClient.isAuthenticated() && !_getSignOutURLFromSessionStorage) {
-      location.href = await _authenticationClient.getSignOutURL();
-    } else {
-      location.href = SPAUtils.getSignOutURL(config.clientID, instanceID);
-    }
-    _spaHelper.clearRefreshTokenTimeout();
-    await _dataLayer.removeOIDCProviderMetaData();
-    await _dataLayer.removeTemporaryData();
-    await _dataLayer.removeSessionData();
-    await _dataLayer.removeSessionStatus();
-    await SPAUtils.waitTillPageRedirect();
-    return true;
-  };
-  const enableRetrievingSignOutURLFromSession = (config2) => {
-    if (config2.preventSignOutURLUpdate) {
-      _getSignOutURLFromSessionStorage = true;
-    }
-  };
-  const requestCustomGrant = async (config2) => {
-    return await _authenticationHelper.requestCustomGrant(config2, enableRetrievingSignOutURLFromSession);
-  };
-  const refreshAccessToken = async () => {
-    try {
-      return await _authenticationHelper.refreshAccessToken(enableRetrievingSignOutURLFromSession);
-    } catch (error) {
-      return Promise.reject(error);
-    }
+  const signOut = () => {
+    return new Promise((resolve, reject) => {
+      if (!_getSignOutURLFromSessionStorage) {
+        const message = {
+          type: SIGN_OUT
+        };
+        return communicate(message).then(async (response) => {
+          window.location.href = response;
+          await SPAUtils.waitTillPageRedirect();
+          return resolve(true);
+        }).catch((error) => {
+          return reject(error);
+        });
+      } else {
+        window.location.href = SPAUtils.getSignOutUrl(config.clientId, instanceID);
+        return SPAUtils.waitTillPageRedirect().then(() => {
+          return Promise.resolve(true);
+        });
+      }
+    });
   };
-  const revokeAccessToken = async () => {
-    const timer = await _spaHelper.getRefreshTimeoutTimer();
-    return _authenticationClient.revokeAccessToken().then(() => {
+  const revokeAccessToken = () => {
+    const message = {
+      type: REVOKE_ACCESS_TOKEN
+    };
+    return communicate(message).then((response) => {
       _sessionManagementHelper.reset();
-      _spaHelper.clearRefreshTokenTimeout(timer);
-      return Promise.resolve(true);
-    }).catch((error) => Promise.reject(error));
+      return Promise.resolve(response);
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
   };
-  const requestAccessToken = async (resolvedAuthorizationCode, resolvedSessionState, resolvedState, tokenRequestConfig) => {
-    return await _authenticationHelper.requestAccessToken(
-      resolvedAuthorizationCode,
-      resolvedSessionState,
-      checkSession,
-      void 0,
-      resolvedState,
-      tokenRequestConfig
-    );
+  const getOpenIDProviderEndpoints = () => {
+    const message = {
+      type: GET_OIDC_SERVICE_ENDPOINTS
+    };
+    return communicate(message).then((response) => {
+      return Promise.resolve(response);
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
   };
-  const constructSilentSignInUrl = async (additionalParams = {}) => {
-    const config2 = await _dataLayer.getConfigData();
-    const urlString = await _authenticationClient.getAuthorizationURL({
-      prompt: "none",
-      state: SILENT_SIGN_IN_STATE,
-      ...additionalParams
+  const getConfigData = () => {
+    const message = {
+      type: GET_CONFIG_DATA
+    };
+    return communicate(message).then((response) => {
+      return Promise.resolve(response);
+    }).catch((error) => {
+      return Promise.reject(error);
     });
-    const urlObject = new URL(urlString);
-    urlObject.searchParams.set("response_mode", "query");
-    const url = urlObject.toString();
-    if (config2.storage === "browserMemory" /* BrowserMemory */ && config2.enablePKCE) {
-      const state = urlObject.searchParams.get(OIDCRequestConstants4.Params.STATE);
-      SPAUtils.setPKCE(
-        extractPkceStorageKeyFromState2(state ?? ""),
-        await _authenticationClient.getPKCECode(state ?? "")
-      );
-    }
-    return url;
   };
-  const trySignInSilently = async (additionalParams, tokenRequestConfig) => {
-    return await _authenticationHelper.trySignInSilently(
-      constructSilentSignInUrl,
-      requestAccessToken,
-      _sessionManagementHelper,
-      additionalParams,
-      tokenRequestConfig
-    );
+  const getUser = () => {
+    const message = {
+      type: GET_BASIC_USER_INFO
+    };
+    return communicate(message).then((response) => {
+      return Promise.resolve(response);
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
   };
-  const getBasicUserInfo = async () => {
-    return _authenticationHelper.getBasicUserInfo();
+  const getDecodedIdToken = () => {
+    const message = {
+      type: GET_DECODED_ID_TOKEN
+    };
+    return communicate(message).then((response) => {
+      return Promise.resolve(response);
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
   };
-  const getDecodedIDToken = async () => {
-    return _authenticationHelper.getDecodedIDToken();
+  const getDecodedIDPIDToken = () => {
+    const message = {
+      type: GET_DECODED_IDP_ID_TOKEN
+    };
+    return communicate(message).then((response) => {
+      return Promise.resolve(response);
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
   };
-  const getCryptoHelper = async () => {
-    return _authenticationHelper.getCryptoHelper();
+  const getCrypto = () => {
+    const message = {
+      type: GET_CRYPTO_HELPER
+    };
+    return communicate(message).then((response) => {
+      return Promise.resolve(response);
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
   };
-  const getIDToken = async () => {
-    return _authenticationHelper.getIDToken();
+  const getIdToken = () => {
+    const message = {
+      type: GET_ID_TOKEN
+    };
+    return communicate(message).then((response) => {
+      return Promise.resolve(response);
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
   };
-  const getOIDCServiceEndpoints = async () => {
-    return _authenticationHelper.getOIDCServiceEndpoints();
+  const isSignedIn = () => {
+    const message = {
+      type: IS_AUTHENTICATED
+    };
+    return communicate(message).then((response) => {
+      return Promise.resolve(response);
+    }).catch((error) => {
+      return Promise.reject(error);
+    });
   };
-  const getAccessToken = async () => {
-    return _authenticationHelper.getAccessToken();
+  const refreshAccessToken = () => {
+    const message = {
+      type: REFRESH_ACCESS_TOKEN
+    };
+    return communicate(message);
   };
-  const getDataLayer = async () => {
-    return _authenticationHelper.getDataLayer();
+  const setHttpRequestSuccessCallback = (callback) => {
+    if (callback && typeof callback === "function") {
+      httpClientHandlers.requestSuccessCallback = callback;
+    }
   };
-  const getConfigData = async () => {
-    return await _dataLayer.getConfigData();
+  const setHttpRequestErrorCallback = (callback) => {
+    if (callback && typeof callback === "function") {
+      httpClientHandlers.requestErrorCallback = callback;
+    }
   };
-  const isAuthenticated = async () => {
-    return _authenticationHelper.isAuthenticated();
+  const setHttpRequestStartCallback = (callback) => {
+    if (callback && typeof callback === "function") {
+      httpClientHandlers.requestStartCallback = callback;
+    }
   };
-  const isSessionActive = async () => {
-    return await _dataLayer.getSessionStatus() === "true";
+  const setHttpRequestFinishCallback = (callback) => {
+    if (callback && typeof callback === "function") {
+      httpClientHandlers.requestFinishCallback = callback;
+    }
   };
-  const updateConfig = async (newConfig) => {
-    const existingConfig = await _dataLayer.getConfigData();
+  const reInitialize = async (newConfig) => {
+    const existingConfig = await getConfigData();
     const isCheckSessionIframeDifferent = !(existingConfig && existingConfig.endpoints && existingConfig.endpoints.checkSessionIframe && newConfig && newConfig.endpoints && newConfig.endpoints.checkSessionIframe && existingConfig.endpoints.checkSessionIframe === newConfig.endpoints.checkSessionIframe);
     const config2 = { ...existingConfig, ...newConfig };
-    await _authenticationClient.updateConfig(config2);
+    const message = {
+      data: config2,
+      type: UPDATE_CONFIG
+    };
+    await communicate(message);
     if (config2.enableOIDCSessionManagement && isCheckSessionIframeDifferent) {
       _sessionManagementHelper.reset();
       checkSession();
@@ -3840,21 +4020,19 @@ var MainThreadClient = async (instanceID, config, getAuthHelper) => {
   return {
     disableHttpHandler,
     enableHttpHandler,
-    getAccessToken,
-    getBasicUserInfo,
+    getUser,
     getConfigData,
-    getCryptoHelper,
-    getDataLayer,
-    getDecodedIDToken,
-    getHttpClient,
-    getIDToken,
-    getOIDCServiceEndpoints,
+    getCrypto,
+    getDecodedIDPIDToken,
+    getDecodedIdToken,
+    getIdToken,
+    getOpenIDProviderEndpoints,
     httpRequest,
     httpRequestAll,
-    isAuthenticated,
-    isSessionActive,
+    initialize,
+    isSignedIn,
     refreshAccessToken,
-    requestCustomGrant,
+    exchangeToken,
     revokeAccessToken,
     setHttpRequestErrorCallback,
     setHttpRequestFinishCallback,
@@ -3863,1044 +4041,509 @@ var MainThreadClient = async (instanceID, config, getAuthHelper) => {
     signIn,
     signOut,
     trySignInSilently,
-    updateConfig
+    reInitialize
   };
 };
 
-// src/__legacy__/clients/web-worker-client.ts
-import {
-  AsgardeoAuthClient as AsgardeoAuthClient8,
-  AsgardeoAuthException as AsgardeoAuthException4,
-  ResponseMode as ResponseMode2,
-  OIDCRequestConstants as OIDCRequestConstants5,
-  extractPkceStorageKeyFromState as extractPkceStorageKeyFromState3
-} from "@asgardeo/javascript";
-var initiateStore2 = (store) => {
-  switch (store) {
-    case "localStorage" /* LocalStorage */:
-      return new LocalStore();
-    case "sessionStorage" /* SessionStorage */:
-      return new SessionStore();
-    case "browserMemory" /* BrowserMemory */:
-      return new MemoryStore();
-    default:
-      return new SessionStore();
-  }
+// src/__legacy__/client.ts
+var DefaultConfig = {
+  autoLogoutOnTokenRefreshError: true,
+  checkSessionInterval: 3,
+  enableOIDCSessionManagement: false,
+  periodicTokenRefresh: false,
+  sessionRefreshInterval: 300,
+  storage: "sessionStorage" /* SessionStorage */
 };
-var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
-  let httpClientHandlers;
-  const _requestTimeout = config?.requestTimeout ?? 6e4;
-  let _isHttpHandlerEnabled = true;
-  let _getSignOutURLFromSessionStorage = false;
-  const _store = initiateStore2(config.storage);
-  const _cryptoUtils = new SPACryptoUtils();
-  const _authenticationClient = new AsgardeoAuthClient8();
-  await _authenticationClient.initialize(config, _store, _cryptoUtils, instanceID);
-  const _spaHelper = new SPAHelper(_authenticationClient);
-  const _sessionManagementHelper = await SessionManagementHelper(
-    async () => {
-      const message = {
-        type: SIGN_OUT
-      };
-      try {
-        const signOutURL = await communicate(message);
-        return signOutURL;
-      } catch {
-        return SPAUtils.getSignOutURL(config.clientID, instanceID);
-      }
-    },
-    config.storage,
-    (sessionState) => setSessionState(sessionState)
-  );
-  const _authenticationHelper = getAuthHelper(
-    _authenticationClient,
-    _spaHelper
-  );
-  const worker = new webWorker();
-  const communicate = (message) => {
-    const channel = new MessageChannel();
-    worker.postMessage(message, [channel.port2]);
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(
-          new AsgardeoAuthException4(
-            "SPA-WEB_WORKER_CLIENT-COM-TO01",
-            "Operation timed out.",
-            "No response was received from the web worker for " + _requestTimeout / 1e3 + " since dispatching the request"
-          )
-        );
-      }, _requestTimeout);
-      return channel.port1.onmessage = ({ data }) => {
-        clearTimeout(timer);
-        channel.port1.close();
-        channel.port2.close();
-        if (data?.success) {
-          const responseData = data?.data ? JSON.parse(data?.data) : null;
-          if (data?.blob) {
-            responseData.data = data?.blob;
-          }
-          resolve(responseData);
-        } else {
-          reject(data.error ? JSON.parse(data.error) : null);
-        }
-      };
-    });
-  };
-  const requestCustomGrant = (requestParams) => {
-    const message = {
-      data: requestParams,
-      type: REQUEST_CUSTOM_GRANT
+var _AsgardeoSPAClient = class _AsgardeoSPAClient {
+  constructor(id) {
+    __publicField(this, "_client");
+    __publicField(this, "_storage");
+    __publicField(this, "_authHelper", AuthenticationHelper);
+    // protected _worker: new () => Worker = WorkerFile;
+    __publicField(this, "_worker", null);
+    __publicField(this, "_initialized", false);
+    __publicField(this, "_startedInitialize", false);
+    __publicField(this, "_onSignInCallback", () => null);
+    __publicField(this, "_onSignOutCallback", () => null);
+    __publicField(this, "_onSignOutFailedCallback", () => null);
+    __publicField(this, "_onEndUserSession", () => null);
+    __publicField(this, "_onInitialize", () => null);
+    __publicField(this, "_onCustomGrant", /* @__PURE__ */ new Map());
+    __publicField(this, "_instanceID");
+    this._instanceID = id;
+  }
+  instantiateAuthHelper(authHelper) {
+    if (authHelper) {
+      this._authHelper = authHelper;
+    } else {
+      this._authHelper = AuthenticationHelper;
+    }
+  }
+  // public instantiateWorker(worker: new () => Worker) {
+  //   if (worker) {
+  //     this._worker = worker;
+  //   } else {
+  //     this._worker = WorkerFile;
+  //   }
+  // }
+  /**
+   * This method specifies if the `AsgardeoSPAClient` has been initialized or not.
+   *
+   * @return {Promise<boolean>} - Resolves to `true` if the client has been initialized.
+   *
+   * @memberof AsgardeoSPAClient
+   *
+   * @private
+   */
+  async isInitialized() {
+    if (!this._startedInitialize) {
+      return false;
+    }
+    let iterationToWait = 0;
+    const sleep = () => {
+      return new Promise((resolve) => setTimeout(resolve, 1));
     };
-    return communicate(message).then((response) => {
-      if (requestParams.preventSignOutURLUpdate) {
-        _getSignOutURLFromSessionStorage = true;
+    while (!this._initialized) {
+      if (iterationToWait === 1e4) {
+        console.warn("It is taking longer than usual for the object to be initialized");
       }
-      return Promise.resolve(response);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const httpRequest = (config2) => {
-    if (config2?.data && config2?.data instanceof FormData) {
-      config2.data = { ...Object.fromEntries((config2?.data).entries()), formData: true };
+      await sleep();
+      iterationToWait++;
     }
-    const message = {
-      data: config2,
-      type: HTTP_REQUEST
-    };
-    return communicate(message).then((response) => {
-      return Promise.resolve(response);
-    }).catch(async (error) => {
-      if (_isHttpHandlerEnabled) {
-        if (typeof httpClientHandlers.requestErrorCallback === "function") {
-          await httpClientHandlers.requestErrorCallback(error);
-        }
-        if (typeof httpClientHandlers.requestFinishCallback === "function") {
-          httpClientHandlers.requestFinishCallback();
-        }
+    return true;
+  }
+  /**
+   * This method checks if the SDK is initialized and the user is authenticated.
+   *
+   * @param validateAuthentication - should user's authenticated status be checked as part of validation
+   *
+   * @return {Promise<boolean>} - A Promise that resolves with `true` if the SDK is initialized and the
+   * user is authenticated.
+   *
+   * @memberof AsgardeoSPAClient
+   *
+   * @private
+   */
+  async _validateMethod(validateAuthentication = true) {
+    if (!await this.isInitialized()) {
+      return Promise.reject(
+        new AsgardeoAuthException4(
+          "SPA-AUTH_CLIENT-VM-NF01",
+          "The SDK is not initialized.",
+          "The SDK must be initialized first."
+        )
+      );
+    }
+    if (validateAuthentication && !await this.isSignedIn()) {
+      return Promise.reject(
+        new AsgardeoAuthException4(
+          "SPA-AUTH_CLIENT-VM-IV02",
+          "The user is not authenticated.",
+          "The user must be authenticated first."
+        )
+      );
+    }
+    return true;
+  }
+  /**
+   * This method returns the instance of the singleton class.
+   * If an ID is provided, it will return the instance with the given ID.
+   * If no ID is provided, it will return the default instance value 0.
+   *
+   * @return {AsgardeoSPAClient} - Returns the instance of the singleton class.
+   *
+   * @example
+   * ```
+   * const auth = AsgardeoSPAClient.getInstance();
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#getinstance
+   *
+   * @memberof AsgardeoSPAClient
+   *
+   * @preserve
+   */
+  static getInstance(id) {
+    if (id && this._instances?.get(id)) {
+      return this._instances.get(id);
+    } else if (!id && this._instances?.get(0)) {
+      return this._instances.get(0);
+    }
+    if (id) {
+      this._instances.set(id, new _AsgardeoSPAClient(id));
+      return this._instances.get(id);
+    }
+    this._instances.set(0, new _AsgardeoSPAClient(0));
+    return this._instances.get(0);
+  }
+  /**
+   * This method initializes the `AsgardeoSPAClient` instance.
+   *
+   * @param {ConfigInterface} config The config object to initialize with.
+   *
+   * @return {Promise<boolean>} - Resolves to `true` if initialization is successful.
+   *
+   * @example
+   * ```
+   * auth.initialize({
+   *     afterSignInUrl: "http://localhost:3000/sign-in",
+   *     clientId: "client ID",
+   *     baseUrl: "https://api.asgardeo.io"
+   * });
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#initialize
+   *
+   * @memberof AsgardeoSPAClient
+   *
+   * @preserve
+   */
+  async initialize(config, authHelper, workerFile) {
+    this._storage = config.storage ?? "sessionStorage" /* SessionStorage */;
+    this._initialized = false;
+    this._startedInitialize = true;
+    authHelper && this.instantiateAuthHelper(authHelper);
+    const _config = await this._client?.getConfigData();
+    if (!(this._storage === "webWorker" /* WebWorker */)) {
+      const mainThreadClientConfig = config;
+      const defaultConfig = { ...DefaultConfig };
+      const mergedConfig = {
+        ...defaultConfig,
+        ...mainThreadClientConfig
+      };
+      if (!this._client || this._client && (!_config || Object.keys(_config)?.length === 0)) {
+        this._client = await MainThreadClient(
+          this._instanceID,
+          mergedConfig,
+          (authClient, spaHelper) => {
+            return new this._authHelper(authClient, spaHelper);
+          }
+        );
       }
-      return Promise.reject(error);
-    });
-  };
-  const httpRequestAll = (configs) => {
-    const message = {
-      data: configs,
-      type: HTTP_REQUEST_ALL
-    };
-    return communicate(message).then((response) => {
-      return Promise.resolve(response);
-    }).catch(async (error) => {
-      if (_isHttpHandlerEnabled) {
-        if (typeof httpClientHandlers.requestErrorCallback === "function") {
-          await httpClientHandlers.requestErrorCallback(error);
-        }
-        if (typeof httpClientHandlers.requestFinishCallback === "function") {
-          httpClientHandlers.requestFinishCallback();
-        }
+      this._initialized = true;
+      if (this._onInitialize) {
+        this._onInitialize(true);
       }
-      return Promise.reject(error);
-    });
-  };
-  const enableHttpHandler = () => {
-    const message = {
-      type: ENABLE_HTTP_HANDLER
-    };
-    return communicate(message).then(() => {
-      _isHttpHandlerEnabled = true;
-      return Promise.resolve(true);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const disableHttpHandler = () => {
-    const message = {
-      type: DISABLE_HTTP_HANDLER
-    };
-    return communicate(message).then(() => {
-      _isHttpHandlerEnabled = false;
+      if (!mergedConfig.autoLogoutOnTokenRefreshError) {
+        return Promise.resolve(true);
+      }
+      window.addEventListener("message", (event) => {
+        if (event?.data?.type === REFRESH_ACCESS_TOKEN_ERR0R) {
+          this.signOut();
+        }
+      });
       return Promise.resolve(true);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const initialize = () => {
-    if (!httpClientHandlers) {
-      httpClientHandlers = {
-        requestErrorCallback: () => Promise.resolve(),
-        requestFinishCallback: () => null,
-        requestStartCallback: () => null,
-        requestSuccessCallback: () => null
-      };
-    }
-    worker.onmessage = ({ data }) => {
-      switch (data.type) {
-        case REQUEST_FINISH:
-          httpClientHandlers?.requestFinishCallback && httpClientHandlers?.requestFinishCallback();
-          break;
-        case REQUEST_START:
-          httpClientHandlers?.requestStartCallback && httpClientHandlers?.requestStartCallback();
-          break;
-        case REQUEST_SUCCESS:
-          httpClientHandlers?.requestSuccessCallback && httpClientHandlers?.requestSuccessCallback(data.data ? JSON.parse(data.data) : null);
-          break;
+    } else {
+      if (!this._client || this._client && (!_config || Object.keys(_config)?.length === 0)) {
+        const webWorkerClientConfig = config;
+        this._client = await WebWorkerClient(
+          this._instanceID,
+          {
+            ...DefaultConfig,
+            ...webWorkerClientConfig
+          },
+          this._worker,
+          (authClient, spaHelper) => {
+            return new this._authHelper(authClient, spaHelper);
+          }
+        );
+        return this._client.initialize().then(() => {
+          if (this._onInitialize) {
+            this._onInitialize(true);
+          }
+          this._initialized = true;
+          return Promise.resolve(true);
+        }).catch((error) => {
+          return Promise.reject(error);
+        });
       }
-    };
-    const message = {
-      data: config,
-      type: INIT
-    };
-    return communicate(message).then(() => {
       return Promise.resolve(true);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const setSessionState = (sessionState) => {
-    const message = {
-      data: sessionState,
-      type: SET_SESSION_STATE
-    };
-    return communicate(message);
-  };
-  const startAutoRefreshToken = () => {
-    const message = {
-      type: START_AUTO_REFRESH_TOKEN
-    };
-    return communicate(message);
-  };
-  const checkSession = async () => {
-    const oidcEndpoints = await getOIDCServiceEndpoints();
-    const config2 = await getConfigData();
-    _authenticationHelper.initializeSessionManger(
-      config2,
-      oidcEndpoints,
-      async () => (await getBasicUserInfo()).sessionState,
-      async (params) => (await getAuthorizationURL(params)).authorizationURL,
-      _sessionManagementHelper
-    );
-  };
-  const constructSilentSignInUrl = async (additionalParams = {}) => {
-    const config2 = await getConfigData();
-    const message = {
-      data: {
-        prompt: "none",
-        state: SILENT_SIGN_IN_STATE,
-        ...additionalParams
-      },
-      type: GET_AUTH_URL
-    };
-    const response = await communicate(message);
-    const pkceKey = extractPkceStorageKeyFromState3(
-      new URL(response.authorizationURL).searchParams.get(OIDCRequestConstants5.Params.STATE) ?? ""
-    );
-    response.pkce && config2.enablePKCE && SPAUtils.setPKCE(pkceKey, response.pkce);
-    const urlString = response.authorizationURL;
-    const urlObject = new URL(urlString);
-    urlObject.searchParams.set("response_mode", "query");
-    const url = urlObject.toString();
-    return url;
-  };
-  const trySignInSilently = async (additionalParams, tokenRequestConfig) => {
-    return await _authenticationHelper.trySignInSilently(
-      constructSilentSignInUrl,
-      requestAccessToken,
-      _sessionManagementHelper,
-      additionalParams,
-      tokenRequestConfig
-    );
-  };
-  const getAuthorizationURL = async (params) => {
-    const config2 = await getConfigData();
-    const message = {
-      data: params,
-      type: GET_AUTH_URL
-    };
-    return communicate(message).then(
-      async (response) => {
-        if (response.pkce && config2.enablePKCE) {
-          const pkceKey = extractPkceStorageKeyFromState3(
-            new URL(response.authorizationURL).searchParams.get(OIDCRequestConstants5.Params.STATE) ?? ""
-          );
-          SPAUtils.setPKCE(pkceKey, response.pkce);
-        }
-        return Promise.resolve(response);
+    }
+  }
+  /**
+   * This method returns a Promise that resolves with the basic user information obtained from the ID token.
+   *
+   * @return {Promise<User>} - A promise that resolves with the user information.
+   *
+   * @example
+   * ```
+   * auth.getUser().then((response) => {
+   *    // console.log(response);
+   * }).catch((error) => {
+   *    // console.error(error);
+   * });
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#getuserinfo
+   *
+   * @memberof AsgardeoSPAClient
+   *
+   * @preserve
+   */
+  async getUser() {
+    await this._validateMethod();
+    return this._client?.getUser();
+  }
+  /**
+   * This method initiates the authentication flow. This should be called twice.
+   *  1. To initiate the authentication flow.
+   *  2. To obtain the access token after getting the authorization code.
+   *
+   * To satisfy the second condition, one of the two strategies mentioned below can be used:
+   *  1. Redirect the user back to the same login page that initiated the authentication flow.
+   *  2. Call the `signIn()` method in the page the user is redirected to after authentication.
+   *
+   * **To fire a callback function after signing in, use the `on()` method.**
+   * **To learn more about the `on()` method:**
+   * @see {@link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#on}
+   *
+   * @param {SignInConfig} config - The sign-in config.
+   * The `SignInConfig` object has these two attributes in addition to any custom key-value pairs.
+   *  1. fidp - Specifies the FIDP parameter that is used to take the user directly to an IdP login page.
+   *  2. forceInit: Specifies if the OIDC Provider Meta Data should be loaded again from the `well-known`
+   * endpoint.
+   *  3. Any other parameters that should be appended to the authorization request.
+   * @param {string} authorizationCode - The authorization code. (Optional)
+   * @param {string} sessionState - The session state. (Optional)
+   * @param {string} state - The state. (Optional)
+   *
+   * @return {Promise<User>} - A promise that resolves with the user information.
+   *
+   * @example
+   * ```
+   * auth.signIn();
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#signin
+   *
+   * @memberof AsgardeoSPAClient
+   *
+   * @preserve
+   */
+  async signIn(config, authorizationCode, sessionState, state, tokenRequestConfig) {
+    await this.isInitialized();
+    if (!SPAUtils.canContinueSignIn(Boolean(config?.callOnlyOnRedirect), authorizationCode)) {
+      return void 0;
+    }
+    delete config?.callOnlyOnRedirect;
+    return this._client?.signIn(config, authorizationCode, sessionState, state, tokenRequestConfig).then((response) => {
+      if (this._onSignInCallback) {
+        this._onSignInCallback(response);
       }
-    );
-  };
-  const requestAccessToken = async (resolvedAuthorizationCode, resolvedSessionState, resolvedState, tokenRequestConfig) => {
-    const config2 = await getConfigData();
-    const pkceKey = extractPkceStorageKeyFromState3(resolvedState);
-    const message = {
-      data: {
-        code: resolvedAuthorizationCode,
-        pkce: config2.enablePKCE ? SPAUtils.getPKCE(pkceKey) : void 0,
-        sessionState: resolvedSessionState,
-        state: resolvedState,
-        tokenRequestConfig
-      },
-      type: REQUEST_ACCESS_TOKEN
-    };
-    config2.enablePKCE && SPAUtils.removePKCE(pkceKey);
-    return communicate(message).then((response) => {
-      const message2 = {
-        type: GET_SIGN_OUT_URL
-      };
-      return communicate(message2).then((url) => {
-        SPAUtils.setSignOutURL(url, config2.clientID, instanceID);
-        if (config2.enableOIDCSessionManagement) {
-          checkSession();
-        }
-        startAutoRefreshToken();
-        return Promise.resolve(response);
-      }).catch((error) => {
-        return Promise.reject(error);
-      });
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const shouldStopAuthn = async () => {
-    return await _sessionManagementHelper.receivePromptNoneResponse(async (sessionState) => {
-      return setSessionState(sessionState);
+      return response;
     });
-  };
-  const tryRetrievingUserInfo = async () => {
-    if (await isAuthenticated()) {
-      await startAutoRefreshToken();
-      if (config.enableOIDCSessionManagement) {
-        checkSession();
-      }
-      return getBasicUserInfo();
+  }
+  /**
+   * This method allows you to sign in silently.
+   * First, this method sends a prompt none request to see if there is an active user session in the identity server.
+   * If there is one, then it requests the access token and stores it. Else, it returns false.
+   *
+   * If this method is to be called on page load and the `signIn` method is also to be called on page load,
+   * then it is advisable to call this method after the `signIn` call.
+   *
+   * @return {Promise<User | boolean>} - A Promise that resolves with the user information after signing in
+   * or with `false` if the user is not signed in.
+   *
+   * @example
+   *```
+   * auth.trySignInSilently()
+   *```
+   */
+  async trySignInSilently(additionalParams, tokenRequestConfig) {
+    await this.isInitialized();
+    if (SPAUtils.wasSignInCalled()) {
+      return void 0;
     }
-    return Promise.resolve(void 0);
-  };
-  const signIn = async (params, authorizationCode, sessionState, state, tokenRequestConfig) => {
-    const basicUserInfo = await _authenticationHelper.handleSignIn(
-      shouldStopAuthn,
-      checkSession,
-      tryRetrievingUserInfo
-    );
-    if (basicUserInfo) {
-      return basicUserInfo;
-    } else {
-      let resolvedAuthorizationCode;
-      let resolvedSessionState;
-      let resolvedState;
-      if (config?.responseMode === ResponseMode2.FormPost && authorizationCode) {
-        resolvedAuthorizationCode = authorizationCode;
-        resolvedSessionState = sessionState ?? "";
-        resolvedState = state ?? "";
-      } else {
-        resolvedAuthorizationCode = new URL(window.location.href).searchParams.get(OIDCRequestConstants5.Params.AUTHORIZATION_CODE) ?? "";
-        resolvedSessionState = new URL(window.location.href).searchParams.get(OIDCRequestConstants5.Params.SESSION_STATE) ?? "";
-        resolvedState = new URL(window.location.href).searchParams.get(OIDCRequestConstants5.Params.STATE) ?? "";
-        SPAUtils.removeAuthorizationCode();
-      }
-      if (resolvedAuthorizationCode && resolvedState) {
-        return requestAccessToken(resolvedAuthorizationCode, resolvedSessionState, resolvedState, tokenRequestConfig);
-      }
-      return getAuthorizationURL(params).then(async (response) => {
-        location.href = response.authorizationURL;
-        await SPAUtils.waitTillPageRedirect();
-        return Promise.resolve({
-          allowedScopes: "",
-          displayName: "",
-          email: "",
-          sessionState: "",
-          sub: "",
-          tenantDomain: "",
-          username: ""
-        });
-      }).catch((error) => {
-        return Promise.reject(error);
-      });
-    }
-  };
-  const signOut = () => {
-    return new Promise((resolve, reject) => {
-      if (!_getSignOutURLFromSessionStorage) {
-        const message = {
-          type: SIGN_OUT
-        };
-        return communicate(message).then(async (response) => {
-          window.location.href = response;
-          await SPAUtils.waitTillPageRedirect();
-          return resolve(true);
-        }).catch((error) => {
-          return reject(error);
-        });
-      } else {
-        window.location.href = SPAUtils.getSignOutURL(config.clientID, instanceID);
-        return SPAUtils.waitTillPageRedirect().then(() => {
-          return Promise.resolve(true);
-        });
+    return this._client?.trySignInSilently(additionalParams, tokenRequestConfig).then((response) => {
+      if (this._onSignInCallback && response) {
+        this._onSignInCallback(response);
       }
+      return response;
     });
-  };
-  const revokeAccessToken = () => {
-    const message = {
-      type: REVOKE_ACCESS_TOKEN
-    };
-    return communicate(message).then((response) => {
-      _sessionManagementHelper.reset();
-      return Promise.resolve(response);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const getOIDCServiceEndpoints = () => {
-    const message = {
-      type: GET_OIDC_SERVICE_ENDPOINTS
-    };
-    return communicate(message).then((response) => {
-      return Promise.resolve(response);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const getConfigData = () => {
-    const message = {
-      type: GET_CONFIG_DATA
-    };
-    return communicate(message).then((response) => {
-      return Promise.resolve(response);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const getBasicUserInfo = () => {
-    const message = {
-      type: GET_BASIC_USER_INFO
-    };
-    return communicate(message).then((response) => {
-      return Promise.resolve(response);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const getDecodedIDToken = () => {
-    const message = {
-      type: GET_DECODED_ID_TOKEN
-    };
-    return communicate(message).then((response) => {
-      return Promise.resolve(response);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const getDecodedIDPIDToken = () => {
-    const message = {
-      type: GET_DECODED_IDP_ID_TOKEN
-    };
-    return communicate(message).then((response) => {
-      return Promise.resolve(response);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const getCryptoHelper = () => {
-    const message = {
-      type: GET_CRYPTO_HELPER
-    };
-    return communicate(message).then((response) => {
-      return Promise.resolve(response);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const getIDToken = () => {
-    const message = {
-      type: GET_ID_TOKEN
-    };
-    return communicate(message).then((response) => {
-      return Promise.resolve(response);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const isAuthenticated = () => {
-    const message = {
-      type: IS_AUTHENTICATED
-    };
-    return communicate(message).then((response) => {
-      return Promise.resolve(response);
-    }).catch((error) => {
-      return Promise.reject(error);
-    });
-  };
-  const refreshAccessToken = () => {
-    const message = {
-      type: REFRESH_ACCESS_TOKEN
-    };
-    return communicate(message);
-  };
-  const setHttpRequestSuccessCallback = (callback) => {
-    if (callback && typeof callback === "function") {
-      httpClientHandlers.requestSuccessCallback = callback;
-    }
-  };
-  const setHttpRequestErrorCallback = (callback) => {
-    if (callback && typeof callback === "function") {
-      httpClientHandlers.requestErrorCallback = callback;
-    }
-  };
-  const setHttpRequestStartCallback = (callback) => {
-    if (callback && typeof callback === "function") {
-      httpClientHandlers.requestStartCallback = callback;
-    }
-  };
-  const setHttpRequestFinishCallback = (callback) => {
-    if (callback && typeof callback === "function") {
-      httpClientHandlers.requestFinishCallback = callback;
-    }
-  };
-  const updateConfig = async (newConfig) => {
-    const existingConfig = await getConfigData();
-    const isCheckSessionIframeDifferent = !(existingConfig && existingConfig.endpoints && existingConfig.endpoints.checkSessionIframe && newConfig && newConfig.endpoints && newConfig.endpoints.checkSessionIframe && existingConfig.endpoints.checkSessionIframe === newConfig.endpoints.checkSessionIframe);
-    const config2 = { ...existingConfig, ...newConfig };
-    const message = {
-      data: config2,
-      type: UPDATE_CONFIG
-    };
-    await communicate(message);
-    if (config2.enableOIDCSessionManagement && isCheckSessionIframeDifferent) {
-      _sessionManagementHelper.reset();
-      checkSession();
-    }
-  };
-  return {
-    disableHttpHandler,
-    enableHttpHandler,
-    getBasicUserInfo,
-    getConfigData,
-    getCryptoHelper,
-    getDecodedIDPIDToken,
-    getDecodedIDToken,
-    getIDToken,
-    getOIDCServiceEndpoints,
-    httpRequest,
-    httpRequestAll,
-    initialize,
-    isAuthenticated,
-    refreshAccessToken,
-    requestCustomGrant,
-    revokeAccessToken,
-    setHttpRequestErrorCallback,
-    setHttpRequestFinishCallback,
-    setHttpRequestStartCallback,
-    setHttpRequestSuccessCallback,
-    signIn,
-    signOut,
-    trySignInSilently,
-    updateConfig
-  };
-};
-
-// src/__legacy__/client.ts
-var DefaultConfig = {
-  autoLogoutOnTokenRefreshError: true,
-  checkSessionInterval: 3,
-  clientHost: origin,
-  enableOIDCSessionManagement: false,
-  periodicTokenRefresh: false,
-  sessionRefreshInterval: 300,
-  storage: "sessionStorage" /* SessionStorage */
-};
-var _AsgardeoSPAClient = class _AsgardeoSPAClient {
-  constructor(id) {
-    __publicField(this, "_client");
-    __publicField(this, "_storage");
-    __publicField(this, "_authHelper", AuthenticationHelper);
-    __publicField(this, "_worker", worker_default);
-    __publicField(this, "_initialized", false);
-    __publicField(this, "_startedInitialize", false);
-    __publicField(this, "_onSignInCallback", () => null);
-    __publicField(this, "_onSignOutCallback", () => null);
-    __publicField(this, "_onSignOutFailedCallback", () => null);
-    __publicField(this, "_onEndUserSession", () => null);
-    __publicField(this, "_onInitialize", () => null);
-    __publicField(this, "_onCustomGrant", /* @__PURE__ */ new Map());
-    __publicField(this, "_instanceID");
-    this._instanceID = id;
-  }
-  instantiateAuthHelper(authHelper) {
-    if (authHelper) {
-      this._authHelper = authHelper;
-    } else {
-      this._authHelper = AuthenticationHelper;
-    }
-  }
-  instantiateWorker(worker) {
-    if (worker) {
-      this._worker = worker;
-    } else {
-      this._worker = worker_default;
-    }
   }
   /**
-   * This method specifies if the `AsgardeoSPAClient` has been initialized or not.
+   * This method initiates the sign-out flow.
    *
-   * @return {Promise<boolean>} - Resolves to `true` if the client has been initialized.
+   * **To fire a callback function after signing out, use the `on()` method.**
+   * **To learn more about the `on()` method:**
+   * @see {@link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#on}
+   *
+   * @return {Promise<boolean>} - Returns a promise that resolves with `true` if sign out is successful.
+   *
+   * @example
+   * ```
+   * auth.signOut();
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#signout
    *
    * @memberof AsgardeoSPAClient
    *
-   * @private
+   * @preserve
    */
-  async _isInitialized() {
-    if (!this._startedInitialize) {
-      return false;
-    }
-    let iterationToWait = 0;
-    const sleep = () => {
-      return new Promise((resolve) => setTimeout(resolve, 1));
-    };
-    while (!this._initialized) {
-      if (iterationToWait === 1e4) {
-        console.warn("It is taking longer than usual for the object to be initialized");
-      }
-      await sleep();
-      iterationToWait++;
-    }
-    return true;
+  async signOut() {
+    await this._validateMethod(false);
+    const signOutResponse = await this._client?.signOut() ?? false;
+    return signOutResponse;
   }
   /**
-   * This method checks if the SDK is initialized and the user is authenticated.
-   *
-   * @param validateAuthentication - should user's authenticated status be checked as part of validation
-   *
-   * @return {Promise<boolean>} - A Promise that resolves with `true` if the SDK is initialized and the
-   * user is authenticated.
-   *
-   * @memberof AsgardeoSPAClient
+   * This method sends an API request to a protected endpoint.
+   * The access token is automatically attached to the header of the request.
+   * This is the only way by which protected endpoints can be accessed
+   * when the web worker is used to store session information.
    *
-   * @private
-   */
-  async _validateMethod(validateAuthentication = true) {
-    if (!await this._isInitialized()) {
-      return Promise.reject(
-        new AsgardeoAuthException5(
-          "SPA-AUTH_CLIENT-VM-NF01",
-          "The SDK is not initialized.",
-          "The SDK must be initialized first."
-        )
-      );
-    }
-    if (validateAuthentication && !await this.isAuthenticated()) {
-      return Promise.reject(
-        new AsgardeoAuthException5(
-          "SPA-AUTH_CLIENT-VM-IV02",
-          "The user is not authenticated.",
-          "The user must be authenticated first."
-        )
-      );
-    }
-    return true;
-  }
-  /**
-   * This method returns the instance of the singleton class.
-   * If an ID is provided, it will return the instance with the given ID.
-   * If no ID is provided, it will return the default instance value 0.
+   * @param {HttpRequestConfig} config -  The config object containing attributes necessary to send a request.
    *
-   * @return {AsgardeoSPAClient} - Returns the instance of the singleton class.
+   * @return {Promise<HttpResponse>} - Returns a Promise that resolves with the response to the request.
    *
    * @example
    * ```
-   * const auth = AsgardeoSPAClient.getInstance();
+   *  const requestConfig = {
+   *      headers: {
+   *          "Accept": "application/json",
+   *          "Access-Control-Allow-Origin": "https://api.asgardeo.io/myaccount",
+   *          "Content-Type": "application/scim+json"
+   *      },
+   *      method: "GET",
+   *      url: "https://api.asgardeo.io/scim2/me"
+   *  };
+   *
+   *  return auth.httpRequest(requestConfig)
+   *     .then((response) => {
+   *           // console.log(response);
+   *      })
+   *      .catch((error) => {
+   *           // console.error(error);
+   *      });
    * ```
    *
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#getinstance
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#httprequest
    *
    * @memberof AsgardeoSPAClient
    *
    * @preserve
    */
-  static getInstance(id) {
-    if (id && this._instances?.get(id)) {
-      return this._instances.get(id);
-    } else if (!id && this._instances?.get(0)) {
-      return this._instances.get(0);
-    }
-    if (id) {
-      this._instances.set(id, new _AsgardeoSPAClient(id));
-      return this._instances.get(id);
-    }
-    this._instances.set(0, new _AsgardeoSPAClient(0));
-    return this._instances.get(0);
+  async httpRequest(config) {
+    await this._validateMethod(false);
+    return this._client?.httpRequest(config);
   }
   /**
-   * This method initializes the `AsgardeoSPAClient` instance.
+   * This method sends multiple API requests to a protected endpoint.
+   * The access token is automatically attached to the header of the request.
+   * This is the only way by which multiple requests can be sent to protected endpoints
+   * when the web worker is used to store session information.
    *
-   * @param {ConfigInterface} config The config object to initialize with.
+   * @param {HttpRequestConfig[]} config -  The config object containing attributes necessary to send a request.
    *
-   * @return {Promise<boolean>} - Resolves to `true` if initialization is successful.
+   * @return {Promise<HttpResponse[]>} - Returns a Promise that resolves with the responses to the requests.
    *
    * @example
    * ```
-   * auth.initialize({
-   *     signInRedirectURL: "http://localhost:3000/sign-in",
-   *     clientID: "client ID",
-   *     baseUrl: "https://api.asgardeo.io"
-   * });
+   *  const requestConfig = {
+   *      headers: {
+   *          "Accept": "application/json",
+   *          "Content-Type": "application/scim+json"
+   *      },
+   *      method: "GET",
+   *      url: "https://api.asgardeo.io/scim2/me"
+   *  };
+   *
+   *  const requestConfig2 = {
+   *      headers: {
+   *          "Accept": "application/json",
+   *          "Content-Type": "application/scim+json"
+   *      },
+   *      method: "GET",
+   *      url: "https://api.asgardeo.io/scim2/me"
+   *  };
+   *
+   *  return auth.httpRequest([requestConfig, requestConfig2])
+   *     .then((responses) => {
+   *           response.forEach((response)=>{
+   *              // console.log(response);
+   *           });
+   *      })
+   *      .catch((error) => {
+   *           // console.error(error);
+   *      });
    * ```
    *
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#initialize
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#httprequestall
    *
    * @memberof AsgardeoSPAClient
    *
    * @preserve
    */
-  async initialize(config, authHelper, workerFile) {
-    this._storage = config.storage ?? "sessionStorage" /* SessionStorage */;
-    this._initialized = false;
-    this._startedInitialize = true;
-    authHelper && this.instantiateAuthHelper(authHelper);
-    workerFile && this.instantiateWorker(workerFile);
-    const _config = await this._client?.getConfigData();
-    if (!(this._storage === "webWorker" /* WebWorker */)) {
-      const mainThreadClientConfig = config;
-      const defaultConfig = { ...DefaultConfig };
-      const mergedConfig = {
-        ...defaultConfig,
-        ...mainThreadClientConfig
-      };
-      if (!this._client || this._client && (!_config || Object.keys(_config)?.length === 0)) {
-        this._client = await MainThreadClient(
-          this._instanceID,
-          mergedConfig,
-          (authClient, spaHelper) => {
-            return new this._authHelper(authClient, spaHelper);
-          }
-        );
-      }
-      this._initialized = true;
-      if (this._onInitialize) {
-        this._onInitialize(true);
-      }
-      if (!mergedConfig.autoLogoutOnTokenRefreshError) {
-        return Promise.resolve(true);
-      }
-      window.addEventListener("message", (event) => {
-        if (event?.data?.type === REFRESH_ACCESS_TOKEN_ERR0R) {
-          this.signOut();
-        }
-      });
-      return Promise.resolve(true);
-    } else {
-      if (!this._client || this._client && (!_config || Object.keys(_config)?.length === 0)) {
-        const webWorkerClientConfig = config;
-        this._client = await WebWorkerClient(
-          this._instanceID,
-          {
-            ...DefaultConfig,
-            ...webWorkerClientConfig
-          },
-          this._worker,
-          (authClient, spaHelper) => {
-            return new this._authHelper(authClient, spaHelper);
-          }
-        );
-        return this._client.initialize().then(() => {
-          if (this._onInitialize) {
-            this._onInitialize(true);
-          }
-          this._initialized = true;
-          return Promise.resolve(true);
-        }).catch((error) => {
-          return Promise.reject(error);
-        });
-      }
-      return Promise.resolve(true);
-    }
+  async httpRequestAll(config) {
+    await this._validateMethod(false);
+    return this._client?.httpRequestAll(config);
   }
   /**
-   * This method returns a Promise that resolves with the basic user information obtained from the ID token.
+   * This method allows you to send a request with a custom grant.
+   *
+   * @param {CustomGrantRequestParams} config - The request parameters.
    *
-   * @return {Promise<BasicUserInfo>} - A promise that resolves with the user information.
+   * @return {Promise<HttpResponse<any> | SignInResponse>} - A Promise that resolves with
+   * the value returned by the custom grant request.
    *
    * @example
    * ```
-   * auth.getBasicUserInfo().then((response) => {
-   *    // console.log(response);
-   * }).catch((error) => {
-   *    // console.error(error);
+   * auth.customGrant({
+   *   attachToken: false,
+   *   data: {
+   *       client_id: "{{clientId}}",
+   *       grant_type: "account_switch",
+   *       scope: "{{scope}}",
+   *       token: "{{token}}",
+   *   },
+   *   id: "account-switch",
+   *   returnResponse: true,
+   *   returnsSession: true,
+   *   signInRequired: true
    * });
    * ```
    *
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#getuserinfo
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#customgrant
    *
    * @memberof AsgardeoSPAClient
    *
    * @preserve
    */
-  async getBasicUserInfo() {
-    await this._validateMethod();
-    return this._client?.getBasicUserInfo();
+  async exchangeToken(config) {
+    if (config.signInRequired) {
+      await this._validateMethod();
+    } else {
+      await this._validateMethod();
+    }
+    if (!config.id) {
+      return Promise.reject(
+        new AsgardeoAuthException4(
+          "SPA-AUTH_CLIENT-RCG-NF01",
+          "The custom grant request id not found.",
+          "The id attribute of the custom grant config object passed as an argument should have a value."
+        )
+      );
+    }
+    const customGrantResponse = await this._client?.exchangeToken(config);
+    const customGrantCallback = this._onCustomGrant.get(config.id);
+    customGrantCallback && customGrantCallback(this._onCustomGrant?.get(config.id));
+    return customGrantResponse;
   }
   /**
-   * This method initiates the authentication flow. This should be called twice.
-   *  1. To initiate the authentication flow.
-   *  2. To obtain the access token after getting the authorization code.
-   *
-   * To satisfy the second condition, one of the two strategies mentioned below can be used:
-   *  1. Redirect the user back to the same login page that initiated the authentication flow.
-   *  2. Call the `signIn()` method in the page the user is redirected to after authentication.
+   * This method ends a user session. The access token is revoked and the session information is destroyed.
    *
-   * **To fire a callback function after signing in, use the `on()` method.**
+   * **To fire a callback function after ending user session, use the `on()` method.**
    * **To learn more about the `on()` method:**
    * @see {@link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#on}
    *
-   * @param {SignInConfig} config - The sign-in config.
-   * The `SignInConfig` object has these two attributes in addition to any custom key-value pairs.
-   *  1. fidp - Specifies the FIDP parameter that is used to take the user directly to an IdP login page.
-   *  2. forceInit: Specifies if the OIDC Provider Meta Data should be loaded again from the `well-known`
-   * endpoint.
-   *  3. Any other parameters that should be appended to the authorization request.
-   * @param {string} authorizationCode - The authorization code. (Optional)
-   * @param {string} sessionState - The session state. (Optional)
-   * @param {string} state - The state. (Optional)
-   *
-   * @return {Promise<BasicUserInfo>} - A promise that resolves with the user information.
+   * @return {Promise<boolean>} - A promise that resolves with `true` if the process is successful.
    *
    * @example
    * ```
-   * auth.signIn();
+   * auth.endUserSession();
    * ```
    *
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#signin
-   *
-   * @memberof AsgardeoSPAClient
-   *
-   * @preserve
-   */
-  async signIn(config, authorizationCode, sessionState, state, tokenRequestConfig) {
-    await this._isInitialized();
-    if (!SPAUtils.canContinueSignIn(Boolean(config?.callOnlyOnRedirect), authorizationCode)) {
-      return void 0;
-    }
-    delete config?.callOnlyOnRedirect;
-    return this._client?.signIn(config, authorizationCode, sessionState, state, tokenRequestConfig).then((response) => {
-      if (this._onSignInCallback) {
-        if (response.allowedScopes || response.displayName || response.email || response.username) {
-          this._onSignInCallback(response);
-        }
-      }
-      return response;
-    });
-  }
-  /**
-   * This method allows you to sign in silently.
-   * First, this method sends a prompt none request to see if there is an active user session in the identity server.
-   * If there is one, then it requests the access token and stores it. Else, it returns false.
-   *
-   * If this method is to be called on page load and the `signIn` method is also to be called on page load,
-   * then it is advisable to call this method after the `signIn` call.
-   *
-   * @return {Promise<BasicUserInfo | boolean>} - A Promise that resolves with the user information after signing in
-   * or with `false` if the user is not signed in.
-   *
-   * @example
-   *```
-   * auth.trySignInSilently()
-   *```
-   */
-  async trySignInSilently(additionalParams, tokenRequestConfig) {
-    await this._isInitialized();
-    if (SPAUtils.wasSignInCalled()) {
-      return void 0;
-    }
-    return this._client?.trySignInSilently(additionalParams, tokenRequestConfig).then((response) => {
-      if (this._onSignInCallback && response) {
-        const basicUserInfo = response;
-        if (basicUserInfo.allowedScopes || basicUserInfo.displayName || basicUserInfo.email || basicUserInfo.username) {
-          this._onSignInCallback(basicUserInfo);
-        }
-      }
-      return response;
-    });
-  }
-  /**
-   * This method initiates the sign-out flow.
-   *
-   * **To fire a callback function after signing out, use the `on()` method.**
-   * **To learn more about the `on()` method:**
-   * @see {@link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#on}
-   *
-   * @return {Promise<boolean>} - Returns a promise that resolves with `true` if sign out is successful.
-   *
-   * @example
-   * ```
-   * auth.signOut();
-   * ```
-   *
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#signout
-   *
-   * @memberof AsgardeoSPAClient
-   *
-   * @preserve
-   */
-  async signOut() {
-    await this._validateMethod(false);
-    const signOutResponse = await this._client?.signOut() ?? false;
-    return signOutResponse;
-  }
-  /**
-   * This method sends an API request to a protected endpoint.
-   * The access token is automatically attached to the header of the request.
-   * This is the only way by which protected endpoints can be accessed
-   * when the web worker is used to store session information.
-   *
-   * @param {HttpRequestConfig} config -  The config object containing attributes necessary to send a request.
-   *
-   * @return {Promise<HttpResponse>} - Returns a Promise that resolves with the response to the request.
-   *
-   * @example
-   * ```
-   *  const requestConfig = {
-   *      headers: {
-   *          "Accept": "application/json",
-   *          "Access-Control-Allow-Origin": "https://api.asgardeo.io/myaccount",
-   *          "Content-Type": "application/scim+json"
-   *      },
-   *      method: "GET",
-   *      url: "https://api.asgardeo.io/scim2/me"
-   *  };
-   *
-   *  return auth.httpRequest(requestConfig)
-   *     .then((response) => {
-   *           // console.log(response);
-   *      })
-   *      .catch((error) => {
-   *           // console.error(error);
-   *      });
-   * ```
-   *
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#httprequest
-   *
-   * @memberof AsgardeoSPAClient
-   *
-   * @preserve
-   */
-  async httpRequest(config) {
-    await this._validateMethod(false);
-    return this._client?.httpRequest(config);
-  }
-  /**
-   * This method sends multiple API requests to a protected endpoint.
-   * The access token is automatically attached to the header of the request.
-   * This is the only way by which multiple requests can be sent to protected endpoints
-   * when the web worker is used to store session information.
-   *
-   * @param {HttpRequestConfig[]} config -  The config object containing attributes necessary to send a request.
-   *
-   * @return {Promise<HttpResponse[]>} - Returns a Promise that resolves with the responses to the requests.
-   *
-   * @example
-   * ```
-   *  const requestConfig = {
-   *      headers: {
-   *          "Accept": "application/json",
-   *          "Content-Type": "application/scim+json"
-   *      },
-   *      method: "GET",
-   *      url: "https://api.asgardeo.io/scim2/me"
-   *  };
-   *
-   *  const requestConfig2 = {
-   *      headers: {
-   *          "Accept": "application/json",
-   *          "Content-Type": "application/scim+json"
-   *      },
-   *      method: "GET",
-   *      url: "https://api.asgardeo.io/scim2/me"
-   *  };
-   *
-   *  return auth.httpRequest([requestConfig, requestConfig2])
-   *     .then((responses) => {
-   *           response.forEach((response)=>{
-   *              // console.log(response);
-   *           });
-   *      })
-   *      .catch((error) => {
-   *           // console.error(error);
-   *      });
-   * ```
-   *
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#httprequestall
-   *
-   * @memberof AsgardeoSPAClient
-   *
-   * @preserve
-   */
-  async httpRequestAll(config) {
-    await this._validateMethod(false);
-    return this._client?.httpRequestAll(config);
-  }
-  /**
-   * This method allows you to send a request with a custom grant.
-   *
-   * @param {CustomGrantRequestParams} config - The request parameters.
-   *
-   * @return {Promise<HttpResponse<any> | SignInResponse>} - A Promise that resolves with
-   * the value returned by the custom grant request.
-   *
-   * @example
-   * ```
-   * auth.customGrant({
-   *   attachToken: false,
-   *   data: {
-   *       client_id: "{{clientId}}",
-   *       grant_type: "account_switch",
-   *       scope: "{{scope}}",
-   *       token: "{{token}}",
-   *   },
-   *   id: "account-switch",
-   *   returnResponse: true,
-   *   returnsSession: true,
-   *   signInRequired: true
-   * });
-   * ```
-   *
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#customgrant
-   *
-   * @memberof AsgardeoSPAClient
-   *
-   * @preserve
-   */
-  async requestCustomGrant(config) {
-    if (config.signInRequired) {
-      await this._validateMethod();
-    } else {
-      await this._validateMethod();
-    }
-    if (!config.id) {
-      return Promise.reject(
-        new AsgardeoAuthException5(
-          "SPA-AUTH_CLIENT-RCG-NF01",
-          "The custom grant request id not found.",
-          "The id attribute of the custom grant config object passed as an argument should have a value."
-        )
-      );
-    }
-    const customGrantResponse = await this._client?.requestCustomGrant(config);
-    const customGrantCallback = this._onCustomGrant.get(config.id);
-    customGrantCallback && customGrantCallback(this._onCustomGrant?.get(config.id));
-    return customGrantResponse;
-  }
-  /**
-   * This method ends a user session. The access token is revoked and the session information is destroyed.
-   *
-   * **To fire a callback function after ending user session, use the `on()` method.**
-   * **To learn more about the `on()` method:**
-   * @see {@link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#on}
-   *
-   * @return {Promise<boolean>} - A promise that resolves with `true` if the process is successful.
-   *
-   * @example
-   * ```
-   * auth.endUserSession();
-   * ```
-   *
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#endusersession
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#endusersession
    *
    * @memberof AsgardeoSPAClient
    *
@@ -4932,9 +4575,9 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @preserve
    */
-  async getOIDCServiceEndpoints() {
-    await this._isInitialized();
-    return this._client?.getOIDCServiceEndpoints();
+  async getOpenIDProviderEndpoints() {
+    await this.isInitialized();
+    return this._client?.getOpenIDProviderEndpoints();
   }
   /**
    * This methods returns the Axios http client.
@@ -4951,13 +4594,13 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
         const mainThreadClient = this._client;
         return mainThreadClient.getHttpClient();
       }
-      throw new AsgardeoAuthException5(
+      throw new AsgardeoAuthException4(
         "SPA-AUTH_CLIENT-GHC-IV01",
         "Http client cannot be returned.",
         "The http client cannot be returned when the storage type is set to webWorker."
       );
     }
-    throw new AsgardeoAuthException5(
+    throw new AsgardeoAuthException4(
       "SPA-AUTH_CLIENT-GHC-NF02",
       "The SDK is not initialized.",
       "The SDK has not been initialized yet. Initialize the SDK using the initialize method before calling this method."
@@ -4971,7 +4614,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @example
    * ```
-   * auth.getDecodedIDToken().then((response)=>{
+   * auth.getDecodedIdToken().then((response)=>{
    *     // console.log(response);
    * }).catch((error)=>{
    *     // console.error(error);
@@ -4983,9 +4626,9 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @preserve
    */
-  async getDecodedIDToken() {
+  async getDecodedIdToken() {
     await this._validateMethod();
-    return this._client?.getDecodedIDToken();
+    return this._client?.getDecodedIdToken();
   }
   /**
    * This method returns the IsomorphicCrypto instance.
@@ -4995,21 +4638,21 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @example
    * ```
-   * auth.getCryptoHelper().then((response)=>{
+   * auth.getCrypto().then((response)=>{
    *     // console.log(response);
    * }).catch((error)=>{
    *     // console.error(error);
    * });
    * ```
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#getCryptoHelper
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#getCrypto
    *
    * @memberof AsgardeoSPAClient
    *
    * @preserve
    */
-  async getCryptoHelper() {
+  async getCrypto() {
     await this._validateMethod();
-    return this._client?.getCryptoHelper();
+    return this._client?.getCrypto();
   }
   /**
    * This method return the ID token.
@@ -5018,18 +4661,18 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @example
    * ```
-   * const idToken = await auth.getIDToken();
+   * const idToken = await auth.getIdToken();
    * ```
    *
-   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getIDToken
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getIdToken
    *
    * @memberof AsgardeoAuthClient
    *
    * @preserve
    */
-  async getIDToken() {
+  async getIdToken() {
     await this._validateMethod();
-    return this._client?.getIDToken();
+    return this._client?.getIdToken();
   }
   /**
    * This method return a Promise that resolves with the access token.
@@ -5057,7 +4700,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
     await this._validateMethod();
     if (this._storage && [("webWorker" /* WebWorker */, "browserMemory" /* BrowserMemory */)].includes(this._storage)) {
       return Promise.reject(
-        new AsgardeoAuthException5(
+        new AsgardeoAuthException4(
           "SPA-AUTH_CLIENT-GAT-IV01",
           "The access token cannot be returned.",
           "The access token cannot be returned when the storage type is set to webWorker or browserMemory."
@@ -5093,7 +4736,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
     await this._validateMethod();
     if (this._storage && [("webWorker" /* WebWorker */, "browserMemory" /* BrowserMemory */)].includes(this._storage)) {
       return Promise.reject(
-        new AsgardeoAuthException5(
+        new AsgardeoAuthException4(
           "SPA-AUTH_CLIENT-GIAT-IV01",
           "The access token cannot be returned.",
           "The access token cannot be returned when the storage type is set to webWorker or browserMemory."
@@ -5112,7 +4755,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @example
    * ```
-   *   auth.getDataLayer().then((dataLayer) => {
+   *   auth.getStorageManager().then((dataLayer) => {
    *       // console.log(dataLayer);
    *   }).catch((error) => {
    *       // console.error(error);
@@ -5125,11 +4768,11 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @preserve
    */
-  async getDataLayer() {
+  async getStorageManager() {
     await this._validateMethod();
     if (this._storage && [("webWorker" /* WebWorker */, "browserMemory" /* BrowserMemory */)].includes(this._storage)) {
       return Promise.reject(
-        new AsgardeoAuthException5(
+        new AsgardeoAuthException4(
           "SPA-AUTH_CLIENT-GDL-IV01",
           "The data layer cannot be returned.",
           "The data layer cannot be returned when the storage type is set to webWorker or browserMemory."
@@ -5137,7 +4780,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
       );
     }
     const mainThreadClient = this._client;
-    return mainThreadClient.getDataLayer();
+    return mainThreadClient.getStorageManager();
   }
   /**
    * This method return a Promise that resolves with the config data stored in the storage.
@@ -5196,9 +4839,9 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @preserve
    */
-  async isAuthenticated() {
-    await this._isInitialized();
-    return this._client?.isAuthenticated();
+  async isSignedIn() {
+    await this.isInitialized();
+    return this._client?.isSignedIn();
   }
   /**
    * This method specifies if there is an active session in the browser or not.
@@ -5210,10 +4853,10 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    * @preserve
    */
   async isSessionActive() {
-    await this._isInitialized();
+    await this.isInitialized();
     if (this._storage && [("webWorker" /* WebWorker */, "browserMemory" /* BrowserMemory */)].includes(this._storage)) {
       return Promise.reject(
-        new AsgardeoAuthException5(
+        new AsgardeoAuthException4(
           "SPA-AUTH_CLIENT-ISA-IV01",
           "The active session cannot be returned.",
           "The active session cannot be returned when the storage type is set to webWorker or browserMemory."
@@ -5224,7 +4867,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
     return mainThreadClient?.isSessionActive();
   }
   async on(hook, callback, id) {
-    await this._isInitialized();
+    await this.isInitialized();
     if (callback && typeof callback === "function") {
       switch (hook) {
         case "sign-in" /* SignIn */:
@@ -5266,10 +4909,10 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
           break;
         }
         default:
-          throw new AsgardeoAuthException5("SPA-AUTH_CLIENT-ON-IV01", "Invalid hook.", "The provided hook is invalid.");
+          throw new AsgardeoAuthException4("SPA-AUTH_CLIENT-ON-IV01", "Invalid hook.", "The provided hook is invalid.");
       }
     } else {
-      throw new AsgardeoAuthException5(
+      throw new AsgardeoAuthException4(
         "SPA-AUTH_CLIENT-ON-IV02",
         "Invalid callback function.",
         "The provided callback function is invalid."
@@ -5293,7 +4936,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    * @preserve
    */
   async enableHttpHandler() {
-    await this._isInitialized();
+    await this.isInitialized();
     return this._client?.enableHttpHandler();
   }
   /**
@@ -5313,7 +4956,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    * @preserve
    */
   async disableHttpHandler() {
-    await this._isInitialized();
+    await this.isInitialized();
     return this._client?.disableHttpHandler();
   }
   /**
@@ -5324,26 +4967,26 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    * @example
    * ```
    * const config = {
-   *     signInRedirectURL: "http://localhost:3000/sign-in",
-   *     clientID: "client ID",
+   *     afterSignInUrl: "http://localhost:3000/sign-in",
+   *     clientId: "client ID",
    *     baseUrl: "https://api.asgardeo.io"
    * }
-   * const auth.updateConfig(config);
+   * const auth.reInitialize(config);
    * ```
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master/lib#updateConfig
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master/lib#reInitialize
    *
    * @memberof AsgardeoAuthClient
    *
    * @preserve
    */
-  async updateConfig(config) {
-    await this._isInitialized();
+  async reInitialize(config) {
+    await this.isInitialized();
     if (this._storage === "webWorker" /* WebWorker */) {
       const client = this._client;
-      await client.updateConfig(config);
+      await client.reInitialize(config);
     } else {
       const client = this._client;
-      await client.updateConfig(config);
+      await client.reInitialize(config);
     }
     return;
   }
@@ -5368,13 +5011,374 @@ import {
 } from "axios";
 
 // src/__legacy__/models/web-worker.ts
-var WebWorkerClass = class extends Worker {
+var WebWorkerClass = class {
   constructor() {
-    super(...arguments);
     __publicField(this, "onmessage", () => null);
+    __publicField(this, "postMessage", () => null);
   }
 };
 
+// src/__legacy__/worker/worker-receiver.ts
+import { AsgardeoAuthException as AsgardeoAuthException5 } from "@asgardeo/javascript";
+
+// src/__legacy__/worker/worker-core.ts
+import {
+  AsgardeoAuthClient as AsgardeoAuthClient8,
+  OIDCRequestConstants as OIDCRequestConstants5
+} from "@asgardeo/javascript";
+var WebWorkerCore = async (config, getAuthHelper) => {
+  const _store = new MemoryStore();
+  const _cryptoUtils = new SPACryptoUtils();
+  const _authenticationClient = new AsgardeoAuthClient8();
+  await _authenticationClient.initialize(config, _store, _cryptoUtils);
+  const _spaHelper = new SPAHelper(_authenticationClient);
+  const _authenticationHelper = getAuthHelper(
+    _authenticationClient,
+    _spaHelper
+  );
+  const _dataLayer = _authenticationClient.getStorageManager();
+  const _httpClient = HttpClient.getInstance();
+  const attachToken = async (request) => {
+    await _authenticationHelper.attachTokenToRequestConfig(request);
+  };
+  _httpClient?.init && await _httpClient.init(true, attachToken);
+  const setHttpRequestStartCallback = (callback) => {
+    _httpClient?.setHttpRequestStartCallback && _httpClient.setHttpRequestStartCallback(callback);
+  };
+  const setHttpRequestSuccessCallback = (callback) => {
+    _httpClient?.setHttpRequestSuccessCallback && _httpClient.setHttpRequestSuccessCallback(callback);
+  };
+  const setHttpRequestFinishCallback = (callback) => {
+    _httpClient?.setHttpRequestFinishCallback && _httpClient.setHttpRequestFinishCallback(callback);
+  };
+  const httpRequest = async (requestConfig) => {
+    return await _authenticationHelper.httpRequest(_httpClient, requestConfig);
+  };
+  const httpRequestAll = async (requestConfigs) => {
+    return await _authenticationHelper.httpRequestAll(requestConfigs, _httpClient);
+  };
+  const enableHttpHandler = () => {
+    _authenticationHelper.enableHttpHandler(_httpClient);
+  };
+  const disableHttpHandler = () => {
+    _authenticationHelper.disableHttpHandler(_httpClient);
+  };
+  const getSignInUrl = async (params) => {
+    return _authenticationClient.getSignInUrl(params).then(async (url) => {
+      const urlObject = new URL(url);
+      const state = urlObject.searchParams.get(OIDCRequestConstants5.Params.STATE) ?? "";
+      const pkce = await _authenticationClient.getPKCECode(state);
+      return { authorizationURL: url, pkce };
+    }).catch((error) => Promise.reject(error));
+  };
+  const startAutoRefreshToken = async () => {
+    _spaHelper.clearRefreshTokenTimeout();
+    _spaHelper.refreshAccessTokenAutomatically(_authenticationHelper);
+    return;
+  };
+  const requestAccessToken = async (authorizationCode, sessionState, pkce, state) => {
+    return await _authenticationHelper.requestAccessToken(authorizationCode, sessionState, void 0, pkce, state);
+  };
+  const signOut = async () => {
+    _spaHelper.clearRefreshTokenTimeout();
+    return await _authenticationClient.getSignOutUrl();
+  };
+  const getSignOutUrl = async () => {
+    return await _authenticationClient.getSignOutUrl();
+  };
+  const exchangeToken = async (config2) => {
+    return await _authenticationHelper.exchangeToken(config2);
+  };
+  const refreshAccessToken = async () => {
+    try {
+      return await _authenticationHelper.refreshAccessToken();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  };
+  const revokeAccessToken = async () => {
+    const timer = await _spaHelper.getRefreshTimeoutTimer();
+    return _authenticationClient.revokeAccessToken().then(() => {
+      _spaHelper.clearRefreshTokenTimeout(timer);
+      return Promise.resolve(true);
+    }).catch((error) => Promise.reject(error));
+  };
+  const getUser = async () => {
+    return _authenticationHelper.getUser();
+  };
+  const getDecodedIdToken = async () => {
+    return _authenticationHelper.getDecodedIdToken();
+  };
+  const getCrypto = async () => {
+    return _authenticationHelper.getCrypto();
+  };
+  const getDecodedIDPIDToken = async () => {
+    return _authenticationHelper.getDecodedIDPIDToken();
+  };
+  const getIdToken = async () => {
+    return _authenticationHelper.getIdToken();
+  };
+  const getOpenIDProviderEndpoints = async () => {
+    return _authenticationHelper.getOpenIDProviderEndpoints();
+  };
+  const getAccessToken = () => {
+    return _authenticationHelper.getAccessToken();
+  };
+  const isSignedIn = () => {
+    return _authenticationHelper.isSignedIn();
+  };
+  const setSessionState = async (sessionState) => {
+    await _dataLayer.setSessionDataParameter(
+      OIDCRequestConstants5.Params.SESSION_STATE,
+      sessionState
+    );
+    return;
+  };
+  const reInitialize = async (config2) => {
+    await _authenticationClient.reInitialize(config2);
+    return;
+  };
+  const getConfigData = async () => {
+    return _dataLayer.getConfigData();
+  };
+  return {
+    disableHttpHandler,
+    enableHttpHandler,
+    getAccessToken,
+    getSignInUrl,
+    getUser,
+    getConfigData,
+    getCrypto,
+    getDecodedIDPIDToken,
+    getDecodedIdToken,
+    getIdToken,
+    getOpenIDProviderEndpoints,
+    getSignOutUrl,
+    httpRequest,
+    httpRequestAll,
+    isSignedIn,
+    refreshAccessToken,
+    requestAccessToken,
+    exchangeToken,
+    revokeAccessToken,
+    setHttpRequestFinishCallback,
+    setHttpRequestStartCallback,
+    setHttpRequestSuccessCallback,
+    setSessionState,
+    signOut,
+    startAutoRefreshToken,
+    reInitialize
+  };
+};
+
+// src/__legacy__/worker/worker-receiver.ts
+var workerReceiver = (getAuthHelper) => {
+  const ctx = self;
+  let webWorker;
+  ctx.onmessage = async ({ data, ports }) => {
+    const port = ports[0];
+    if (data.type !== INIT && !webWorker) {
+      port.postMessage(
+        MessageUtils.generateFailureMessage(
+          new AsgardeoAuthException5(
+            "SPA-CLIENT_WORKER-ONMSG-NF01",
+            "The web worker has not been initialized yet.",
+            "The initialize method needs to be called before the specified operation can be carried out."
+          )
+        )
+      );
+      return;
+    }
+    switch (data.type) {
+      case INIT:
+        try {
+          const config = { ...data.data };
+          webWorker = await WebWorkerCore(config, getAuthHelper);
+          webWorker.setHttpRequestFinishCallback(onRequestFinishCallback);
+          webWorker.setHttpRequestStartCallback(onRequestStartCallback);
+          webWorker.setHttpRequestSuccessCallback(onRequestSuccessCallback);
+          port.postMessage(MessageUtils.generateSuccessMessage());
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case GET_AUTH_URL:
+        webWorker.getSignInUrl(data?.data).then((response) => {
+          port.postMessage(MessageUtils.generateSuccessMessage(response));
+        }).catch((error) => {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        });
+        break;
+      case REQUEST_ACCESS_TOKEN:
+        webWorker.requestAccessToken(data?.data?.code, data?.data?.sessionState, data?.data?.pkce, data?.data?.state).then((response) => {
+          port.postMessage(MessageUtils.generateSuccessMessage(response));
+        }).catch((error) => {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        });
+        break;
+      case HTTP_REQUEST: {
+        const request = data.data;
+        const requestData = request?.data;
+        if (data.data?.data?.formData === true) {
+          const formData = new FormData();
+          for (const key in requestData) {
+            if (key === "formData") {
+              continue;
+            }
+            formData.append(key, requestData[key]);
+          }
+          request.data = formData;
+        }
+        webWorker.httpRequest(request).then((response) => {
+          port.postMessage(MessageUtils.generateSuccessMessage(response));
+        }).catch((error) => {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        });
+        break;
+      }
+      case HTTP_REQUEST_ALL:
+        webWorker.httpRequestAll(data.data).then((response) => {
+          port.postMessage(MessageUtils.generateSuccessMessage(response));
+        }).catch((error) => {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        });
+        break;
+      case SIGN_OUT:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.signOut()));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case REQUEST_CUSTOM_GRANT:
+        webWorker.exchangeToken(data.data).then((response) => {
+          port.postMessage(MessageUtils.generateSuccessMessage(response));
+        }).catch((error) => {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        });
+        break;
+      case REVOKE_ACCESS_TOKEN:
+        webWorker.revokeAccessToken().then((response) => {
+          port.postMessage(MessageUtils.generateSuccessMessage(response));
+        }).catch((error) => {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        });
+        break;
+      case GET_OIDC_SERVICE_ENDPOINTS:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getOpenIDProviderEndpoints()));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case GET_BASIC_USER_INFO:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getUser()));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case GET_DECODED_ID_TOKEN:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getDecodedIdToken()));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case GET_CRYPTO_HELPER:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getCrypto()));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case GET_ID_TOKEN:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getIdToken()));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case ENABLE_HTTP_HANDLER:
+        webWorker.enableHttpHandler();
+        port.postMessage(MessageUtils.generateSuccessMessage());
+        break;
+      case DISABLE_HTTP_HANDLER:
+        webWorker.disableHttpHandler();
+        port.postMessage(MessageUtils.generateSuccessMessage());
+        break;
+      case IS_AUTHENTICATED:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.isSignedIn()));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case GET_SIGN_OUT_URL:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getSignOutUrl()));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case REFRESH_ACCESS_TOKEN:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.refreshAccessToken()));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case START_AUTO_REFRESH_TOKEN:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(webWorker.startAutoRefreshToken()));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case SET_SESSION_STATE:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.setSessionState(data?.data)));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case UPDATE_CONFIG:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.reInitialize(data?.data)));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      case GET_CONFIG_DATA:
+        try {
+          port.postMessage(MessageUtils.generateSuccessMessage(await webWorker.getConfigData()));
+        } catch (error) {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        }
+        break;
+      default:
+        port?.postMessage(
+          MessageUtils.generateFailureMessage(
+            new AsgardeoAuthException5(
+              "SPA-CLIENT_WORKER-ONMSG-IV02",
+              "The message type is invalid.",
+              `The message type provided, ${data.type}, is invalid.`
+            )
+          )
+        );
+    }
+  };
+  const onRequestStartCallback = () => {
+    ctx.postMessage({ type: REQUEST_START });
+  };
+  const onRequestSuccessCallback = (response) => {
+    ctx.postMessage({ data: JSON.stringify(response ?? ""), type: REQUEST_SUCCESS });
+  };
+  const onRequestFinishCallback = () => {
+    ctx.postMessage({ type: REQUEST_FINISH });
+  };
+};
+
 // src/constants/StyleConstants.ts
 var StyleConstants = class {
   constructor() {