@asgardeo/browser 0.0.1 → 0.1.1

package/dist/index.js

@@ -1914,13 +1914,15 @@ 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 AsgardeoAuthClient4,
+  OIDCRequestConstants as OIDCRequestConstants3,
+  extractPkceStorageKeyFromState,
+  initializeEmbeddedSignInFlow
 } from "@asgardeo/javascript";
 
 // src/__legacy__/constants/messages-types.ts
@@ -1991,6 +1993,9 @@ var STATE_QUERY = "state";
 // src/__legacy__/constants/errors.ts
 var ACCESS_TOKEN_INVALID = "Access token is invalid";
 
+// src/__legacy__/helpers/session-management-helper.ts
+import { AsgardeoAuthClient as AsgardeoAuthClient2, OIDCRequestConstants as OIDCRequestConstants2 } from "@asgardeo/javascript";
+
 // src/__legacy__/utils/message-utils.ts
 var MessageUtils = class {
   // eslint-disable-next-line @typescript-eslint/no-empty-function
@@ -2046,15 +2051,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 +2113,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;
@@ -2203,1678 +2208,1276 @@ __publicField(_SPAUtils, "until", (condition, timeout = 500) => {
 });
 var SPAUtils = _SPAUtils;
 
-// src/__legacy__/helpers/authentication-helper.ts
-var AuthenticationHelper = class {
-  constructor(authClient, spaHelper) {
-    __publicField(this, "_authenticationClient");
-    __publicField(this, "_dataLayer");
-    __publicField(this, "_spaHelper");
-    __publicField(this, "_instanceID");
-    __publicField(this, "_isTokenRefreshing");
-    this._authenticationClient = authClient;
-    this._dataLayer = this._authenticationClient.getDataLayer();
-    this._spaHelper = spaHelper;
-    this._instanceID = this._authenticationClient.getInstanceID();
-    this._isTokenRefreshing = false;
-  }
-  enableHttpHandler(httpClient) {
-    httpClient?.enableHandler && httpClient.enableHandler();
-  }
-  disableHttpHandler(httpClient) {
-    httpClient?.disableHandler && httpClient.disableHandler();
-  }
-  initializeSessionManger(config, oidcEndpoints, getSessionState, getAuthzURL, sessionManagementHelper) {
-    sessionManagementHelper.initialize(
-      config.clientID,
-      oidcEndpoints.checkSessionIframe ?? "",
-      getSessionState,
-      config.checkSessionInterval ?? 3,
-      config.sessionRefreshInterval ?? 300,
-      config.signInRedirectURL,
-      getAuthzURL
-    );
-  }
-  async requestCustomGrant(config, enableRetrievingSignOutURLFromSession) {
-    let useDefaultEndpoint = true;
-    let matches = false;
-    if (config?.tokenEndpoint) {
-      useDefaultEndpoint = false;
-      for (const baseUrl of [
-        ...(await this._dataLayer.getConfigData())?.resourceServerURLs ?? [],
-        config.baseUrl
-      ]) {
-        if (baseUrl && config.tokenEndpoint?.startsWith(baseUrl)) {
-          matches = true;
-          break;
-        }
-      }
+// src/__legacy__/helpers/session-management-helper.ts
+var SessionManagementHelper = /* @__PURE__ */ (() => {
+  let _clientID;
+  let _checkSessionEndpoint;
+  let _sessionState;
+  let _interval;
+  let _redirectURL;
+  let _sessionRefreshInterval;
+  let _signOut;
+  let _sessionRefreshIntervalTimeout;
+  let _checkSessionIntervalTimeout;
+  let _storage;
+  let _setSessionState;
+  let _getSignInUrl;
+  const initialize = (clientId, checkSessionEndpoint, getSessionState, interval, sessionRefreshInterval, redirectURL, getSignInUrl) => {
+    _clientID = clientId;
+    _checkSessionEndpoint = checkSessionEndpoint;
+    _sessionState = getSessionState;
+    _interval = interval;
+    _redirectURL = redirectURL;
+    _sessionRefreshInterval = sessionRefreshInterval;
+    _getSignInUrl = getSignInUrl;
+    if (_interval > -1) {
+      initiateCheckSession();
     }
-    if (config.shouldReplayAfterRefresh) {
-      this._dataLayer.setTemporaryDataParameter(CUSTOM_GRANT_CONFIG, JSON.stringify(config));
+    if (_sessionRefreshInterval > -1) {
+      sessionRefreshInterval = setInterval(() => {
+        sendPromptNoneRequest();
+      }, _sessionRefreshInterval * 1e3);
     }
-    if (useDefaultEndpoint || matches) {
-      return this._authenticationClient.requestCustomGrant(config).then(async (response) => {
-        if (enableRetrievingSignOutURLFromSession && typeof enableRetrievingSignOutURLFromSession === "function") {
-          enableRetrievingSignOutURLFromSession(config);
-        }
-        if (config.returnsSession) {
-          this._spaHelper.refreshAccessTokenAutomatically(this);
-          return this._authenticationClient.getBasicUserInfo();
-        } else {
-          return response;
-        }
-      }).catch((error) => {
-        return Promise.reject(error);
-      });
-    } else {
-      return Promise.reject(
-        new AsgardeoAuthException(
-          "SPA-MAIN_THREAD_CLIENT-RCG-IV01",
-          "Request to the provided endpoint is prohibited.",
-          "Requests can only be sent to resource servers specified by the `resourceServerURLs` attribute while initializing the SDK. The specified token endpoint in this request cannot be found among the `resourceServerURLs`"
-        )
-      );
+  };
+  const initiateCheckSession = async () => {
+    if (!_checkSessionEndpoint || !_clientID || !_redirectURL) {
+      return;
     }
-  }
-  async getCustomGrantConfigData() {
-    const configString = await this._dataLayer.getTemporaryDataParameter(CUSTOM_GRANT_CONFIG);
-    if (configString) {
-      return JSON.parse(configString);
-    } else {
-      return null;
+    const OP_IFRAME2 = "opIFrame";
+    async function checkSession() {
+      const sessionState = await _sessionState();
+      if (Boolean(_clientID) && Boolean(sessionState)) {
+        const message = `${_clientID} ${sessionState}`;
+        const rpIFrame2 = document.getElementById(RP_IFRAME);
+        const opIframe2 = rpIFrame2?.contentDocument?.getElementById(OP_IFRAME2);
+        const win = opIframe2.contentWindow;
+        win?.postMessage(message, _checkSessionEndpoint);
+      }
     }
-  }
-  async refreshAccessToken(enableRetrievingSignOutURLFromSession) {
-    try {
-      await this._authenticationClient.refreshAccessToken();
-      const customGrantConfig = await this.getCustomGrantConfigData();
-      if (customGrantConfig) {
-        await this.requestCustomGrant(customGrantConfig, enableRetrievingSignOutURLFromSession);
+    const rpIFrame = document.getElementById(RP_IFRAME);
+    const opIframe = rpIFrame?.contentDocument?.getElementById(OP_IFRAME2);
+    opIframe.src = _checkSessionEndpoint + "?client_id=" + _clientID + "&redirect_uri=" + _redirectURL;
+    _checkSessionIntervalTimeout = setInterval(checkSession, _interval * 1e3);
+    listenToResponseFromOPIFrame();
+  };
+  const reset = () => {
+    clearInterval(_checkSessionIntervalTimeout);
+    clearInterval(_sessionRefreshIntervalTimeout);
+  };
+  const listenToResponseFromOPIFrame = () => {
+    async function receiveMessage(e) {
+      const targetOrigin = _checkSessionEndpoint;
+      if (!targetOrigin || targetOrigin?.indexOf(e.origin) < 0 || e?.data?.type === SET_SESSION_STATE_FROM_IFRAME) {
+        return;
       }
-      this._spaHelper.refreshAccessTokenAutomatically(this);
-      return this._authenticationClient.getBasicUserInfo();
-    } catch (error) {
-      const refreshTokenError = {
-        type: REFRESH_ACCESS_TOKEN_ERR0R
+      if (e.data === "unchanged") {
+      } else if (e.data === "error") {
+        window.location.href = await _signOut();
+      } else if (e.data === "changed") {
+        sendPromptNoneRequest();
+      }
+    }
+    window?.addEventListener("message", receiveMessage, false);
+  };
+  const sendPromptNoneRequest = async () => {
+    const rpIFrame = document.getElementById(RP_IFRAME);
+    const promptNoneIFrame = rpIFrame?.contentDocument?.getElementById(
+      PROMPT_NONE_IFRAME
+    );
+    if (SPAUtils.canSendPromptNoneRequest()) {
+      SPAUtils.setPromptNoneRequestSent(true);
+      const receiveMessageListener = (e) => {
+        if (e?.data?.type === SET_SESSION_STATE_FROM_IFRAME) {
+          _setSessionState(e?.data?.data ?? "");
+          window?.removeEventListener("message", receiveMessageListener);
+        }
       };
-      window.postMessage(refreshTokenError);
-      return Promise.reject(error);
+      if (_storage === "browserMemory" /* BrowserMemory */ || _storage === "webWorker" /* WebWorker */) {
+        window?.addEventListener("message", receiveMessageListener);
+      }
+      const promptNoneURL = await _getSignInUrl({
+        prompt: "none",
+        response_mode: "query",
+        state: STATE
+      });
+      promptNoneIFrame.src = promptNoneURL;
     }
-  }
-  async retryFailedRequests(failedRequest) {
-    const httpClient = failedRequest.httpClient;
-    const requestConfig = failedRequest.requestConfig;
-    const isHttpHandlerEnabled = failedRequest.isHttpHandlerEnabled;
-    const httpErrorCallback = failedRequest.httpErrorCallback;
-    const httpFinishCallback = failedRequest.httpFinishCallback;
-    await SPAUtils.until(() => !this._isTokenRefreshing);
-    try {
-      const httpResponse = await httpClient.request(requestConfig);
-      return Promise.resolve(httpResponse);
-    } catch (error) {
-      if (isHttpHandlerEnabled) {
-        if (typeof httpErrorCallback === "function") {
-          await httpErrorCallback(error);
+  };
+  const receivePromptNoneResponse = async (setSessionState) => {
+    const state = new URL(window.location.href).searchParams.get(STATE_QUERY);
+    const sessionState = new URL(window.location.href).searchParams.get(OIDCRequestConstants2.Params.SESSION_STATE);
+    const parent = window.parent.parent;
+    if (state !== null && (state.includes(STATE) || state.includes(SILENT_SIGN_IN_STATE))) {
+      const code = new URL(window.location.href).searchParams.get("code");
+      if (code !== null && code.length !== 0) {
+        if (state.includes(SILENT_SIGN_IN_STATE)) {
+          const message = {
+            data: {
+              code,
+              sessionState: sessionState ?? "",
+              state
+            },
+            type: CHECK_SESSION_SIGNED_IN
+          };
+          sessionStorage.setItem(INITIALIZED_SILENT_SIGN_IN, "false");
+          parent.postMessage(message, parent.origin);
+          SPAUtils.setPromptNoneRequestSent(false);
+          window.location.href = "about:blank";
+          await SPAUtils.waitTillPageRedirect();
+          return true;
         }
-        if (typeof httpFinishCallback === "function") {
-          httpFinishCallback();
+        const newSessionState = new URL(window.location.href).searchParams.get("session_state");
+        if (_storage === "localStorage" /* LocalStorage */ || _storage === "sessionStorage" /* SessionStorage */) {
+          setSessionState && await setSessionState(newSessionState);
+        } else {
+          const message = {
+            data: newSessionState ?? "",
+            type: SET_SESSION_STATE_FROM_IFRAME
+          };
+          window?.parent?.parent?.postMessage(message);
+        }
+        SPAUtils.setPromptNoneRequestSent(false);
+        window.location.href = "about:blank";
+        await SPAUtils.waitTillPageRedirect();
+        return true;
+      } else {
+        if (state.includes(SILENT_SIGN_IN_STATE)) {
+          const message = {
+            type: CHECK_SESSION_SIGNED_OUT
+          };
+          window.parent.parent.postMessage(message, parent.origin);
+          SPAUtils.setPromptNoneRequestSent(false);
+          window.location.href = "about:blank";
+          await SPAUtils.waitTillPageRedirect();
+          return true;
         }
+        SPAUtils.setPromptNoneRequestSent(false);
+        const signOutURL = await _signOut();
+        await AsgardeoAuthClient2.clearSession();
+        parent.location.href = signOutURL;
+        window.location.href = "about:blank";
+        await SPAUtils.waitTillPageRedirect();
+        return true;
       }
-      return Promise.reject(error);
     }
-  }
-  async httpRequest(httpClient, requestConfig, isHttpHandlerEnabled, httpErrorCallback, httpFinishCallback, enableRetrievingSignOutURLFromSession) {
-    let matches = false;
-    const config = await this._dataLayer.getConfigData();
-    for (const baseUrl of [...await config?.resourceServerURLs ?? [], config.baseUrl]) {
-      if (baseUrl && requestConfig?.url?.startsWith(baseUrl)) {
-        matches = true;
-        break;
+    return false;
+  };
+  return async (signOut, storage, setSessionState) => {
+    let rpIFrame = document.createElement("iframe");
+    rpIFrame.setAttribute("id", RP_IFRAME);
+    rpIFrame.style.display = "none";
+    let rpIframeLoaded = false;
+    rpIFrame.onload = () => {
+      rpIFrame = document.getElementById(RP_IFRAME);
+      const rpDoc = rpIFrame?.contentDocument;
+      const opIFrame = rpDoc?.createElement("iframe");
+      if (opIFrame) {
+        opIFrame.setAttribute("id", OP_IFRAME);
+        opIFrame.style.display = "none";
       }
+      const promptNoneIFrame = rpDoc?.createElement("iframe");
+      if (promptNoneIFrame) {
+        promptNoneIFrame.setAttribute("id", PROMPT_NONE_IFRAME);
+        promptNoneIFrame.style.display = "none";
+      }
+      opIFrame && rpIFrame?.contentDocument?.body?.appendChild(opIFrame);
+      promptNoneIFrame && rpIFrame?.contentDocument?.body?.appendChild(promptNoneIFrame);
+      rpIframeLoaded = true;
+    };
+    document?.body?.appendChild(rpIFrame);
+    _signOut = signOut;
+    _storage = storage;
+    _setSessionState = setSessionState;
+    const sleep = () => {
+      return new Promise((resolve) => setTimeout(resolve, 1));
+    };
+    while (rpIframeLoaded === false) {
+      await sleep();
     }
-    if (matches) {
-      return httpClient.request(requestConfig).then((response) => {
-        return Promise.resolve(response);
-      }).catch(async (error) => {
-        if (error?.response?.status === 401 || !error?.response) {
-          if (this._isTokenRefreshing) {
-            return this.retryFailedRequests({
-              enableRetrievingSignOutURLFromSession,
-              httpClient,
-              httpErrorCallback,
-              httpFinishCallback,
-              isHttpHandlerEnabled,
-              requestConfig
-            });
-          }
-          this._isTokenRefreshing = true;
-          let refreshAccessTokenResponse;
-          try {
-            refreshAccessTokenResponse = await this.refreshAccessToken(enableRetrievingSignOutURLFromSession);
-            this._isTokenRefreshing = false;
-          } catch (refreshError) {
-            this._isTokenRefreshing = false;
-            if (isHttpHandlerEnabled) {
-              if (typeof httpErrorCallback === "function") {
-                await httpErrorCallback({
-                  ...error,
-                  code: ACCESS_TOKEN_INVALID
-                });
-              }
-              if (typeof httpFinishCallback === "function") {
-                httpFinishCallback();
-              }
-            }
-            throw new AsgardeoAuthException(
-              "SPA-AUTH_HELPER-HR-SE01",
-              refreshError?.name ?? "Refresh token request failed.",
-              refreshError?.message ?? "An error occurred while trying to refresh the access token following a 401 response from the server."
-            );
-          }
-          if (refreshAccessTokenResponse) {
-            try {
-              const httpResponse = await httpClient.request(requestConfig);
-              return Promise.resolve(httpResponse);
-            } catch (error2) {
-              if (isHttpHandlerEnabled) {
-                if (typeof httpErrorCallback === "function") {
-                  await httpErrorCallback(error2);
-                }
-                if (typeof httpFinishCallback === "function") {
-                  httpFinishCallback();
-                }
-              }
-              return Promise.reject(error2);
-            }
-          }
-        }
-        if (isHttpHandlerEnabled) {
-          if (typeof httpErrorCallback === "function") {
-            await httpErrorCallback(error);
-          }
-          if (typeof httpFinishCallback === "function") {
-            httpFinishCallback();
-          }
-        }
-        return Promise.reject(error);
-      });
-    } else {
-      return Promise.reject(
-        new AsgardeoAuthException(
-          "SPA-AUTH_HELPER-HR-IV02",
-          "Request to the provided endpoint is prohibited.",
-          "Requests can only be sent to resource servers specified by the `resourceServerURLs` attribute while initializing the SDK. The specified endpoint in this request cannot be found among the `resourceServerURLs`"
-        )
-      );
-    }
+    return {
+      initialize,
+      receivePromptNoneResponse,
+      reset
+    };
+  };
+})();
+
+// src/__legacy__/helpers/spa-helper.ts
+import { TokenConstants } from "@asgardeo/javascript";
+var SPAHelper = class {
+  constructor(authClient) {
+    __publicField(this, "_authenticationClient");
+    __publicField(this, "_storageManager");
+    this._authenticationClient = authClient;
+    this._storageManager = this._authenticationClient.getStorageManager();
   }
-  async httpRequestAll(requestConfigs, httpClient, isHttpHandlerEnabled, httpErrorCallback, httpFinishCallback) {
-    let matches = true;
-    const config = await this._dataLayer.getConfigData();
-    for (const requestConfig of requestConfigs) {
-      let urlMatches = false;
-      for (const baseUrl of [...(await config)?.resourceServerURLs ?? [], config.baseUrl]) {
-        if (baseUrl && requestConfig.url?.startsWith(baseUrl)) {
-          urlMatches = true;
-          break;
-        }
-      }
-      if (!urlMatches) {
-        matches = false;
-        break;
-      }
+  async refreshAccessTokenAutomatically(authenticationHelper) {
+    const shouldRefreshAutomatically = (await this._storageManager.getConfigData())?.periodicTokenRefresh ?? false;
+    if (!shouldRefreshAutomatically) {
+      return;
     }
-    const requests = [];
-    if (matches) {
-      requestConfigs.forEach((request) => {
-        requests.push(httpClient.request(request));
-      });
-      return httpClient?.all && httpClient.all(requests).then((responses) => {
-        return Promise.resolve(responses);
-      }).catch(async (error) => {
-        if (error?.response?.status === 401 || !error?.response) {
-          let refreshTokenResponse;
-          try {
-            refreshTokenResponse = await this._authenticationClient.refreshAccessToken();
-          } catch (refreshError) {
-            if (isHttpHandlerEnabled) {
-              if (typeof httpErrorCallback === "function") {
-                await httpErrorCallback({
-                  ...error,
-                  code: ACCESS_TOKEN_INVALID
-                });
-              }
-              if (typeof httpFinishCallback === "function") {
-                httpFinishCallback();
-              }
-            }
-            throw new AsgardeoAuthException(
-              "SPA-AUTH_HELPER-HRA-SE01",
-              refreshError?.name ?? "Refresh token request failed.",
-              refreshError?.message ?? "An error occurred while trying to refresh the access token following a 401 response from the server."
-            );
-          }
-          if (refreshTokenResponse) {
-            return httpClient.all && httpClient.all(requests).then((response) => {
-              return Promise.resolve(response);
-            }).catch(async (error2) => {
-              if (isHttpHandlerEnabled) {
-                if (typeof httpErrorCallback === "function") {
-                  await httpErrorCallback(error2);
-                }
-                if (typeof httpFinishCallback === "function") {
-                  httpFinishCallback();
-                }
-              }
-              return Promise.reject(error2);
-            });
-          }
-        }
-        if (isHttpHandlerEnabled) {
-          if (typeof httpErrorCallback === "function") {
-            await httpErrorCallback(error);
-          }
-          if (typeof httpFinishCallback === "function") {
-            httpFinishCallback();
-          }
-        }
-        return Promise.reject(error);
-      });
-    } else {
-      throw new AsgardeoAuthException(
-        "SPA-AUTH_HELPER-HRA-IV02",
-        "Request to the provided endpoint is prohibited.",
-        "Requests can only be sent to resource servers specified by the `resourceServerURLs` attribute while initializing the SDK. The specified endpoint in this request cannot be found among the `resourceServerURLs`"
+    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._storageManager.setTemporaryDataParameter(
+        TokenConstants.Storage.StorageKeys.REFRESH_TOKEN_TIMER,
+        JSON.stringify(timer)
       );
     }
   }
-  async requestAccessToken(authorizationCode, sessionState, checkSession, pkce, state, tokenRequestConfig) {
-    const config = await this._dataLayer.getConfigData();
-    if (config.storage === "browserMemory" /* BrowserMemory */ && config.enablePKCE && sessionState) {
-      const pkce2 = SPAUtils.getPKCE(extractPkceStorageKeyFromState(sessionState));
-      await this._authenticationClient.setPKCECode(extractPkceStorageKeyFromState(sessionState), pkce2);
-    } else if (config.storage === "webWorker" /* WebWorker */ && pkce) {
-      await this._authenticationClient.setPKCECode(pkce, state ?? "");
-    }
-    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);
-          if (this._spaHelper) {
-            this._spaHelper.clearRefreshTokenTimeout();
-            this._spaHelper.refreshAccessTokenAutomatically(this);
-          }
-          if (checkSession && typeof checkSession === "function" && config.enableOIDCSessionManagement) {
-            checkSession();
-          }
-        } else {
-          if (this._spaHelper) {
-            this._spaHelper.refreshAccessTokenAutomatically(this);
-          }
-        }
-        return this._authenticationClient.getBasicUserInfo();
-      }).catch((error) => {
-        return Promise.reject(error);
-      });
+  async getRefreshTimeoutTimer() {
+    if (await this._storageManager.getTemporaryDataParameter(TokenConstants.Storage.StorageKeys.REFRESH_TOKEN_TIMER)) {
+      return JSON.parse(
+        await this._storageManager.getTemporaryDataParameter(
+          TokenConstants.Storage.StorageKeys.REFRESH_TOKEN_TIMER
+        )
+      );
     }
-    return Promise.reject(
-      new AsgardeoAuthException(
-        "SPA-AUTH_HELPER-RAT1-NF01",
-        "No authorization code.",
-        "No authorization code was found."
-      )
-    );
+    return -1;
   }
-  async trySignInSilently(constructSilentSignInUrl, requestAccessToken, sessionManagementHelper, additionalParams, tokenRequestConfig) {
-    if (SPAUtils.isInitializedSilentSignIn()) {
-      await sessionManagementHelper.receivePromptNoneResponse();
-      return Promise.resolve({
-        allowedScopes: "",
-        displayName: "",
-        email: "",
-        sessionState: "",
-        sub: "",
-        tenantDomain: "",
-        username: ""
-      });
+  async clearRefreshTokenTimeout(timer) {
+    if (timer) {
+      clearTimeout(timer);
+      return;
     }
-    const rpIFrame = document.getElementById(RP_IFRAME);
-    const promptNoneIFrame = rpIFrame?.contentDocument?.getElementById(
-      PROMPT_NONE_IFRAME
-    );
-    try {
-      const url = await constructSilentSignInUrl(additionalParams);
-      promptNoneIFrame.src = url;
-    } catch (error) {
-      return Promise.reject(error);
+    const refreshTimer = await this.getRefreshTimeoutTimer();
+    if (refreshTimer !== -1) {
+      clearTimeout(refreshTimer);
     }
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        resolve(false);
-      }, 1e4);
-      const listenToPromptNoneIFrame = async (e) => {
-        const data = e.data;
-        if (data?.type == CHECK_SESSION_SIGNED_OUT) {
-          window.removeEventListener("message", listenToPromptNoneIFrame);
-          clearTimeout(timer);
-          resolve(false);
-        }
-        if (data?.type == CHECK_SESSION_SIGNED_IN && data?.data?.code) {
-          requestAccessToken(data?.data?.code, data?.data?.sessionState, data?.data?.state, tokenRequestConfig).then((response) => {
-            window.removeEventListener("message", listenToPromptNoneIFrame);
-            resolve(response);
-          }).catch((error) => {
-            window.removeEventListener("message", listenToPromptNoneIFrame);
-            reject(error);
-          }).finally(() => {
-            clearTimeout(timer);
-          });
-        }
-      };
-      window.addEventListener("message", listenToPromptNoneIFrame);
+  }
+};
+
+// src/__legacy__/http-client/clients/axios-http-client.ts
+import axios from "axios";
+
+// src/__legacy__/http-client/helpers/decorators.ts
+function staticDecorator() {
+  return (_constructor) => {
+  };
+}
+
+// src/__legacy__/http-client/clients/axios-http-client.ts
+var HttpClient = class {
+  /**
+   * Private constructor to avoid object instantiation from outside
+   * the class.
+   *
+   * @hideconstructor
+   */
+  constructor() {
+    __publicField(this, "attachToken", () => Promise.resolve());
+    __publicField(this, "requestStartCallback", () => null);
+    __publicField(this, "requestSuccessCallback", () => null);
+    __publicField(this, "requestErrorCallback", () => null);
+    __publicField(this, "requestFinishCallback", () => null);
+    this.init = this.init.bind(this);
+    this.setHttpRequestErrorCallback = this.setHttpRequestErrorCallback.bind(this);
+    this.setHttpRequestFinishCallback = this.setHttpRequestFinishCallback.bind(this);
+    this.setHttpRequestStartCallback = this.setHttpRequestStartCallback.bind(this);
+    this.setHttpRequestSuccessCallback = this.setHttpRequestSuccessCallback.bind(this);
+  }
+  /**
+   * Returns an aggregated instance of type `HttpInstance` of `HttpClient`.
+   *
+   * @return {any}
+   */
+  static getInstance() {
+    if (this.axiosInstance) {
+      return this.axiosInstance;
+    }
+    this.axiosInstance = axios.create({
+      withCredentials: true
     });
+    if (!this.clientInstance) {
+      this.clientInstance = new HttpClient();
+    }
+    this.axiosInstance.interceptors.request.use(async (request) => await this.clientInstance.requestHandler(request));
+    this.axiosInstance.interceptors.response.use(
+      (response) => this.clientInstance.successHandler(response),
+      (error) => this.clientInstance.errorHandler(error)
+    );
+    this.axiosInstance.all = axios.all;
+    this.axiosInstance.spread = axios.spread;
+    this.axiosInstance.init = this.clientInstance.init;
+    this.axiosInstance.enableHandler = this.clientInstance.enableHandler;
+    this.axiosInstance.disableHandler = this.clientInstance.disableHandler;
+    this.axiosInstance.disableHandlerWithTimeout = this.clientInstance.disableHandlerWithTimeout;
+    this.axiosInstance.setHttpRequestStartCallback = this.clientInstance.setHttpRequestStartCallback;
+    this.axiosInstance.setHttpRequestSuccessCallback = this.clientInstance.setHttpRequestSuccessCallback;
+    this.axiosInstance.setHttpRequestErrorCallback = this.clientInstance.setHttpRequestErrorCallback;
+    this.axiosInstance.setHttpRequestFinishCallback = this.clientInstance.setHttpRequestFinishCallback;
+    return this.axiosInstance;
   }
-  async handleSignIn(shouldStopAuthn, checkSession, tryRetrievingUserInfo) {
-    const config = await this._dataLayer.getConfigData();
-    if (await shouldStopAuthn()) {
-      return Promise.resolve({
-        allowedScopes: "",
-        displayName: "",
-        email: "",
-        sessionState: "",
-        sub: "",
-        tenantDomain: "",
-        username: ""
+  /**
+   * Intercepts all the requests.
+   * If the `isHandlerEnabled` flag is set to true, fires the `requestStartCallback`
+   * and retrieves the access token from the server and attaches it to the request.
+   * Else, just returns the original request.
+   *
+   * @param {HttpRequestConfig} request - Original request.
+   * @return {HttpRequestConfig}
+   */
+  async requestHandler(request) {
+    await this.attachToken(request);
+    if (request?.shouldEncodeToFormData) {
+      const data = request?.data;
+      const formData = new FormData();
+      Object.keys(data).forEach((key) => {
+        formData.append(key, data[key]);
       });
+      request.data = formData;
     }
-    if (config.storage !== "webWorker" /* WebWorker */) {
-      if (await this._authenticationClient.isAuthenticated()) {
-        this._spaHelper.clearRefreshTokenTimeout();
-        this._spaHelper.refreshAccessTokenAutomatically(this);
-        if (config.enableOIDCSessionManagement) {
-          checkSession();
-        }
-        return Promise.resolve(await this._authenticationClient.getBasicUserInfo());
+    request.startTimeInMs = (/* @__PURE__ */ new Date()).getTime();
+    if (HttpClient.isHandlerEnabled) {
+      if (this.requestStartCallback && typeof this.requestStartCallback === "function") {
+        this.requestStartCallback(request);
       }
     }
-    const error = new URL(window.location.href).searchParams.get(ERROR);
-    const errorDescription = new URL(window.location.href).searchParams.get(ERROR_DESCRIPTION);
-    if (error) {
-      const url = new URL(window.location.href);
-      url.searchParams.delete(ERROR);
-      url.searchParams.delete(ERROR_DESCRIPTION);
-      history.pushState(null, document.title, url.toString());
-      throw new AsgardeoAuthException("SPA-AUTH_HELPER-SI-SE01", error, errorDescription ?? "");
-    }
-    if (config.storage === "webWorker" /* WebWorker */ && tryRetrievingUserInfo) {
-      const basicUserInfo = await tryRetrievingUserInfo();
-      if (basicUserInfo) {
-        return basicUserInfo;
+    return request;
+  }
+  /**
+   * Handles response errors.
+   * If the `isHandlerEnabled` flag is set to true, fires the `requestErrorCallback`
+   * and the `requestFinishCallback` functions. Else, just returns the original error.
+   *
+   * @param {HttpError} error - Original error.
+   * @return {HttpError}
+   */
+  errorHandler(error) {
+    if (HttpClient.isHandlerEnabled) {
+      if (this.requestErrorCallback && typeof this.requestErrorCallback === "function") {
+        this.requestErrorCallback(error);
+      }
+      if (this.requestFinishCallback && typeof this.requestFinishCallback === "function") {
+        this.requestFinishCallback();
       }
     }
-    return Promise.resolve(void 0);
+    throw error;
   }
-  async attachTokenToRequestConfig(request) {
-    const requestConfig = { attachToken: true, ...request };
-    if (requestConfig.attachToken) {
-      if (requestConfig.shouldAttachIDPAccessToken) {
-        request.headers = {
-          ...request.headers,
-          Authorization: `Bearer ${await this.getIDPAccessToken()}`
-        };
-      } else {
-        request.headers = {
-          ...request.headers,
-          Authorization: `Bearer ${await this.getAccessToken()}`
-        };
+  /**
+   * Handles response success.
+   * If the `isHandlerEnabled` flag is set to true, fires the `requestSuccessCallback`
+   * and the `requestFinishCallback` functions. Else, just returns the original response.
+   *
+   * @param {HttpResponse} response - Original response.
+   * @return {HttpResponse}
+   */
+  successHandler(response) {
+    if (HttpClient.isHandlerEnabled) {
+      if (this.requestSuccessCallback && typeof this.requestSuccessCallback === "function") {
+        this.requestSuccessCallback(response);
+      }
+      if (this.requestFinishCallback && typeof this.requestFinishCallback === "function") {
+        this.requestFinishCallback();
       }
     }
+    return response;
+  }
+  /**
+   * Initializes the Http client.
+   *
+   * @param isHandlerEnabled - Flag to toggle handler enablement.
+   * @param requestStartCallback - Callback function to be triggered on request start.
+   * @param requestSuccessCallback - Callback function to be triggered on request success.
+   * @param requestErrorCallback - Callback function to be triggered on request error.
+   * @param requestFinishCallback - Callback function to be triggered on request error.
+   */
+  async init(isHandlerEnabled = true, attachToken) {
+    HttpClient.isHandlerEnabled = isHandlerEnabled;
+    this.attachToken = attachToken;
   }
-  async getBasicUserInfo() {
-    return this._authenticationClient.getBasicUserInfo();
+  /**
+   * Enables the handler.
+   */
+  enableHandler() {
+    HttpClient.isHandlerEnabled = true;
   }
-  async getDecodedIDToken() {
-    return this._authenticationClient.getDecodedIDToken();
+  /**
+   * Disables the handler.
+   */
+  disableHandler() {
+    HttpClient.isHandlerEnabled = false;
   }
-  async getDecodedIDPIDToken() {
-    return this._authenticationClient.getDecodedIDToken();
+  /**
+   * Disables the handler for a given period of time.
+   *
+   * @param {number} timeout - Timeout in milliseconds.
+   */
+  disableHandlerWithTimeout(timeout = HttpClient.DEFAULT_HANDLER_DISABLE_TIMEOUT) {
+    HttpClient.isHandlerEnabled = false;
+    setTimeout(() => {
+      HttpClient.isHandlerEnabled = true;
+    }, timeout);
   }
-  async getCryptoHelper() {
-    return this._authenticationClient.getCryptoHelper();
+  setHttpRequestStartCallback(callback) {
+    this.requestStartCallback = callback;
   }
-  async getIDToken() {
-    return this._authenticationClient.getIDToken();
+  setHttpRequestSuccessCallback(callback) {
+    this.requestSuccessCallback = callback;
   }
-  async getOIDCServiceEndpoints() {
-    return this._authenticationClient.getOIDCServiceEndpoints();
+  setHttpRequestErrorCallback(callback) {
+    this.requestErrorCallback = callback;
   }
-  async getAccessToken() {
-    return this._authenticationClient.getAccessToken();
+  setHttpRequestFinishCallback(callback) {
+    this.requestFinishCallback = callback;
   }
-  async getIDPAccessToken() {
-    return (await this._dataLayer.getSessionData())?.access_token;
+};
+__publicField(HttpClient, "axiosInstance");
+__publicField(HttpClient, "clientInstance");
+__publicField(HttpClient, "isHandlerEnabled");
+__publicField(HttpClient, "DEFAULT_HANDLER_DISABLE_TIMEOUT", 1e3);
+HttpClient = __decorateClass([
+  staticDecorator()
+], HttpClient);
+
+// src/__legacy__/stores/local-store.ts
+var LocalStore = class {
+  async setData(key, value) {
+    localStorage.setItem(key, value);
   }
-  getDataLayer() {
-    return this._dataLayer;
+  async getData(key) {
+    return localStorage.getItem(key) ?? "{}";
   }
-  async isAuthenticated() {
-    return this._authenticationClient.isAuthenticated();
+  async removeData(key) {
+    localStorage.removeItem(key);
   }
 };
 
-// src/__legacy__/helpers/spa-helper.ts
-import { TokenConstants } from "@asgardeo/javascript";
-var SPAHelper = class {
-  constructor(authClient) {
-    __publicField(this, "_authenticationClient");
-    __publicField(this, "_dataLayer");
-    this._authenticationClient = authClient;
-    this._dataLayer = this._authenticationClient.getDataLayer();
+// src/__legacy__/stores/memory-store.ts
+var MemoryStore = class {
+  constructor() {
+    __publicField(this, "_data");
+    this._data = /* @__PURE__ */ new Map();
   }
-  async refreshAccessTokenAutomatically(authenticationHelper) {
-    const shouldRefreshAutomatically = (await this._dataLayer.getConfigData())?.periodicTokenRefresh ?? false;
-    if (!shouldRefreshAutomatically) {
-      return;
-    }
-    const sessionData = await this._dataLayer.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(
-        TokenConstants.Storage.StorageKeys.REFRESH_TOKEN_TIMER,
-        JSON.stringify(timer)
-      );
-    }
+  async setData(key, value) {
+    this._data.set(key, value);
   }
-  async getRefreshTimeoutTimer() {
-    if (await this._dataLayer.getTemporaryDataParameter(TokenConstants.Storage.StorageKeys.REFRESH_TOKEN_TIMER)) {
-      return JSON.parse(
-        await this._dataLayer.getTemporaryDataParameter(
-          TokenConstants.Storage.StorageKeys.REFRESH_TOKEN_TIMER
-        )
-      );
-    }
-    return -1;
+  async getData(key) {
+    return this._data?.get(key) ?? "{}";
   }
-  async clearRefreshTokenTimeout(timer) {
-    if (timer) {
-      clearTimeout(timer);
-      return;
-    }
-    const refreshTimer = await this.getRefreshTimeoutTimer();
-    if (refreshTimer !== -1) {
-      clearTimeout(refreshTimer);
-    }
+  async removeData(key) {
+    this._data.delete(key);
   }
 };
 
-// src/__legacy__/helpers/session-management-helper.ts
-import { AsgardeoAuthClient as AsgardeoAuthClient4, OIDCRequestConstants as OIDCRequestConstants2 } from "@asgardeo/javascript";
-var SessionManagementHelper = /* @__PURE__ */ (() => {
-  let _clientID;
-  let _checkSessionEndpoint;
-  let _sessionState;
-  let _interval;
-  let _redirectURL;
-  let _sessionRefreshInterval;
-  let _signOut;
-  let _sessionRefreshIntervalTimeout;
-  let _checkSessionIntervalTimeout;
-  let _storage;
-  let _setSessionState;
-  let _getAuthorizationURL;
-  const initialize = (clientID, checkSessionEndpoint, getSessionState, interval, sessionRefreshInterval, redirectURL, getAuthorizationURL) => {
-    _clientID = clientID;
-    _checkSessionEndpoint = checkSessionEndpoint;
-    _sessionState = getSessionState;
-    _interval = interval;
-    _redirectURL = redirectURL;
-    _sessionRefreshInterval = sessionRefreshInterval;
-    _getAuthorizationURL = getAuthorizationURL;
-    if (_interval > -1) {
-      initiateCheckSession();
-    }
-    if (_sessionRefreshInterval > -1) {
-      sessionRefreshInterval = setInterval(() => {
-        sendPromptNoneRequest();
-      }, _sessionRefreshInterval * 1e3);
+// src/__legacy__/stores/session-store.ts
+var SessionStore = class {
+  async setData(key, value) {
+    sessionStorage.setItem(key, value);
+  }
+  async getData(key) {
+    return sessionStorage.getItem(key) ?? "{}";
+  }
+  async removeData(key) {
+    sessionStorage.removeItem(key);
+  }
+};
+
+// src/__legacy__/utils/crypto-utils.ts
+var import_buffer = __toESM(require_buffer(), 1);
+var import_randombytes = __toESM(require_browser(), 1);
+import { AsgardeoAuthException } from "@asgardeo/javascript";
+import base64url from "base64url";
+import sha256 from "fast-sha256";
+import { createLocalJWKSet, jwtVerify } from "jose";
+var SPACryptoUtils = class {
+  /**
+   * Get URL encoded string.
+   *
+   * @returns {string} base 64 url encoded value.
+   */
+  base64URLEncode(value) {
+    return base64url.encode(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+  base64URLDecode(value) {
+    return base64url.decode(value).toString();
+  }
+  hashSha256(data) {
+    return import_buffer.Buffer.from(sha256(new TextEncoder().encode(data)));
+  }
+  generateRandomBytes(length) {
+    return (0, import_randombytes.default)(length);
+  }
+  verifyJwt(idToken, jwk, algorithms, clientId, issuer, subject, clockTolerance, validateJwtIssuer) {
+    const jwtVerifyOptions = {
+      algorithms,
+      audience: clientId,
+      clockTolerance,
+      subject
+    };
+    if (validateJwtIssuer ?? true) {
+      jwtVerifyOptions["issuer"] = issuer;
     }
+    return jwtVerify(
+      idToken,
+      createLocalJWKSet({
+        keys: [jwk]
+      }),
+      jwtVerifyOptions
+    ).then(() => {
+      return Promise.resolve(true);
+    }).catch((error) => {
+      return Promise.reject(
+        new AsgardeoAuthException(
+          "SPA-CRYPTO-UTILS-VJ-IV01",
+          error?.reason ?? JSON.stringify(error),
+          `${error?.code} ${error?.claim}`
+        )
+      );
+    });
+  }
+};
+
+// 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 AsgardeoAuthClient4();
+  await _authenticationClient.initialize(config, _store, _cryptoUtils, instanceID);
+  const _spaHelper = new SPAHelper(_authenticationClient);
+  const _dataLayer = _authenticationClient.getStorageManager();
+  const _sessionManagementHelper = await SessionManagementHelper(
+    async () => _authenticationClient.getSignOutUrl(),
+    config.storage ?? "sessionStorage" /* SessionStorage */,
+    (sessionState) => _dataLayer.setSessionDataParameter(
+      OIDCRequestConstants3.Params.SESSION_STATE,
+      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 initiateCheckSession = async () => {
-    if (!_checkSessionEndpoint || !_clientID || !_redirectURL) {
-      return;
-    }
-    const OP_IFRAME2 = "opIFrame";
-    async function checkSession() {
-      const sessionState = await _sessionState();
-      if (Boolean(_clientID) && Boolean(sessionState)) {
-        const message = `${_clientID} ${sessionState}`;
-        const rpIFrame2 = document.getElementById(RP_IFRAME);
-        const opIframe2 = rpIFrame2?.contentDocument?.getElementById(OP_IFRAME2);
-        const win = opIframe2.contentWindow;
-        win?.postMessage(message, _checkSessionEndpoint);
-      }
-    }
-    const rpIFrame = document.getElementById(RP_IFRAME);
-    const opIframe = rpIFrame?.contentDocument?.getElementById(OP_IFRAME2);
-    opIframe.src = _checkSessionEndpoint + "?client_id=" + _clientID + "&redirect_uri=" + _redirectURL;
-    _checkSessionIntervalTimeout = setInterval(checkSession, _interval * 1e3);
-    listenToResponseFromOPIFrame();
+  _httpClient?.init && await _httpClient.init(true, attachToken);
+  const setHttpRequestStartCallback = (callback) => {
+    _httpClient?.setHttpRequestStartCallback && _httpClient.setHttpRequestStartCallback(callback);
   };
-  const reset = () => {
-    clearInterval(_checkSessionIntervalTimeout);
-    clearInterval(_sessionRefreshIntervalTimeout);
+  const setHttpRequestSuccessCallback = (callback) => {
+    _httpClient?.setHttpRequestSuccessCallback && _httpClient.setHttpRequestSuccessCallback(callback);
   };
-  const listenToResponseFromOPIFrame = () => {
-    async function receiveMessage(e) {
-      const targetOrigin = _checkSessionEndpoint;
-      if (!targetOrigin || targetOrigin?.indexOf(e.origin) < 0 || e?.data?.type === SET_SESSION_STATE_FROM_IFRAME) {
-        return;
+  const setHttpRequestFinishCallback = (callback) => {
+    _httpClient?.setHttpRequestFinishCallback && _httpClient.setHttpRequestFinishCallback(callback);
+  };
+  const setHttpRequestErrorCallback = (callback) => {
+    _httpErrorCallback = callback;
+  };
+  const httpRequest = async (requestConfig) => _authenticationHelper.httpRequest(
+    _httpClient,
+    requestConfig,
+    _isHttpHandlerEnabled,
+    _httpErrorCallback,
+    _httpFinishCallback
+  );
+  const httpRequestAll = async (requestConfigs) => _authenticationHelper.httpRequestAll(
+    requestConfigs,
+    _httpClient,
+    _isHttpHandlerEnabled,
+    _httpErrorCallback,
+    _httpFinishCallback
+  );
+  const getHttpClient = () => _httpClient;
+  const enableHttpHandler = () => {
+    _authenticationHelper.enableHttpHandler(_httpClient);
+    _isHttpHandlerEnabled = true;
+    return true;
+  };
+  const disableHttpHandler = () => {
+    _authenticationHelper.disableHttpHandler(_httpClient);
+    _isHttpHandlerEnabled = false;
+    return true;
+  };
+  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 shouldStopAuthn = async () => _sessionManagementHelper.receivePromptNoneResponse(async (sessionState) => {
+    await _dataLayer.setSessionDataParameter(
+      OIDCRequestConstants3.Params.SESSION_STATE,
+      sessionState ?? ""
+    );
+  });
+  const setSessionStatus = async (sessionStatus) => {
+    await _dataLayer.setSessionStatus(sessionStatus);
+  };
+  const signIn = async (signInConfig, authorizationCode, sessionState, state, tokenRequestConfig) => {
+    const basicUserInfo = await _authenticationHelper.handleSignIn(shouldStopAuthn, checkSession, void 0);
+    if (basicUserInfo) {
+      return basicUserInfo;
+    }
+    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 = extractPkceStorageKeyFromState(resolvedState);
+        SPAUtils.setPKCE(pkceKey, await _authenticationClient.getPKCECode(resolvedState));
       }
-      if (e.data === "unchanged") {
-      } else if (e.data === "error") {
-        window.location.href = await _signOut();
-      } else if (e.data === "changed") {
-        sendPromptNoneRequest();
+      if (tokenRequestConfig) {
+        _dataLayer.setTemporaryDataParameter(TOKEN_REQUEST_CONFIG_KEY, JSON.stringify(tokenRequestConfig));
+      }
+      if (signInConfig && signInConfig["response_mode"] === "direct") {
+        const authorizeUrl = new URL(url);
+        return initializeEmbeddedSignInFlow({
+          url: `${authorizeUrl.origin}${authorizeUrl.pathname}`,
+          payload: Object.fromEntries(authorizeUrl.searchParams.entries())
+        });
       }
+      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);
     }
-    window?.addEventListener("message", receiveMessage, false);
+    _spaHelper.clearRefreshTokenTimeout();
+    await _dataLayer.removeOIDCProviderMetaData();
+    await _dataLayer.removeTemporaryData();
+    await _dataLayer.removeSessionData();
+    await _dataLayer.removeSessionStatus();
+    await SPAUtils.waitTillPageRedirect();
+    return true;
   };
-  const sendPromptNoneRequest = async () => {
-    const rpIFrame = document.getElementById(RP_IFRAME);
-    const promptNoneIFrame = rpIFrame?.contentDocument?.getElementById(
-      PROMPT_NONE_IFRAME
-    );
-    if (SPAUtils.canSendPromptNoneRequest()) {
-      SPAUtils.setPromptNoneRequestSent(true);
-      const receiveMessageListener = (e) => {
-        if (e?.data?.type === SET_SESSION_STATE_FROM_IFRAME) {
-          _setSessionState(e?.data?.data ?? "");
-          window?.removeEventListener("message", receiveMessageListener);
-        }
-      };
-      if (_storage === "browserMemory" /* BrowserMemory */ || _storage === "webWorker" /* WebWorker */) {
-        window?.addEventListener("message", receiveMessageListener);
-      }
-      const promptNoneURL = await _getAuthorizationURL({
-        prompt: "none",
-        response_mode: "query",
-        state: STATE
-      });
-      promptNoneIFrame.src = promptNoneURL;
+  const enableRetrievingSignOutURLFromSession = (config2) => {
+    if (config2.preventSignOutURLUpdate) {
+      _getSignOutURLFromSessionStorage = true;
     }
   };
-  const receivePromptNoneResponse = async (setSessionState) => {
-    const state = new URL(window.location.href).searchParams.get(STATE_QUERY);
-    const sessionState = new URL(window.location.href).searchParams.get(OIDCRequestConstants2.Params.SESSION_STATE);
-    const parent = window.parent.parent;
-    if (state !== null && (state.includes(STATE) || state.includes(SILENT_SIGN_IN_STATE))) {
-      const code = new URL(window.location.href).searchParams.get("code");
-      if (code !== null && code.length !== 0) {
-        if (state.includes(SILENT_SIGN_IN_STATE)) {
-          const message = {
-            data: {
-              code,
-              sessionState: sessionState ?? "",
-              state
-            },
-            type: CHECK_SESSION_SIGNED_IN
-          };
-          sessionStorage.setItem(INITIALIZED_SILENT_SIGN_IN, "false");
-          parent.postMessage(message, parent.origin);
-          SPAUtils.setPromptNoneRequestSent(false);
-          window.location.href = "about:blank";
-          await SPAUtils.waitTillPageRedirect();
-          return true;
-        }
-        const newSessionState = new URL(window.location.href).searchParams.get("session_state");
-        if (_storage === "localStorage" /* LocalStorage */ || _storage === "sessionStorage" /* SessionStorage */) {
-          setSessionState && await setSessionState(newSessionState);
-        } else {
-          const message = {
-            data: newSessionState ?? "",
-            type: SET_SESSION_STATE_FROM_IFRAME
-          };
-          window?.parent?.parent?.postMessage(message);
-        }
-        SPAUtils.setPromptNoneRequestSent(false);
-        window.location.href = "about:blank";
-        await SPAUtils.waitTillPageRedirect();
-        return true;
-      } else {
-        if (state.includes(SILENT_SIGN_IN_STATE)) {
-          const message = {
-            type: CHECK_SESSION_SIGNED_OUT
-          };
-          window.parent.parent.postMessage(message, parent.origin);
-          SPAUtils.setPromptNoneRequestSent(false);
-          window.location.href = "about:blank";
-          await SPAUtils.waitTillPageRedirect();
-          return true;
-        }
-        SPAUtils.setPromptNoneRequestSent(false);
-        const signOutURL = await _signOut();
-        await AsgardeoAuthClient4.clearUserSessionData();
-        parent.location.href = signOutURL;
-        window.location.href = "about:blank";
-        await SPAUtils.waitTillPageRedirect();
-        return true;
-      }
+  const exchangeToken = async (config2) => _authenticationHelper.exchangeToken(config2, enableRetrievingSignOutURLFromSession);
+  const refreshAccessToken = async () => {
+    try {
+      return await _authenticationHelper.refreshAccessToken(enableRetrievingSignOutURLFromSession);
+    } catch (error) {
+      return Promise.reject(error);
     }
-    return false;
   };
-  return async (signOut, storage, setSessionState) => {
-    let rpIFrame = document.createElement("iframe");
-    rpIFrame.setAttribute("id", RP_IFRAME);
-    rpIFrame.style.display = "none";
-    let rpIframeLoaded = false;
-    rpIFrame.onload = () => {
-      rpIFrame = document.getElementById(RP_IFRAME);
-      const rpDoc = rpIFrame?.contentDocument;
-      const opIFrame = rpDoc?.createElement("iframe");
-      if (opIFrame) {
-        opIFrame.setAttribute("id", OP_IFRAME);
-        opIFrame.style.display = "none";
-      }
-      const promptNoneIFrame = rpDoc?.createElement("iframe");
-      if (promptNoneIFrame) {
-        promptNoneIFrame.setAttribute("id", PROMPT_NONE_IFRAME);
-        promptNoneIFrame.style.display = "none";
-      }
-      opIFrame && rpIFrame?.contentDocument?.body?.appendChild(opIFrame);
-      promptNoneIFrame && rpIFrame?.contentDocument?.body?.appendChild(promptNoneIFrame);
-      rpIframeLoaded = true;
-    };
-    document?.body?.appendChild(rpIFrame);
-    _signOut = signOut;
-    _storage = storage;
-    _setSessionState = setSessionState;
-    const sleep = () => {
-      return new Promise((resolve) => setTimeout(resolve, 1));
-    };
-    while (rpIframeLoaded === false) {
-      await sleep();
+  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 requestAccessToken = async (resolvedAuthorizationCode, resolvedSessionState, resolvedState, tokenRequestConfig) => _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(
+        extractPkceStorageKeyFromState(state ?? ""),
+        await _authenticationClient.getPKCECode(state ?? "")
+      );
     }
-    return {
-      initialize,
-      receivePromptNoneResponse,
-      reset
-    };
+    return url;
   };
-})();
-
-// src/__legacy__/worker/worker-receiver.ts
-import { AsgardeoAuthException as AsgardeoAuthException3 } from "@asgardeo/javascript";
+  const trySignInSilently = async (additionalParams, tokenRequestConfig) => _authenticationHelper.trySignInSilently(
+    constructSilentSignInUrl,
+    requestAccessToken,
+    _sessionManagementHelper,
+    additionalParams,
+    tokenRequestConfig
+  );
+  const getUser = async () => _authenticationHelper.getUser();
+  const getDecodedIdToken = async () => _authenticationHelper.getDecodedIdToken();
+  const getCrypto = async () => _authenticationHelper.getCrypto();
+  const getIdToken = async () => _authenticationHelper.getIdToken();
+  const getOpenIDProviderEndpoints = async () => _authenticationHelper.getOpenIDProviderEndpoints();
+  const getAccessToken = async () => _authenticationHelper.getAccessToken();
+  const getStorageManager = async () => _authenticationHelper.getStorageManager();
+  const getConfigData = async () => _dataLayer.getConfigData();
+  const isSignedIn = async () => _authenticationHelper.isSignedIn();
+  const isSessionActive = async () => 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,
+    getUser,
+    getConfigData,
+    getCrypto,
+    getStorageManager,
+    getDecodedIdToken,
+    getHttpClient,
+    getIdToken,
+    getOpenIDProviderEndpoints,
+    httpRequest,
+    httpRequestAll,
+    isSignedIn,
+    isSessionActive,
+    refreshAccessToken,
+    exchangeToken,
+    revokeAccessToken,
+    setHttpRequestErrorCallback,
+    setHttpRequestFinishCallback,
+    setHttpRequestStartCallback,
+    setHttpRequestSuccessCallback,
+    signIn,
+    signOut,
+    trySignInSilently,
+    reInitialize
+  };
+};
 
-// src/__legacy__/worker/worker-core.ts
+// src/__legacy__/clients/web-worker-client.ts
 import {
-  AsgardeoAuthClient as AsgardeoAuthClient5,
-  OIDCRequestConstants as OIDCRequestConstants3
+  AsgardeoAuthClient as AsgardeoAuthClient6,
+  AsgardeoAuthException as AsgardeoAuthException3,
+  OIDCRequestConstants as OIDCRequestConstants4,
+  extractPkceStorageKeyFromState as extractPkceStorageKeyFromState3
 } from "@asgardeo/javascript";
 
-// src/__legacy__/http-client/clients/axios-http-client.ts
-import axios from "axios";
-
-// src/__legacy__/http-client/helpers/decorators.ts
-function staticDecorator() {
-  return (_constructor) => {
-  };
-}
-
-// src/__legacy__/http-client/clients/axios-http-client.ts
-var HttpClient = class {
-  /**
-   * Private constructor to avoid object instantiation from outside
-   * the class.
-   *
-   * @hideconstructor
-   */
-  constructor() {
-    __publicField(this, "attachToken", () => Promise.resolve());
-    __publicField(this, "requestStartCallback", () => null);
-    __publicField(this, "requestSuccessCallback", () => null);
-    __publicField(this, "requestErrorCallback", () => null);
-    __publicField(this, "requestFinishCallback", () => null);
-    this.init = this.init.bind(this);
-    this.setHttpRequestErrorCallback = this.setHttpRequestErrorCallback.bind(this);
-    this.setHttpRequestFinishCallback = this.setHttpRequestFinishCallback.bind(this);
-    this.setHttpRequestStartCallback = this.setHttpRequestStartCallback.bind(this);
-    this.setHttpRequestSuccessCallback = this.setHttpRequestSuccessCallback.bind(this);
+// src/__legacy__/helpers/authentication-helper.ts
+import {
+  AsgardeoAuthException as AsgardeoAuthException2,
+  extractPkceStorageKeyFromState as extractPkceStorageKeyFromState2
+} from "@asgardeo/javascript";
+var AuthenticationHelper = class {
+  constructor(authClient, spaHelper) {
+    __publicField(this, "_authenticationClient");
+    __publicField(this, "_storageManager");
+    __publicField(this, "_spaHelper");
+    __publicField(this, "_instanceID");
+    __publicField(this, "_isTokenRefreshing");
+    this._authenticationClient = authClient;
+    this._storageManager = this._authenticationClient.getStorageManager();
+    this._spaHelper = spaHelper;
+    this._instanceID = this._authenticationClient.getInstanceId();
+    this._isTokenRefreshing = false;
   }
-  /**
-   * Returns an aggregated instance of type `HttpInstance` of `HttpClient`.
-   *
-   * @return {any}
-   */
-  static getInstance() {
-    if (this.axiosInstance) {
-      return this.axiosInstance;
-    }
-    this.axiosInstance = axios.create({
-      withCredentials: true
-    });
-    if (!this.clientInstance) {
-      this.clientInstance = new HttpClient();
-    }
-    this.axiosInstance.interceptors.request.use(async (request) => await this.clientInstance.requestHandler(request));
-    this.axiosInstance.interceptors.response.use(
-      (response) => this.clientInstance.successHandler(response),
-      (error) => this.clientInstance.errorHandler(error)
-    );
-    this.axiosInstance.all = axios.all;
-    this.axiosInstance.spread = axios.spread;
-    this.axiosInstance.init = this.clientInstance.init;
-    this.axiosInstance.enableHandler = this.clientInstance.enableHandler;
-    this.axiosInstance.disableHandler = this.clientInstance.disableHandler;
-    this.axiosInstance.disableHandlerWithTimeout = this.clientInstance.disableHandlerWithTimeout;
-    this.axiosInstance.setHttpRequestStartCallback = this.clientInstance.setHttpRequestStartCallback;
-    this.axiosInstance.setHttpRequestSuccessCallback = this.clientInstance.setHttpRequestSuccessCallback;
-    this.axiosInstance.setHttpRequestErrorCallback = this.clientInstance.setHttpRequestErrorCallback;
-    this.axiosInstance.setHttpRequestFinishCallback = this.clientInstance.setHttpRequestFinishCallback;
-    return this.axiosInstance;
+  enableHttpHandler(httpClient) {
+    httpClient?.enableHandler && httpClient.enableHandler();
   }
-  /**
-   * Intercepts all the requests.
-   * If the `isHandlerEnabled` flag is set to true, fires the `requestStartCallback`
-   * and retrieves the access token from the server and attaches it to the request.
-   * Else, just returns the original request.
-   *
-   * @param {HttpRequestConfig} request - Original request.
-   * @return {HttpRequestConfig}
-   */
-  async requestHandler(request) {
-    await this.attachToken(request);
-    if (request?.shouldEncodeToFormData) {
-      const data = request?.data;
-      const formData = new FormData();
-      Object.keys(data).forEach((key) => {
-        formData.append(key, data[key]);
+  disableHttpHandler(httpClient) {
+    httpClient?.disableHandler && httpClient.disableHandler();
+  }
+  initializeSessionManger(config, oidcEndpoints, getSessionState, getAuthzURL, sessionManagementHelper) {
+    sessionManagementHelper.initialize(
+      config.clientId,
+      oidcEndpoints.checkSessionIframe ?? "",
+      getSessionState,
+      config.checkSessionInterval ?? 3,
+      config.sessionRefreshInterval ?? 300,
+      config.afterSignInUrl,
+      getAuthzURL
+    );
+  }
+  async exchangeToken(config, enableRetrievingSignOutURLFromSession) {
+    let useDefaultEndpoint = true;
+    let matches = false;
+    if (config?.tokenEndpoint) {
+      useDefaultEndpoint = false;
+      for (const baseUrl of [
+        ...(await this._storageManager.getConfigData())?.resourceServerURLs ?? [],
+        config.baseUrl
+      ]) {
+        if (baseUrl && config.tokenEndpoint?.startsWith(baseUrl)) {
+          matches = true;
+          break;
+        }
+      }
+    }
+    if (config.shouldReplayAfterRefresh) {
+      this._storageManager.setTemporaryDataParameter(CUSTOM_GRANT_CONFIG, JSON.stringify(config));
+    }
+    if (useDefaultEndpoint || matches) {
+      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.getUser();
+        } else {
+          return response;
+        }
+      }).catch((error) => {
+        return Promise.reject(error);
       });
-      request.data = formData;
+    } else {
+      return Promise.reject(
+        new AsgardeoAuthException2(
+          "SPA-MAIN_THREAD_CLIENT-RCG-IV01",
+          "Request to the provided endpoint is prohibited.",
+          "Requests can only be sent to resource servers specified by the `resourceServerURLs` attribute while initializing the SDK. The specified token endpoint in this request cannot be found among the `resourceServerURLs`"
+        )
+      );
     }
-    request.startTimeInMs = (/* @__PURE__ */ new Date()).getTime();
-    if (HttpClient.isHandlerEnabled) {
-      if (this.requestStartCallback && typeof this.requestStartCallback === "function") {
-        this.requestStartCallback(request);
+  }
+  async getCustomGrantConfigData() {
+    const configString = await this._storageManager.getTemporaryDataParameter(CUSTOM_GRANT_CONFIG);
+    if (configString) {
+      return JSON.parse(configString);
+    } else {
+      return null;
+    }
+  }
+  async refreshAccessToken(enableRetrievingSignOutURLFromSession) {
+    try {
+      await this._authenticationClient.refreshAccessToken();
+      const customGrantConfig = await this.getCustomGrantConfigData();
+      if (customGrantConfig) {
+        await this.exchangeToken(customGrantConfig, enableRetrievingSignOutURLFromSession);
       }
+      this._spaHelper.refreshAccessTokenAutomatically(this);
+      return this._authenticationClient.getUser();
+    } catch (error) {
+      const refreshTokenError = {
+        type: REFRESH_ACCESS_TOKEN_ERR0R
+      };
+      window.postMessage(refreshTokenError);
+      return Promise.reject(error);
     }
-    return request;
   }
-  /**
-   * Handles response errors.
-   * If the `isHandlerEnabled` flag is set to true, fires the `requestErrorCallback`
-   * and the `requestFinishCallback` functions. Else, just returns the original error.
-   *
-   * @param {HttpError} error - Original error.
-   * @return {HttpError}
-   */
-  errorHandler(error) {
-    if (HttpClient.isHandlerEnabled) {
-      if (this.requestErrorCallback && typeof this.requestErrorCallback === "function") {
-        this.requestErrorCallback(error);
+  async retryFailedRequests(failedRequest) {
+    const httpClient = failedRequest.httpClient;
+    const requestConfig = failedRequest.requestConfig;
+    const isHttpHandlerEnabled = failedRequest.isHttpHandlerEnabled;
+    const httpErrorCallback = failedRequest.httpErrorCallback;
+    const httpFinishCallback = failedRequest.httpFinishCallback;
+    await SPAUtils.until(() => !this._isTokenRefreshing);
+    try {
+      const httpResponse = await httpClient.request(requestConfig);
+      return Promise.resolve(httpResponse);
+    } catch (error) {
+      if (isHttpHandlerEnabled) {
+        if (typeof httpErrorCallback === "function") {
+          await httpErrorCallback(error);
+        }
+        if (typeof httpFinishCallback === "function") {
+          httpFinishCallback();
+        }
       }
-      if (this.requestFinishCallback && typeof this.requestFinishCallback === "function") {
-        this.requestFinishCallback();
+      return Promise.reject(error);
+    }
+  }
+  async httpRequest(httpClient, requestConfig, isHttpHandlerEnabled, httpErrorCallback, httpFinishCallback, enableRetrievingSignOutURLFromSession) {
+    let matches = false;
+    const config = await this._storageManager.getConfigData();
+    for (const baseUrl of [...await config?.resourceServerURLs ?? [], config.baseUrl]) {
+      if (baseUrl && requestConfig?.url?.startsWith(baseUrl)) {
+        matches = true;
+        break;
       }
     }
-    throw error;
+    if (matches) {
+      return httpClient.request(requestConfig).then((response) => {
+        return Promise.resolve(response);
+      }).catch(async (error) => {
+        if (error?.response?.status === 401 || !error?.response) {
+          if (this._isTokenRefreshing) {
+            return this.retryFailedRequests({
+              enableRetrievingSignOutURLFromSession,
+              httpClient,
+              httpErrorCallback,
+              httpFinishCallback,
+              isHttpHandlerEnabled,
+              requestConfig
+            });
+          }
+          this._isTokenRefreshing = true;
+          let refreshAccessTokenResponse;
+          try {
+            refreshAccessTokenResponse = await this.refreshAccessToken(enableRetrievingSignOutURLFromSession);
+            this._isTokenRefreshing = false;
+          } catch (refreshError) {
+            this._isTokenRefreshing = false;
+            if (isHttpHandlerEnabled) {
+              if (typeof httpErrorCallback === "function") {
+                await httpErrorCallback({
+                  ...error,
+                  code: ACCESS_TOKEN_INVALID
+                });
+              }
+              if (typeof httpFinishCallback === "function") {
+                httpFinishCallback();
+              }
+            }
+            throw new AsgardeoAuthException2(
+              "SPA-AUTH_HELPER-HR-SE01",
+              refreshError?.name ?? "Refresh token request failed.",
+              refreshError?.message ?? "An error occurred while trying to refresh the access token following a 401 response from the server."
+            );
+          }
+          if (refreshAccessTokenResponse) {
+            try {
+              const httpResponse = await httpClient.request(requestConfig);
+              return Promise.resolve(httpResponse);
+            } catch (error2) {
+              if (isHttpHandlerEnabled) {
+                if (typeof httpErrorCallback === "function") {
+                  await httpErrorCallback(error2);
+                }
+                if (typeof httpFinishCallback === "function") {
+                  httpFinishCallback();
+                }
+              }
+              return Promise.reject(error2);
+            }
+          }
+        }
+        if (isHttpHandlerEnabled) {
+          if (typeof httpErrorCallback === "function") {
+            await httpErrorCallback(error);
+          }
+          if (typeof httpFinishCallback === "function") {
+            httpFinishCallback();
+          }
+        }
+        return Promise.reject(error);
+      });
+    } else {
+      return Promise.reject(
+        new AsgardeoAuthException2(
+          "SPA-AUTH_HELPER-HR-IV02",
+          "Request to the provided endpoint is prohibited.",
+          "Requests can only be sent to resource servers specified by the `resourceServerURLs` attribute while initializing the SDK. The specified endpoint in this request cannot be found among the `resourceServerURLs`"
+        )
+      );
+    }
   }
-  /**
-   * Handles response success.
-   * If the `isHandlerEnabled` flag is set to true, fires the `requestSuccessCallback`
-   * and the `requestFinishCallback` functions. Else, just returns the original response.
-   *
-   * @param {HttpResponse} response - Original response.
-   * @return {HttpResponse}
-   */
-  successHandler(response) {
-    if (HttpClient.isHandlerEnabled) {
-      if (this.requestSuccessCallback && typeof this.requestSuccessCallback === "function") {
-        this.requestSuccessCallback(response);
+  async httpRequestAll(requestConfigs, httpClient, isHttpHandlerEnabled, httpErrorCallback, httpFinishCallback) {
+    let matches = true;
+    const config = await this._storageManager.getConfigData();
+    for (const requestConfig of requestConfigs) {
+      let urlMatches = false;
+      for (const baseUrl of [...(await config)?.resourceServerURLs ?? [], config.baseUrl]) {
+        if (baseUrl && requestConfig.url?.startsWith(baseUrl)) {
+          urlMatches = true;
+          break;
+        }
       }
-      if (this.requestFinishCallback && typeof this.requestFinishCallback === "function") {
-        this.requestFinishCallback();
+      if (!urlMatches) {
+        matches = false;
+        break;
       }
     }
-    return response;
-  }
-  /**
-   * Initializes the Http client.
-   *
-   * @param isHandlerEnabled - Flag to toggle handler enablement.
-   * @param requestStartCallback - Callback function to be triggered on request start.
-   * @param requestSuccessCallback - Callback function to be triggered on request success.
-   * @param requestErrorCallback - Callback function to be triggered on request error.
-   * @param requestFinishCallback - Callback function to be triggered on request error.
-   */
-  async init(isHandlerEnabled = true, attachToken) {
-    HttpClient.isHandlerEnabled = isHandlerEnabled;
-    this.attachToken = attachToken;
-  }
-  /**
-   * Enables the handler.
-   */
-  enableHandler() {
-    HttpClient.isHandlerEnabled = true;
-  }
-  /**
-   * Disables the handler.
-   */
-  disableHandler() {
-    HttpClient.isHandlerEnabled = false;
-  }
-  /**
-   * Disables the handler for a given period of time.
-   *
-   * @param {number} timeout - Timeout in milliseconds.
-   */
-  disableHandlerWithTimeout(timeout = HttpClient.DEFAULT_HANDLER_DISABLE_TIMEOUT) {
-    HttpClient.isHandlerEnabled = false;
-    setTimeout(() => {
-      HttpClient.isHandlerEnabled = true;
-    }, timeout);
-  }
-  setHttpRequestStartCallback(callback) {
-    this.requestStartCallback = callback;
-  }
-  setHttpRequestSuccessCallback(callback) {
-    this.requestSuccessCallback = callback;
-  }
-  setHttpRequestErrorCallback(callback) {
-    this.requestErrorCallback = callback;
-  }
-  setHttpRequestFinishCallback(callback) {
-    this.requestFinishCallback = callback;
-  }
-};
-__publicField(HttpClient, "axiosInstance");
-__publicField(HttpClient, "clientInstance");
-__publicField(HttpClient, "isHandlerEnabled");
-__publicField(HttpClient, "DEFAULT_HANDLER_DISABLE_TIMEOUT", 1e3);
-HttpClient = __decorateClass([
-  staticDecorator()
-], HttpClient);
-
-// src/__legacy__/stores/local-store.ts
-var LocalStore = class {
-  async setData(key, value) {
-    localStorage.setItem(key, value);
-  }
-  async getData(key) {
-    return localStorage.getItem(key) ?? "{}";
-  }
-  async removeData(key) {
-    localStorage.removeItem(key);
-  }
-};
-
-// src/__legacy__/stores/memory-store.ts
-var MemoryStore = class {
-  constructor() {
-    __publicField(this, "_data");
-    this._data = /* @__PURE__ */ new Map();
-  }
-  async setData(key, value) {
-    this._data.set(key, value);
-  }
-  async getData(key) {
-    return this._data?.get(key) ?? "{}";
-  }
-  async removeData(key) {
-    this._data.delete(key);
-  }
-};
-
-// src/__legacy__/stores/session-store.ts
-var SessionStore = class {
-  async setData(key, value) {
-    sessionStorage.setItem(key, value);
-  }
-  async getData(key) {
-    return sessionStorage.getItem(key) ?? "{}";
-  }
-  async removeData(key) {
-    sessionStorage.removeItem(key);
-  }
-};
-
-// src/__legacy__/utils/crypto-utils.ts
-var import_buffer = __toESM(require_buffer(), 1);
-var import_randombytes = __toESM(require_browser(), 1);
-import { AsgardeoAuthException as AsgardeoAuthException2 } from "@asgardeo/javascript";
-import base64url from "base64url";
-import sha256 from "fast-sha256";
-import { createLocalJWKSet, jwtVerify } from "jose";
-var SPACryptoUtils = class {
-  /**
-   * Get URL encoded string.
-   *
-   * @returns {string} base 64 url encoded value.
-   */
-  base64URLEncode(value) {
-    return base64url.encode(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-  }
-  base64URLDecode(value) {
-    return base64url.decode(value).toString();
-  }
-  hashSha256(data) {
-    return import_buffer.Buffer.from(sha256(new TextEncoder().encode(data)));
-  }
-  generateRandomBytes(length) {
-    return (0, import_randombytes.default)(length);
-  }
-  verifyJwt(idToken, jwk, algorithms, clientID, issuer, subject, clockTolerance, validateJwtIssuer) {
-    const jwtVerifyOptions = {
-      algorithms,
-      audience: clientID,
-      clockTolerance,
-      subject
-    };
-    if (validateJwtIssuer ?? true) {
-      jwtVerifyOptions["issuer"] = issuer;
-    }
-    return jwtVerify(
-      idToken,
-      createLocalJWKSet({
-        keys: [jwk]
-      }),
-      jwtVerifyOptions
-    ).then(() => {
-      return Promise.resolve(true);
-    }).catch((error) => {
-      return Promise.reject(
-        new AsgardeoAuthException2(
-          "SPA-CRYPTO-UTILS-VJ-IV01",
-          error?.reason ?? JSON.stringify(error),
-          `${error?.code} ${error?.claim}`
-        )
-      );
-    });
-  }
-};
-
-// src/__legacy__/worker/worker-core.ts
-var WebWorkerCore = async (config, getAuthHelper) => {
-  const _store = new MemoryStore();
-  const _cryptoUtils = new SPACryptoUtils();
-  const _authenticationClient = new AsgardeoAuthClient5();
-  await _authenticationClient.initialize(config, _store, _cryptoUtils);
-  const _spaHelper = new SPAHelper(_authenticationClient);
-  const _authenticationHelper = getAuthHelper(
-    _authenticationClient,
-    _spaHelper
-  );
-  const _dataLayer = _authenticationClient.getDataLayer();
-  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 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 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 requestCustomGrant = async (config2) => {
-    return await _authenticationHelper.requestCustomGrant(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 getBasicUserInfo = async () => {
-    return _authenticationHelper.getBasicUserInfo();
-  };
-  const getDecodedIDToken = async () => {
-    return _authenticationHelper.getDecodedIDToken();
-  };
-  const getCryptoHelper = async () => {
-    return _authenticationHelper.getCryptoHelper();
-  };
-  const getDecodedIDPIDToken = async () => {
-    return _authenticationHelper.getDecodedIDPIDToken();
-  };
-  const getIDToken = async () => {
-    return _authenticationHelper.getIDToken();
-  };
-  const getOIDCServiceEndpoints = async () => {
-    return _authenticationHelper.getOIDCServiceEndpoints();
-  };
-  const getAccessToken = () => {
-    return _authenticationHelper.getAccessToken();
-  };
-  const isAuthenticated = () => {
-    return _authenticationHelper.isAuthenticated();
-  };
-  const setSessionState = async (sessionState) => {
-    await _dataLayer.setSessionDataParameter(
-      OIDCRequestConstants3.Params.SESSION_STATE,
-      sessionState
-    );
-    return;
-  };
-  const updateConfig = async (config2) => {
-    await _authenticationClient.updateConfig(config2);
-    return;
-  };
-  const getConfigData = async () => {
-    return _dataLayer.getConfigData();
-  };
-  return {
-    disableHttpHandler,
-    enableHttpHandler,
-    getAccessToken,
-    getAuthorizationURL,
-    getBasicUserInfo,
-    getConfigData,
-    getCryptoHelper,
-    getDecodedIDPIDToken,
-    getDecodedIDToken,
-    getIDToken,
-    getOIDCServiceEndpoints,
-    getSignOutURL,
-    httpRequest,
-    httpRequestAll,
-    isAuthenticated,
-    refreshAccessToken,
-    requestAccessToken,
-    requestCustomGrant,
-    revokeAccessToken,
-    setHttpRequestFinishCallback,
-    setHttpRequestStartCallback,
-    setHttpRequestSuccessCallback,
-    setSessionState,
-    signOut,
-    startAutoRefreshToken,
-    updateConfig
-  };
-};
-
-// 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
-import {
-  AsgardeoAuthClient as AsgardeoAuthClient7,
-  ResponseMode,
-  OIDCRequestConstants as OIDCRequestConstants4,
-  extractPkceStorageKeyFromState as extractPkceStorageKeyFromState2
-} from "@asgardeo/javascript";
-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 AsgardeoAuthClient7();
-  await _authenticationClient.initialize(config, _store, _cryptoUtils, instanceID);
-  const _spaHelper = new SPAHelper(_authenticationClient);
-  const _dataLayer = _authenticationClient.getDataLayer();
-  const _sessionManagementHelper = await SessionManagementHelper(
-    async () => {
-      return _authenticationClient.getSignOutURL();
-    },
-    config.storage ?? "sessionStorage" /* SessionStorage */,
-    (sessionState) => _dataLayer.setSessionDataParameter(
-      OIDCRequestConstants4.Params.SESSION_STATE,
-      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);
-  };
-  _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 setHttpRequestErrorCallback = (callback) => {
-    _httpErrorCallback = callback;
-  };
-  const httpRequest = async (requestConfig) => {
-    return await _authenticationHelper.httpRequest(
-      _httpClient,
-      requestConfig,
-      _isHttpHandlerEnabled,
-      _httpErrorCallback,
-      _httpFinishCallback
-    );
-  };
-  const httpRequestAll = async (requestConfigs) => {
-    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 checkSession = async () => {
-    const oidcEndpoints = await _authenticationClient.getOIDCServiceEndpoints();
-    const config2 = await _dataLayer.getConfigData();
-    _authenticationHelper.initializeSessionManger(
-      config2,
-      oidcEndpoints,
-      async () => (await _authenticationClient.getBasicUserInfo()).sessionState,
-      async (params) => _authenticationClient.getAuthorizationURL(params),
-      _sessionManagementHelper
-    );
-  };
-  const shouldStopAuthn = async () => {
-    return await _sessionManagementHelper.receivePromptNoneResponse(async (sessionState) => {
-      await _dataLayer.setSessionDataParameter(
-        OIDCRequestConstants4.Params.SESSION_STATE,
-        sessionState ?? ""
-      );
-      return;
-    });
-  };
-  const setSessionStatus = async (sessionStatus) => {
-    await _dataLayer.setSessionStatus(sessionStatus);
-  };
-  const signIn = async (signInConfig, authorizationCode, sessionState, state, tokenRequestConfig) => {
-    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 === ResponseMode.FormPost && authorizationCode) {
-        resolvedAuthorizationCode = authorizationCode;
-        resolvedSessionState = sessionState ?? "";
-        resolvedState = state ?? "";
-      } else {
-        resolvedAuthorizationCode = new URL(window.location.href).searchParams.get(OIDCRequestConstants4.Params.AUTHORIZATION_CODE) ?? "";
-        resolvedSessionState = new URL(window.location.href).searchParams.get(OIDCRequestConstants4.Params.SESSION_STATE) ?? "";
-        resolvedState = new URL(window.location.href).searchParams.get(OIDCRequestConstants4.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.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;
-        await SPAUtils.waitTillPageRedirect();
-        return Promise.resolve({
-          allowedScopes: "",
-          displayName: "",
-          email: "",
-          sessionState: "",
-          sub: "",
-          tenantDomain: "",
-          username: ""
-        });
+    const requests = [];
+    if (matches) {
+      requestConfigs.forEach((request) => {
+        requests.push(httpClient.request(request));
+      });
+      return httpClient?.all && httpClient.all(requests).then((responses) => {
+        return Promise.resolve(responses);
+      }).catch(async (error) => {
+        if (error?.response?.status === 401 || !error?.response) {
+          let refreshTokenResponse;
+          try {
+            refreshTokenResponse = await this._authenticationClient.refreshAccessToken();
+          } catch (refreshError) {
+            if (isHttpHandlerEnabled) {
+              if (typeof httpErrorCallback === "function") {
+                await httpErrorCallback({
+                  ...error,
+                  code: ACCESS_TOKEN_INVALID
+                });
+              }
+              if (typeof httpFinishCallback === "function") {
+                httpFinishCallback();
+              }
+            }
+            throw new AsgardeoAuthException2(
+              "SPA-AUTH_HELPER-HRA-SE01",
+              refreshError?.name ?? "Refresh token request failed.",
+              refreshError?.message ?? "An error occurred while trying to refresh the access token following a 401 response from the server."
+            );
+          }
+          if (refreshTokenResponse) {
+            return httpClient.all && httpClient.all(requests).then((response) => {
+              return Promise.resolve(response);
+            }).catch(async (error2) => {
+              if (isHttpHandlerEnabled) {
+                if (typeof httpErrorCallback === "function") {
+                  await httpErrorCallback(error2);
+                }
+                if (typeof httpFinishCallback === "function") {
+                  httpFinishCallback();
+                }
+              }
+              return Promise.reject(error2);
+            });
+          }
+        }
+        if (isHttpHandlerEnabled) {
+          if (typeof httpErrorCallback === "function") {
+            await httpErrorCallback(error);
+          }
+          if (typeof httpFinishCallback === "function") {
+            httpFinishCallback();
+          }
+        }
+        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);
+      throw new AsgardeoAuthException2(
+        "SPA-AUTH_HELPER-HRA-IV02",
+        "Request to the provided endpoint is prohibited.",
+        "Requests can only be sent to resource servers specified by the `resourceServerURLs` attribute while initializing the SDK. The specified endpoint in this request cannot be found among the `resourceServerURLs`"
+      );
     }
-    _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;
+  }
+  async requestAccessToken(authorizationCode, sessionState, checkSession, pkce, state, tokenRequestConfig) {
+    const config = await this._storageManager.getConfigData();
+    if (config.storage === "browserMemory" /* BrowserMemory */ && config.enablePKCE && sessionState) {
+      const pkce2 = SPAUtils.getPKCE(extractPkceStorageKeyFromState2(sessionState));
+      await this._authenticationClient.setPKCECode(extractPkceStorageKeyFromState2(sessionState), pkce2);
+    } else if (config.storage === "webWorker" /* WebWorker */ && pkce) {
+      await this._authenticationClient.setPKCECode(pkce, state ?? "");
     }
-  };
-  const requestCustomGrant = async (config2) => {
-    return await _authenticationHelper.requestCustomGrant(config2, enableRetrievingSignOutURLFromSession);
-  };
-  const refreshAccessToken = async () => {
+    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);
+          if (this._spaHelper) {
+            this._spaHelper.clearRefreshTokenTimeout();
+            this._spaHelper.refreshAccessTokenAutomatically(this);
+          }
+          if (checkSession && typeof checkSession === "function" && config.enableOIDCSessionManagement) {
+            checkSession();
+          }
+        } else {
+          if (this._spaHelper) {
+            this._spaHelper.refreshAccessTokenAutomatically(this);
+          }
+        }
+        return this._authenticationClient.getUser();
+      }).catch((error) => {
+        return Promise.reject(error);
+      });
+    }
+    return Promise.reject(
+      new AsgardeoAuthException2(
+        "SPA-AUTH_HELPER-RAT1-NF01",
+        "No authorization code.",
+        "No authorization code was found."
+      )
+    );
+  }
+  async trySignInSilently(constructSilentSignInUrl, requestAccessToken, sessionManagementHelper, additionalParams, tokenRequestConfig) {
+    if (SPAUtils.isInitializedSilentSignIn()) {
+      await sessionManagementHelper.receivePromptNoneResponse();
+      return Promise.resolve({
+        allowedScopes: "",
+        displayName: "",
+        email: "",
+        sessionState: "",
+        sub: "",
+        tenantDomain: "",
+        username: ""
+      });
+    }
+    const rpIFrame = document.getElementById(RP_IFRAME);
+    const promptNoneIFrame = rpIFrame?.contentDocument?.getElementById(
+      PROMPT_NONE_IFRAME
+    );
     try {
-      return await _authenticationHelper.refreshAccessToken(enableRetrievingSignOutURLFromSession);
+      const url = await constructSilentSignInUrl(additionalParams);
+      promptNoneIFrame.src = url;
     } catch (error) {
       return Promise.reject(error);
     }
-  };
-  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 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.getAuthorizationURL({
-      prompt: "none",
-      state: SILENT_SIGN_IN_STATE,
-      ...additionalParams
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        resolve(false);
+      }, 1e4);
+      const listenToPromptNoneIFrame = async (e) => {
+        const data = e.data;
+        if (data?.type == CHECK_SESSION_SIGNED_OUT) {
+          window.removeEventListener("message", listenToPromptNoneIFrame);
+          clearTimeout(timer);
+          resolve(false);
+        }
+        if (data?.type == CHECK_SESSION_SIGNED_IN && data?.data?.code) {
+          requestAccessToken(data?.data?.code, data?.data?.sessionState, data?.data?.state, tokenRequestConfig).then((response) => {
+            window.removeEventListener("message", listenToPromptNoneIFrame);
+            resolve(response);
+          }).catch((error) => {
+            window.removeEventListener("message", listenToPromptNoneIFrame);
+            reject(error);
+          }).finally(() => {
+            clearTimeout(timer);
+          });
+        }
+      };
+      window.addEventListener("message", listenToPromptNoneIFrame);
     });
-    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 ?? "")
-      );
+  }
+  async handleSignIn(shouldStopAuthn, checkSession, tryRetrievingUserInfo) {
+    const config = await this._storageManager.getConfigData();
+    if (await shouldStopAuthn()) {
+      return Promise.resolve({
+        allowedScopes: "",
+        displayName: "",
+        email: "",
+        sessionState: "",
+        sub: "",
+        tenantDomain: "",
+        username: ""
+      });
     }
-    return url;
-  };
-  const trySignInSilently = async (additionalParams, tokenRequestConfig) => {
-    return await _authenticationHelper.trySignInSilently(
-      constructSilentSignInUrl,
-      requestAccessToken,
-      _sessionManagementHelper,
-      additionalParams,
-      tokenRequestConfig
-    );
-  };
-  const getBasicUserInfo = async () => {
-    return _authenticationHelper.getBasicUserInfo();
-  };
-  const getDecodedIDToken = async () => {
-    return _authenticationHelper.getDecodedIDToken();
-  };
-  const getCryptoHelper = async () => {
-    return _authenticationHelper.getCryptoHelper();
-  };
-  const getIDToken = async () => {
-    return _authenticationHelper.getIDToken();
-  };
-  const getOIDCServiceEndpoints = async () => {
-    return _authenticationHelper.getOIDCServiceEndpoints();
-  };
-  const getAccessToken = async () => {
-    return _authenticationHelper.getAccessToken();
-  };
-  const getDataLayer = async () => {
-    return _authenticationHelper.getDataLayer();
-  };
-  const getConfigData = async () => {
-    return await _dataLayer.getConfigData();
-  };
-  const isAuthenticated = async () => {
-    return _authenticationHelper.isAuthenticated();
-  };
-  const isSessionActive = async () => {
-    return await _dataLayer.getSessionStatus() === "true";
-  };
-  const updateConfig = 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.updateConfig(config2);
-    if (config2.enableOIDCSessionManagement && isCheckSessionIframeDifferent) {
-      _sessionManagementHelper.reset();
-      checkSession();
+    if (config.storage !== "webWorker" /* WebWorker */) {
+      if (await this._authenticationClient.isSignedIn()) {
+        this._spaHelper.clearRefreshTokenTimeout();
+        this._spaHelper.refreshAccessTokenAutomatically(this);
+        if (config.enableOIDCSessionManagement) {
+          checkSession();
+        }
+        return Promise.resolve(await this._authenticationClient.getUser());
+      }
     }
-  };
-  return {
-    disableHttpHandler,
-    enableHttpHandler,
-    getAccessToken,
-    getBasicUserInfo,
-    getConfigData,
-    getCryptoHelper,
-    getDataLayer,
-    getDecodedIDToken,
-    getHttpClient,
-    getIDToken,
-    getOIDCServiceEndpoints,
-    httpRequest,
-    httpRequestAll,
-    isAuthenticated,
-    isSessionActive,
-    refreshAccessToken,
-    requestCustomGrant,
-    revokeAccessToken,
-    setHttpRequestErrorCallback,
-    setHttpRequestFinishCallback,
-    setHttpRequestStartCallback,
-    setHttpRequestSuccessCallback,
-    signIn,
-    signOut,
-    trySignInSilently,
-    updateConfig
-  };
+    const error = new URL(window.location.href).searchParams.get(ERROR);
+    const errorDescription = new URL(window.location.href).searchParams.get(ERROR_DESCRIPTION);
+    if (error) {
+      const url = new URL(window.location.href);
+      url.searchParams.delete(ERROR);
+      url.searchParams.delete(ERROR_DESCRIPTION);
+      history.pushState(null, document.title, url.toString());
+      throw new AsgardeoAuthException2("SPA-AUTH_HELPER-SI-SE01", error, errorDescription ?? "");
+    }
+    if (config.storage === "webWorker" /* WebWorker */ && tryRetrievingUserInfo) {
+      const basicUserInfo = await tryRetrievingUserInfo();
+      if (basicUserInfo) {
+        return basicUserInfo;
+      }
+    }
+    return Promise.resolve(void 0);
+  }
+  async attachTokenToRequestConfig(request) {
+    const requestConfig = { attachToken: true, ...request };
+    if (requestConfig.attachToken) {
+      if (requestConfig.shouldAttachIDPAccessToken) {
+        request.headers = {
+          ...request.headers,
+          Authorization: `Bearer ${await this.getIDPAccessToken()}`
+        };
+      } else {
+        request.headers = {
+          ...request.headers,
+          Authorization: `Bearer ${await this.getAccessToken()}`
+        };
+      }
+    }
+  }
+  async getUser() {
+    return this._authenticationClient.getUser();
+  }
+  async getDecodedIdToken() {
+    return this._authenticationClient.getDecodedIdToken();
+  }
+  async getDecodedIDPIDToken() {
+    return this._authenticationClient.getDecodedIdToken();
+  }
+  async getCrypto() {
+    return this._authenticationClient.getCrypto();
+  }
+  async getIdToken() {
+    return this._authenticationClient.getIdToken();
+  }
+  async getOpenIDProviderEndpoints() {
+    return this._authenticationClient.getOpenIDProviderEndpoints();
+  }
+  async getAccessToken() {
+    return this._authenticationClient.getAccessToken();
+  }
+  async getIDPAccessToken() {
+    return (await this._storageManager.getSessionData())?.access_token;
+  }
+  getStorageManager() {
+    return this._storageManager;
+  }
+  async isSignedIn() {
+    return this._authenticationClient.isSignedIn();
+  }
 };
 
 // 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 */:
@@ -3894,7 +3497,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
   let _getSignOutURLFromSessionStorage = false;
   const _store = initiateStore2(config.storage);
   const _cryptoUtils = new SPACryptoUtils();
-  const _authenticationClient = new AsgardeoAuthClient8();
+  const _authenticationClient = new AsgardeoAuthClient6();
   await _authenticationClient.initialize(config, _store, _cryptoUtils, instanceID);
   const _spaHelper = new SPAHelper(_authenticationClient);
   const _sessionManagementHelper = await SessionManagementHelper(
@@ -3906,7 +3509,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
         const signOutURL = await communicate(message);
         return signOutURL;
       } catch {
-        return SPAUtils.getSignOutURL(config.clientID, instanceID);
+        return SPAUtils.getSignOutUrl(config.clientId, instanceID);
       }
     },
     config.storage,
@@ -3923,7 +3526,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         reject(
-          new AsgardeoAuthException4(
+          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"
@@ -3946,7 +3549,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       };
     });
   };
-  const requestCustomGrant = (requestParams) => {
+  const exchangeToken = (requestParams) => {
     const message = {
       data: requestParams,
       type: REQUEST_CUSTOM_GRANT
@@ -4069,13 +3672,13 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
     return communicate(message);
   };
   const checkSession = async () => {
-    const oidcEndpoints = await getOIDCServiceEndpoints();
+    const oidcEndpoints = await getOpenIDProviderEndpoints();
     const config2 = await getConfigData();
     _authenticationHelper.initializeSessionManger(
       config2,
       oidcEndpoints,
-      async () => (await getBasicUserInfo()).sessionState,
-      async (params) => (await getAuthorizationURL(params)).authorizationURL,
+      async () => (await _authenticationClient.getUserSession()).sessionState,
+      async (params) => (await getSignInUrl(params)).authorizationURL,
       _sessionManagementHelper
     );
   };
@@ -4089,9 +3692,11 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       },
       type: GET_AUTH_URL
     };
-    const response = await communicate(message);
+    const response = await communicate(
+      message
+    );
     const pkceKey = extractPkceStorageKeyFromState3(
-      new URL(response.authorizationURL).searchParams.get(OIDCRequestConstants5.Params.STATE) ?? ""
+      new URL(response.authorizationURL).searchParams.get(OIDCRequestConstants4.Params.STATE) ?? ""
     );
     response.pkce && config2.enablePKCE && SPAUtils.setPKCE(pkceKey, response.pkce);
     const urlString = response.authorizationURL;
@@ -4109,7 +3714,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       tokenRequestConfig
     );
   };
-  const getAuthorizationURL = async (params) => {
+  const getSignInUrl = async (params) => {
     const config2 = await getConfigData();
     const message = {
       data: params,
@@ -4119,7 +3724,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       async (response) => {
         if (response.pkce && config2.enablePKCE) {
           const pkceKey = extractPkceStorageKeyFromState3(
-            new URL(response.authorizationURL).searchParams.get(OIDCRequestConstants5.Params.STATE) ?? ""
+            new URL(response.authorizationURL).searchParams.get(OIDCRequestConstants4.Params.STATE) ?? ""
           );
           SPAUtils.setPKCE(pkceKey, response.pkce);
         }
@@ -4146,7 +3751,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
         type: GET_SIGN_OUT_URL
       };
       return communicate(message2).then((url) => {
-        SPAUtils.setSignOutURL(url, config2.clientID, instanceID);
+        SPAUtils.setSignOutURL(url, config2.clientId, instanceID);
         if (config2.enableOIDCSessionManagement) {
           checkSession();
         }
@@ -4165,12 +3770,12 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
     });
   };
   const tryRetrievingUserInfo = async () => {
-    if (await isAuthenticated()) {
+    if (await isSignedIn()) {
       await startAutoRefreshToken();
       if (config.enableOIDCSessionManagement) {
         checkSession();
       }
-      return getBasicUserInfo();
+      return getUser();
     }
     return Promise.resolve(void 0);
   };
@@ -4186,20 +3791,20 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       let resolvedAuthorizationCode;
       let resolvedSessionState;
       let resolvedState;
-      if (config?.responseMode === ResponseMode2.FormPost && authorizationCode) {
+      if (config?.responseMode === "form_post" && 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) ?? "";
+        resolvedAuthorizationCode = new URL(window.location.href).searchParams.get(OIDCRequestConstants4.Params.AUTHORIZATION_CODE) ?? "";
+        resolvedSessionState = new URL(window.location.href).searchParams.get(OIDCRequestConstants4.Params.SESSION_STATE) ?? "";
+        resolvedState = new URL(window.location.href).searchParams.get(OIDCRequestConstants4.Params.STATE) ?? "";
         SPAUtils.removeAuthorizationCode();
       }
       if (resolvedAuthorizationCode && resolvedState) {
         return requestAccessToken(resolvedAuthorizationCode, resolvedSessionState, resolvedState, tokenRequestConfig);
       }
-      return getAuthorizationURL(params).then(async (response) => {
+      return getSignInUrl(params).then(async (response) => {
         location.href = response.authorizationURL;
         await SPAUtils.waitTillPageRedirect();
         return Promise.resolve({
@@ -4230,7 +3835,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
           return reject(error);
         });
       } else {
-        window.location.href = SPAUtils.getSignOutURL(config.clientID, instanceID);
+        window.location.href = SPAUtils.getSignOutUrl(config.clientId, instanceID);
         return SPAUtils.waitTillPageRedirect().then(() => {
           return Promise.resolve(true);
         });
@@ -4248,7 +3853,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       return Promise.reject(error);
     });
   };
-  const getOIDCServiceEndpoints = () => {
+  const getOpenIDProviderEndpoints = () => {
     const message = {
       type: GET_OIDC_SERVICE_ENDPOINTS
     };
@@ -4268,7 +3873,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       return Promise.reject(error);
     });
   };
-  const getBasicUserInfo = () => {
+  const getUser = () => {
     const message = {
       type: GET_BASIC_USER_INFO
     };
@@ -4278,7 +3883,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       return Promise.reject(error);
     });
   };
-  const getDecodedIDToken = () => {
+  const getDecodedIdToken = () => {
     const message = {
       type: GET_DECODED_ID_TOKEN
     };
@@ -4298,7 +3903,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       return Promise.reject(error);
     });
   };
-  const getCryptoHelper = () => {
+  const getCrypto = () => {
     const message = {
       type: GET_CRYPTO_HELPER
     };
@@ -4308,7 +3913,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       return Promise.reject(error);
     });
   };
-  const getIDToken = () => {
+  const getIdToken = () => {
     const message = {
       type: GET_ID_TOKEN
     };
@@ -4318,7 +3923,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       return Promise.reject(error);
     });
   };
-  const isAuthenticated = () => {
+  const isSignedIn = () => {
     const message = {
       type: IS_AUTHENTICATED
     };
@@ -4354,7 +3959,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       httpClientHandlers.requestFinishCallback = callback;
     }
   };
-  const updateConfig = async (newConfig) => {
+  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 };
@@ -4371,19 +3976,19 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
   return {
     disableHttpHandler,
     enableHttpHandler,
-    getBasicUserInfo,
+    getUser,
     getConfigData,
-    getCryptoHelper,
+    getCrypto,
     getDecodedIDPIDToken,
-    getDecodedIDToken,
-    getIDToken,
-    getOIDCServiceEndpoints,
+    getDecodedIdToken,
+    getIdToken,
+    getOpenIDProviderEndpoints,
     httpRequest,
     httpRequestAll,
     initialize,
-    isAuthenticated,
+    isSignedIn,
     refreshAccessToken,
-    requestCustomGrant,
+    exchangeToken,
     revokeAccessToken,
     setHttpRequestErrorCallback,
     setHttpRequestFinishCallback,
@@ -4392,7 +3997,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
     signIn,
     signOut,
     trySignInSilently,
-    updateConfig
+    reInitialize
   };
 };
 
@@ -4400,7 +4005,6 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
 var DefaultConfig = {
   autoLogoutOnTokenRefreshError: true,
   checkSessionInterval: 3,
-  clientHost: origin,
   enableOIDCSessionManagement: false,
   periodicTokenRefresh: false,
   sessionRefreshInterval: 300,
@@ -4411,7 +4015,8 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
     __publicField(this, "_client");
     __publicField(this, "_storage");
     __publicField(this, "_authHelper", AuthenticationHelper);
-    __publicField(this, "_worker", worker_default);
+    // protected _worker: new () => Worker = WorkerFile;
+    __publicField(this, "_worker", null);
     __publicField(this, "_initialized", false);
     __publicField(this, "_startedInitialize", false);
     __publicField(this, "_onSignInCallback", () => null);
@@ -4430,13 +4035,13 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
       this._authHelper = AuthenticationHelper;
     }
   }
-  instantiateWorker(worker) {
-    if (worker) {
-      this._worker = worker;
-    } else {
-      this._worker = worker_default;
-    }
-  }
+  // 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.
    *
@@ -4446,7 +4051,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @private
    */
-  async _isInitialized() {
+  async isInitialized() {
     if (!this._startedInitialize) {
       return false;
     }
@@ -4476,18 +4081,18 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    * @private
    */
   async _validateMethod(validateAuthentication = true) {
-    if (!await this._isInitialized()) {
+    if (!await this.isInitialized()) {
       return Promise.reject(
-        new AsgardeoAuthException5(
+        new AsgardeoAuthException4(
           "SPA-AUTH_CLIENT-VM-NF01",
           "The SDK is not initialized.",
           "The SDK must be initialized first."
         )
       );
     }
-    if (validateAuthentication && !await this.isAuthenticated()) {
+    if (validateAuthentication && !await this.isSignedIn()) {
       return Promise.reject(
-        new AsgardeoAuthException5(
+        new AsgardeoAuthException4(
           "SPA-AUTH_CLIENT-VM-IV02",
           "The user is not authenticated.",
           "The user must be authenticated first."
@@ -4537,8 +4142,8 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    * @example
    * ```
    * auth.initialize({
-   *     signInRedirectURL: "http://localhost:3000/sign-in",
-   *     clientID: "client ID",
+   *     afterSignInUrl: "http://localhost:3000/sign-in",
+   *     clientId: "client ID",
    *     baseUrl: "https://api.asgardeo.io"
    * });
    * ```
@@ -4554,7 +4159,6 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
     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;
@@ -4615,11 +4219,11 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
   /**
    * This method returns a Promise that resolves with the basic user information obtained from the ID token.
    *
-   * @return {Promise<BasicUserInfo>} - A promise that resolves with the user information.
+   * @return {Promise<User>} - A promise that resolves with the user information.
    *
    * @example
    * ```
-   * auth.getBasicUserInfo().then((response) => {
+   * auth.getUser().then((response) => {
    *    // console.log(response);
    * }).catch((error) => {
    *    // console.error(error);
@@ -4632,9 +4236,9 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @preserve
    */
-  async getBasicUserInfo() {
+  async getUser() {
     await this._validateMethod();
-    return this._client?.getBasicUserInfo();
+    return this._client?.getUser();
   }
   /**
    * This method initiates the authentication flow. This should be called twice.
@@ -4659,7 +4263,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    * @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<User>} - A promise that resolves with the user information.
    *
    * @example
    * ```
@@ -4673,16 +4277,14 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    * @preserve
    */
   async signIn(config, authorizationCode, sessionState, state, tokenRequestConfig) {
-    await this._isInitialized();
+    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);
-        }
+        this._onSignInCallback(response);
       }
       return response;
     });
@@ -4695,7 +4297,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    * 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
+   * @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
@@ -4704,16 +4306,13 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *```
    */
   async trySignInSilently(additionalParams, tokenRequestConfig) {
-    await this._isInitialized();
+    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);
-        }
+        this._onSignInCallback(response);
       }
       return response;
     });
@@ -4866,7 +4465,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @preserve
    */
-  async requestCustomGrant(config) {
+  async exchangeToken(config) {
     if (config.signInRequired) {
       await this._validateMethod();
     } else {
@@ -4874,14 +4473,14 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
     }
     if (!config.id) {
       return Promise.reject(
-        new AsgardeoAuthException5(
+        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?.requestCustomGrant(config);
+    const customGrantResponse = await this._client?.exchangeToken(config);
     const customGrantCallback = this._onCustomGrant.get(config.id);
     customGrantCallback && customGrantCallback(this._onCustomGrant?.get(config.id));
     return customGrantResponse;
@@ -4932,9 +4531,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 +4550,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 +4570,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @example
    * ```
-   * auth.getDecodedIDToken().then((response)=>{
+   * auth.getDecodedIdToken().then((response)=>{
    *     // console.log(response);
    * }).catch((error)=>{
    *     // console.error(error);
@@ -4983,9 +4582,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 +4594,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 +4617,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 +4656,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 +4692,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 +4711,7 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @example
    * ```
-   *   auth.getDataLayer().then((dataLayer) => {
+   *   auth.getStorageManager().then((dataLayer) => {
    *       // console.log(dataLayer);
    *   }).catch((error) => {
    *       // console.error(error);
@@ -5125,11 +4724,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 +4736,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 +4795,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 +4809,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 +4823,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 */:
@@ -5263,128 +4862,478 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
           if (signOutFail) {
             this._onSignOutFailedCallback(signOutFail);
           }
-          break;
+          break;
+        }
+        default:
+          throw new AsgardeoAuthException4("SPA-AUTH_CLIENT-ON-IV01", "Invalid hook.", "The provided hook is invalid.");
+      }
+    } else {
+      throw new AsgardeoAuthException4(
+        "SPA-AUTH_CLIENT-ON-IV02",
+        "Invalid callback function.",
+        "The provided callback function is invalid."
+      );
+    }
+  }
+  /**
+   * This method enables callback functions attached to the http client.
+   *
+   * @return {Promise<boolean>} - A promise that resolves with True.
+   *
+   * @example
+   * ```
+   * auth.enableHttpHandler();
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#enableHttpHandler
+   *
+   * @memberof AsgardeoSPAClient
+   *
+   * @preserve
+   */
+  async enableHttpHandler() {
+    await this.isInitialized();
+    return this._client?.enableHttpHandler();
+  }
+  /**
+   * This method disables callback functions attached to the http client.
+   *
+   * @return {Promise<boolean>} - A promise that resolves with True.
+   *
+   * @example
+   * ```
+   * auth.disableHttpHandler();
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#disableHttpHandler
+   *
+   * @memberof AsgardeoSPAClient
+   *
+   * @preserve
+   */
+  async disableHttpHandler() {
+    await this.isInitialized();
+    return this._client?.disableHttpHandler();
+  }
+  /**
+   * This method updates the configuration that was passed into the constructor when instantiating this class.
+   *
+   * @param {Partial<AuthClientConfig<T>>} config - A config object to update the SDK configurations with.
+   *
+   * @example
+   * ```
+   * const config = {
+   *     afterSignInUrl: "http://localhost:3000/sign-in",
+   *     clientId: "client ID",
+   *     baseUrl: "https://api.asgardeo.io"
+   * }
+   * const auth.reInitialize(config);
+   * ```
+   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master/lib#reInitialize
+   *
+   * @memberof AsgardeoAuthClient
+   *
+   * @preserve
+   */
+  async reInitialize(config) {
+    await this.isInitialized();
+    if (this._storage === "webWorker" /* WebWorker */) {
+      const client = this._client;
+      await client.reInitialize(config);
+    } else {
+      const client = this._client;
+      await client.reInitialize(config);
+    }
+    return;
+  }
+};
+__publicField(_AsgardeoSPAClient, "_instances", /* @__PURE__ */ new Map());
+var AsgardeoSPAClient = _AsgardeoSPAClient;
+
+// src/__legacy__/models/http-client.ts
+import {
+  AxiosResponse,
+  Method,
+  AxiosRequestTransformer,
+  AxiosResponseTransformer,
+  AxiosAdapter,
+  AxiosBasicCredentials,
+  ResponseType,
+  AxiosProxyConfig,
+  CancelToken,
+  AxiosError,
+  AxiosPromise,
+  AxiosInstance
+} from "axios";
+
+// src/__legacy__/models/web-worker.ts
+var WebWorkerClass = class {
+  constructor() {
+    __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;
         }
-        default:
-          throw new AsgardeoAuthException5("SPA-AUTH_CLIENT-ON-IV01", "Invalid hook.", "The provided hook is invalid.");
+        webWorker.httpRequest(request).then((response) => {
+          port.postMessage(MessageUtils.generateSuccessMessage(response));
+        }).catch((error) => {
+          port.postMessage(MessageUtils.generateFailureMessage(error));
+        });
+        break;
       }
-    } else {
-      throw new AsgardeoAuthException5(
-        "SPA-AUTH_CLIENT-ON-IV02",
-        "Invalid callback function.",
-        "The provided callback function is invalid."
-      );
-    }
-  }
-  /**
-   * This method enables callback functions attached to the http client.
-   *
-   * @return {Promise<boolean>} - A promise that resolves with True.
-   *
-   * @example
-   * ```
-   * auth.enableHttpHandler();
-   * ```
-   *
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#enableHttpHandler
-   *
-   * @memberof AsgardeoSPAClient
-   *
-   * @preserve
-   */
-  async enableHttpHandler() {
-    await this._isInitialized();
-    return this._client?.enableHttpHandler();
-  }
-  /**
-   * This method disables callback functions attached to the http client.
-   *
-   * @return {Promise<boolean>} - A promise that resolves with True.
-   *
-   * @example
-   * ```
-   * auth.disableHttpHandler();
-   * ```
-   *
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master#disableHttpHandler
-   *
-   * @memberof AsgardeoSPAClient
-   *
-   * @preserve
-   */
-  async disableHttpHandler() {
-    await this._isInitialized();
-    return this._client?.disableHttpHandler();
-  }
-  /**
-   * This method updates the configuration that was passed into the constructor when instantiating this class.
-   *
-   * @param {Partial<AuthClientConfig<T>>} config - A config object to update the SDK configurations with.
-   *
-   * @example
-   * ```
-   * const config = {
-   *     signInRedirectURL: "http://localhost:3000/sign-in",
-   *     clientID: "client ID",
-   *     baseUrl: "https://api.asgardeo.io"
-   * }
-   * const auth.updateConfig(config);
-   * ```
-   * @link https://github.com/asgardeo/asgardeo-auth-spa-sdk/tree/master/lib#updateConfig
-   *
-   * @memberof AsgardeoAuthClient
-   *
-   * @preserve
-   */
-  async updateConfig(config) {
-    await this._isInitialized();
-    if (this._storage === "webWorker" /* WebWorker */) {
-      const client = this._client;
-      await client.updateConfig(config);
-    } else {
-      const client = this._client;
-      await client.updateConfig(config);
+      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.`
+            )
+          )
+        );
     }
-    return;
-  }
-};
-__publicField(_AsgardeoSPAClient, "_instances", /* @__PURE__ */ new Map());
-var AsgardeoSPAClient = _AsgardeoSPAClient;
-
-// src/__legacy__/models/http-client.ts
-import {
-  AxiosResponse,
-  Method,
-  AxiosRequestTransformer,
-  AxiosResponseTransformer,
-  AxiosAdapter,
-  AxiosBasicCredentials,
-  ResponseType,
-  AxiosProxyConfig,
-  CancelToken,
-  AxiosError,
-  AxiosPromise,
-  AxiosInstance
-} from "axios";
-
-// src/__legacy__/models/web-worker.ts
-var WebWorkerClass = class extends Worker {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "onmessage", () => null);
-  }
-};
-
-// src/constants/StyleConstants.ts
-var StyleConstants = class {
-  constructor() {
-  }
+  };
+  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 });
+  };
 };
-/**
- * CSS class prefix for out of the box components.
- */
-__publicField(StyleConstants, "VENDOR_CSS_CLASS_PREFIX", "asgardeo");
-var StyleConstants_default = StyleConstants;
 
 // src/utils/hasAuthParamsInUrl.ts
 var hasAuthParamsInUrl = (params = window.location.search) => {
@@ -5393,12 +5342,6 @@ var hasAuthParamsInUrl = (params = window.location.search) => {
 };
 var hasAuthParamsInUrl_default = hasAuthParamsInUrl;
 
-// src/utils/withVendorCSSClassPrefix.ts
-var withVendorCSSClassPrefix = (className) => {
-  return `${StyleConstants_default.VENDOR_CSS_CLASS_PREFIX}-${className}`;
-};
-var withVendorCSSClassPrefix_default = withVendorCSSClassPrefix;
-
 // src/AsgardeoBrowserClient.ts
 import { AsgardeoJavaScriptClient } from "@asgardeo/javascript";
 var AsgardeoBrowserClient = class extends AsgardeoJavaScriptClient {
@@ -5427,12 +5370,10 @@ export {
   ResponseType,
   SPAHelper,
   SPAUtils,
-  StyleConstants_default as StyleConstants,
   TOKEN_REQUEST_CONFIG_KEY,
   WebWorkerClass,
   WebWorkerClient,
   hasAuthParamsInUrl_default as hasAuthParamsInUrl,
-  withVendorCSSClassPrefix_default as withVendorCSSClassPrefix,
   workerReceiver
 };
 /*! Bundled license information: