@asgardeo/browser 0.1.0 → 0.1.2

package/dist/index.js

@@ -1919,11 +1919,10 @@ import {
 
 // src/__legacy__/clients/main-thread-client.ts
 import {
-  AsgardeoAuthClient as AsgardeoAuthClient5,
+  AsgardeoAuthClient as AsgardeoAuthClient4,
   OIDCRequestConstants as OIDCRequestConstants3,
-  extractPkceStorageKeyFromState as extractPkceStorageKeyFromState2,
-  initializeApplicationNativeAuthentication,
-  handleApplicationNativeAuthentication
+  extractPkceStorageKeyFromState,
+  initializeEmbeddedSignInFlow
 } from "@asgardeo/javascript";
 
 // src/__legacy__/constants/messages-types.ts
@@ -1994,11 +1993,8 @@ var STATE_QUERY = "state";
 // src/__legacy__/constants/errors.ts
 var ACCESS_TOKEN_INVALID = "Access token is invalid";
 
-// src/__legacy__/helpers/authentication-helper.ts
-import {
-  AsgardeoAuthException,
-  extractPkceStorageKeyFromState
-} from "@asgardeo/javascript";
+// src/__legacy__/helpers/session-management-helper.ts
+import { AsgardeoAuthClient as AsgardeoAuthClient2, OIDCRequestConstants as OIDCRequestConstants2 } from "@asgardeo/javascript";
 
 // src/__legacy__/utils/message-utils.ts
 var MessageUtils = class {
@@ -2212,1316 +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, "_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;
-  }
-  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.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;
-        }
-      }
+// 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._storageManager.setTemporaryDataParameter(CUSTOM_GRANT_CONFIG, JSON.stringify(config));
+    if (_sessionRefreshInterval > -1) {
+      sessionRefreshInterval = setInterval(() => {
+        sendPromptNoneRequest();
+      }, _sessionRefreshInterval * 1e3);
     }
-    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);
-      });
-    } 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._storageManager.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.exchangeToken(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.getUser();
-    } 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._storageManager.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 refreshAccessTokenAutomatically(authenticationHelper) {
+    const shouldRefreshAutomatically = (await this._storageManager.getConfigData())?.periodicTokenRefresh ?? false;
+    if (!shouldRefreshAutomatically) {
+      return;
+    }
+    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 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 (!urlMatches) {
-        matches = false;
-        break;
-      }
-    }
-    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`"
+  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 -1;
   }
-  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(extractPkceStorageKeyFromState(sessionState));
-      await this._authenticationClient.setPKCECode(extractPkceStorageKeyFromState(sessionState), pkce2);
-    } else if (config.storage === "webWorker" /* WebWorker */ && pkce) {
-      await this._authenticationClient.setPKCECode(pkce, state ?? "");
+  async clearRefreshTokenTimeout(timer) {
+    if (timer) {
+      clearTimeout(timer);
+      return;
     }
-    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);
-      });
+    const refreshTimer = await this.getRefreshTimeoutTimer();
+    if (refreshTimer !== -1) {
+      clearTimeout(refreshTimer);
     }
-    return Promise.reject(
-      new AsgardeoAuthException(
-        "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 {
-      const url = await constructSilentSignInUrl(additionalParams);
-      promptNoneIFrame.src = url;
-    } catch (error) {
-      return Promise.reject(error);
+};
+
+// 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;
     }
-    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);
+    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._storageManager.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.isSignedIn()) {
-        this._spaHelper.clearRefreshTokenTimeout();
-        this._spaHelper.refreshAccessTokenAutomatically(this);
-        if (config.enableOIDCSessionManagement) {
-          checkSession();
-        }
-        return Promise.resolve(await this._authenticationClient.getUser());
+    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;
   }
-  async getUser() {
-    return this._authenticationClient.getUser();
-  }
-  async getDecodedIdToken() {
-    return this._authenticationClient.getDecodedIdToken();
+  /**
+   * 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 getDecodedIDPIDToken() {
-    return this._authenticationClient.getDecodedIdToken();
+  /**
+   * Enables the handler.
+   */
+  enableHandler() {
+    HttpClient.isHandlerEnabled = true;
   }
-  async getCrypto() {
-    return this._authenticationClient.getCrypto();
+  /**
+   * Disables the handler.
+   */
+  disableHandler() {
+    HttpClient.isHandlerEnabled = false;
   }
-  async getIdToken() {
-    return this._authenticationClient.getIdToken();
+  /**
+   * 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 getOpenIDProviderEndpoints() {
-    return this._authenticationClient.getOpenIDProviderEndpoints();
+  setHttpRequestStartCallback(callback) {
+    this.requestStartCallback = callback;
   }
-  async getAccessToken() {
-    return this._authenticationClient.getAccessToken();
+  setHttpRequestSuccessCallback(callback) {
+    this.requestSuccessCallback = callback;
   }
-  async getIDPAccessToken() {
-    return (await this._storageManager.getSessionData())?.access_token;
+  setHttpRequestErrorCallback(callback) {
+    this.requestErrorCallback = callback;
   }
-  getStorageManager() {
-    return this._storageManager;
+  setHttpRequestFinishCallback(callback) {
+    this.requestFinishCallback = callback;
   }
-  async isSignedIn() {
-    return this._authenticationClient.isSignedIn();
+};
+__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__/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();
+// 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._storageManager.getConfigData())?.periodicTokenRefresh ?? false;
-    if (!shouldRefreshAutomatically) {
-      return;
-    }
-    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 setData(key, value) {
+    this._data.set(key, value);
   }
-  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 -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 _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 (_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;
-      }
-      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 setHttpRequestFinishCallback = (callback) => {
+    _httpClient?.setHttpRequestFinishCallback && _httpClient.setHttpRequestFinishCallback(callback);
   };
-  const sendPromptNoneRequest = async () => {
-    const rpIFrame = document.getElementById(RP_IFRAME);
-    const promptNoneIFrame = rpIFrame?.contentDocument?.getElementById(
-      PROMPT_NONE_IFRAME
+  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
     );
-    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 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));
       }
-      const promptNoneURL = await _getSignInUrl({
-        prompt: "none",
-        response_mode: "query",
-        state: STATE
+      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: ""
       });
-      promptNoneIFrame.src = promptNoneURL;
+    });
+  };
+  const signOut = async () => {
+    if (await _authenticationClient.isSignedIn() && !_getSignOutURLFromSessionStorage) {
+      location.href = await _authenticationClient.getSignOutUrl();
+    } else {
+      location.href = SPAUtils.getSignOutUrl(config.clientId, instanceID);
     }
+    _spaHelper.clearRefreshTokenTimeout();
+    await _dataLayer.removeOIDCProviderMetaData();
+    await _dataLayer.removeTemporaryData();
+    await _dataLayer.removeSessionData();
+    await _dataLayer.removeSessionStatus();
+    await SPAUtils.waitTillPageRedirect();
+    return true;
   };
-  const 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.clearSession();
-        parent.location.href = signOutURL;
-        window.location.href = "about:blank";
-        await SPAUtils.waitTillPageRedirect();
-        return true;
-      }
+  const enableRetrievingSignOutURLFromSession = (config2) => {
+    if (config2.preventSignOutURLUpdate) {
+      _getSignOutURLFromSessionStorage = true;
     }
-    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 exchangeToken = async (config2) => _authenticationHelper.exchangeToken(config2, enableRetrievingSignOutURLFromSession);
+  const refreshAccessToken = async () => {
+    try {
+      return await _authenticationHelper.refreshAccessToken(enableRetrievingSignOutURLFromSession);
+    } catch (error) {
+      return Promise.reject(error);
     }
-    return {
-      initialize,
-      receivePromptNoneResponse,
-      reset
-    };
   };
-})();
-
-// src/__legacy__/http-client/clients/axios-http-client.ts
-import axios from "axios";
-
-// src/__legacy__/http-client/helpers/decorators.ts
-function staticDecorator() {
-  return (_constructor) => {
+  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));
   };
-}
-
-// 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
+  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
     });
-    if (!this.clientInstance) {
-      this.clientInstance = new HttpClient();
+    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 ?? "")
+      );
     }
-    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)
+    return url;
+  };
+  const trySignInSilently = async (additionalParams, tokenRequestConfig) => _authenticationHelper.trySignInSilently(
+    constructSilentSignInUrl,
+    requestAccessToken,
+    _sessionManagementHelper,
+    additionalParams,
+    tokenRequestConfig
+  );
+  const getUser = async () => _authenticationHelper.getUser();
+  const getDecodedIdToken = async (sessionId) => _authenticationHelper.getDecodedIdToken(sessionId);
+  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__/clients/web-worker-client.ts
+import {
+  AsgardeoAuthClient as AsgardeoAuthClient6,
+  AsgardeoAuthException as AsgardeoAuthException3,
+  OIDCRequestConstants as OIDCRequestConstants4,
+  extractPkceStorageKeyFromState as extractPkceStorageKeyFromState3
+} from "@asgardeo/javascript";
+
+// 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;
+  }
+  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.afterSignInUrl,
+      getAuthzURL
     );
-    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;
   }
-  /**
-   * 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]);
+  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;
     }
-    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();
+  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);
     }
-    throw error;
   }
-  /**
-   * 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();
+  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();
+        }
       }
+      return Promise.reject(error);
     }
-    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;
+  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;
+      }
     }
-    return jwtVerify(
-      idToken,
-      createLocalJWKSet({
-        keys: [jwk]
-      }),
-      jwtVerifyOptions
-    ).then(() => {
-      return Promise.resolve(true);
-    }).catch((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-CRYPTO-UTILS-VJ-IV01",
-          error?.reason ?? JSON.stringify(error),
-          `${error?.code} ${error?.claim}`
+          "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`"
         )
       );
-    });
+    }
   }
-};
-
-// 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();
+  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 (!urlMatches) {
+        matches = false;
+        break;
+      }
+    }
+    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);
+      });
+    } else {
+      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`"
+      );
+    }
   }
-};
-var MainThreadClient = async (instanceID, config, getAuthHelper) => {
-  const _store = initiateStore(config.storage);
-  const _cryptoUtils = new SPACryptoUtils();
-  const _authenticationClient = new AsgardeoAuthClient5();
-  await _authenticationClient.initialize(config, _store, _cryptoUtils, instanceID);
-  const _spaHelper = new SPAHelper(_authenticationClient);
-  const _dataLayer = _authenticationClient.getStorageManager();
-  const _sessionManagementHelper = await SessionManagementHelper(
-    async () => {
-      return _authenticationClient.getSignOutUrl();
-    },
-    config.storage ?? "sessionStorage" /* SessionStorage */,
-    (sessionState) => _dataLayer.setSessionDataParameter(
-      OIDCRequestConstants3.Params.SESSION_STATE,
-      sessionState ?? ""
-    )
-  );
-  const _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.getOpenIDProviderEndpoints();
-    const config2 = await _dataLayer.getConfigData();
-    _authenticationHelper.initializeSessionManger(
-      config2,
-      oidcEndpoints,
-      async () => (await _authenticationClient.getUserSession()).sessionState,
-      async (params) => _authenticationClient.getSignInUrl(params),
-      _sessionManagementHelper
+  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 ?? "");
+    }
+    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."
+      )
     );
-  };
-  const shouldStopAuthn = async () => {
-    return await _sessionManagementHelper.receivePromptNoneResponse(async (sessionState) => {
-      await _dataLayer.setSessionDataParameter(
-        OIDCRequestConstants3.Params.SESSION_STATE,
-        sessionState ?? ""
-      );
-      return;
-    });
-  };
-  const setSessionStatus = async (sessionStatus) => {
-    await _dataLayer.setSessionStatus(sessionStatus);
-  };
-  const signIn = async (signInConfig, authorizationCode, sessionState, state, tokenRequestConfig) => {
-    if (signInConfig["flow"]) {
-      return handleApplicationNativeAuthentication({
-        url: signInConfig["flow"]["requestConfig"]["url"],
-        payload: signInConfig["flow"]["payload"]
+  }
+  async trySignInSilently(constructSilentSignInUrl, requestAccessToken, sessionManagementHelper, additionalParams, tokenRequestConfig) {
+    if (SPAUtils.isInitializedSilentSignIn()) {
+      await sessionManagementHelper.receivePromptNoneResponse();
+      return Promise.resolve({
+        allowedScopes: "",
+        displayName: "",
+        email: "",
+        sessionState: "",
+        sub: "",
+        tenantDomain: "",
+        username: ""
       });
     }
-    const basicUserInfo = await _authenticationHelper.handleSignIn(shouldStopAuthn, checkSession, void 0);
-    if (basicUserInfo) {
-      return basicUserInfo;
-    } else {
-      let resolvedAuthorizationCode;
-      let resolvedSessionState;
-      let resolvedState;
-      let resolvedTokenRequestConfig = { params: {} };
-      if (config?.responseMode === "form_post" && authorizationCode) {
-        resolvedAuthorizationCode = authorizationCode;
-        resolvedSessionState = sessionState ?? "";
-        resolvedState = state ?? "";
-      } else {
-        resolvedAuthorizationCode = new URL(window.location.href).searchParams.get(OIDCRequestConstants3.Params.AUTHORIZATION_CODE) ?? "";
-        resolvedSessionState = new URL(window.location.href).searchParams.get(OIDCRequestConstants3.Params.SESSION_STATE) ?? "";
-        resolvedState = new URL(window.location.href).searchParams.get(OIDCRequestConstants3.Params.STATE) ?? "";
-        SPAUtils.removeAuthorizationCode();
-      }
-      if (resolvedAuthorizationCode && resolvedState) {
-        setSessionStatus("true");
-        const storedTokenRequestConfig = await _dataLayer.getTemporaryDataParameter(TOKEN_REQUEST_CONFIG_KEY);
-        if (storedTokenRequestConfig && typeof storedTokenRequestConfig === "string") {
-          resolvedTokenRequestConfig = JSON.parse(storedTokenRequestConfig);
-        }
-        return requestAccessToken(
-          resolvedAuthorizationCode,
-          resolvedSessionState,
-          resolvedState,
-          resolvedTokenRequestConfig
-        );
-      }
-      return _authenticationClient.getSignInUrl(signInConfig).then(async (url) => {
-        if (config.storage === "browserMemory" /* BrowserMemory */ && config.enablePKCE) {
-          const pkceKey = extractPkceStorageKeyFromState2(resolvedState);
-          SPAUtils.setPKCE(pkceKey, await _authenticationClient.getPKCECode(resolvedState));
-        }
-        if (tokenRequestConfig) {
-          _dataLayer.setTemporaryDataParameter(TOKEN_REQUEST_CONFIG_KEY, JSON.stringify(tokenRequestConfig));
+    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);
+    }
+    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 (signInConfig["response_mode"] === "direct") {
-          const authorizeUrl = new URL(url);
-          return initializeApplicationNativeAuthentication({
-            url: `${authorizeUrl.origin}${authorizeUrl.pathname}`,
-            payload: Object.fromEntries(authorizeUrl.searchParams.entries())
+        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);
           });
-        } else {
-          location.href = url;
         }
-        await SPAUtils.waitTillPageRedirect();
-        return Promise.resolve({
-          allowedScopes: "",
-          displayName: "",
-          email: "",
-          sessionState: "",
-          sub: "",
-          tenantDomain: "",
-          username: ""
-        });
+      };
+      window.addEventListener("message", listenToPromptNoneIFrame);
+    });
+  }
+  async handleSignIn(shouldStopAuthn, checkSession, tryRetrievingUserInfo) {
+    const config = await this._storageManager.getConfigData();
+    if (await shouldStopAuthn()) {
+      return Promise.resolve({
+        allowedScopes: "",
+        displayName: "",
+        email: "",
+        sessionState: "",
+        sub: "",
+        tenantDomain: "",
+        username: ""
       });
     }
-  };
-  const signOut = async () => {
-    if (await _authenticationClient.isSignedIn() && !_getSignOutURLFromSessionStorage) {
-      location.href = await _authenticationClient.getSignOutUrl();
-    } else {
-      location.href = SPAUtils.getSignOutUrl(config.clientId, instanceID);
-    }
-    _spaHelper.clearRefreshTokenTimeout();
-    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;
+    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());
+      }
     }
-  };
-  const exchangeToken = async (config2) => {
-    return await _authenticationHelper.exchangeToken(config2, enableRetrievingSignOutURLFromSession);
-  };
-  const refreshAccessToken = async () => {
-    try {
-      return await _authenticationHelper.refreshAccessToken(enableRetrievingSignOutURLFromSession);
-    } catch (error) {
-      return Promise.reject(error);
+    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 ?? "");
     }
-  };
-  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.getSignInUrl({
-      prompt: "none",
-      state: SILENT_SIGN_IN_STATE,
-      ...additionalParams
-    });
-    const urlObject = new URL(urlString);
-    urlObject.searchParams.set("response_mode", "query");
-    const url = urlObject.toString();
-    if (config2.storage === "browserMemory" /* BrowserMemory */ && config2.enablePKCE) {
-      const state = urlObject.searchParams.get(OIDCRequestConstants3.Params.STATE);
-      SPAUtils.setPKCE(
-        extractPkceStorageKeyFromState2(state ?? ""),
-        await _authenticationClient.getPKCECode(state ?? "")
-      );
+    if (config.storage === "webWorker" /* WebWorker */ && tryRetrievingUserInfo) {
+      const basicUserInfo = await tryRetrievingUserInfo();
+      if (basicUserInfo) {
+        return basicUserInfo;
+      }
     }
-    return url;
-  };
-  const trySignInSilently = async (additionalParams, tokenRequestConfig) => {
-    return await _authenticationHelper.trySignInSilently(
-      constructSilentSignInUrl,
-      requestAccessToken,
-      _sessionManagementHelper,
-      additionalParams,
-      tokenRequestConfig
-    );
-  };
-  const getUser = async () => {
-    return _authenticationHelper.getUser();
-  };
-  const getDecodedIdToken = async () => {
-    return _authenticationHelper.getDecodedIdToken();
-  };
-  const getCrypto = async () => {
-    return _authenticationHelper.getCrypto();
-  };
-  const getIdToken = async () => {
-    return _authenticationHelper.getIdToken();
-  };
-  const getOpenIDProviderEndpoints = async () => {
-    return _authenticationHelper.getOpenIDProviderEndpoints();
-  };
-  const getAccessToken = async () => {
-    return _authenticationHelper.getAccessToken();
-  };
-  const getStorageManager = async () => {
-    return _authenticationHelper.getStorageManager();
-  };
-  const getConfigData = async () => {
-    return await _dataLayer.getConfigData();
-  };
-  const isSignedIn = async () => {
-    return _authenticationHelper.isSignedIn();
-  };
-  const isSessionActive = async () => {
-    return await _dataLayer.getSessionStatus() === "true";
-  };
-  const reInitialize = async (newConfig) => {
-    const existingConfig = await _dataLayer.getConfigData();
-    const isCheckSessionIframeDifferent = !(existingConfig && existingConfig.endpoints && existingConfig.endpoints.checkSessionIframe && newConfig && newConfig.endpoints && newConfig.endpoints.checkSessionIframe && existingConfig.endpoints.checkSessionIframe === newConfig.endpoints.checkSessionIframe);
-    const config2 = { ...existingConfig, ...newConfig };
-    await _authenticationClient.reInitialize(config2);
-    if (config2.enableOIDCSessionManagement && isCheckSessionIframeDifferent) {
-      _sessionManagementHelper.reset();
-      checkSession();
+    return 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()}`
+        };
+      }
     }
-  };
-  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
-  };
+  }
+  async getUser() {
+    return this._authenticationClient.getUser();
+  }
+  async getDecodedIdToken(sessionId) {
+    return this._authenticationClient.getDecodedIdToken(sessionId);
+  }
+  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 AsgardeoAuthClient6,
-  AsgardeoAuthException as AsgardeoAuthException3,
-  OIDCRequestConstants as OIDCRequestConstants4,
-  extractPkceStorageKeyFromState as extractPkceStorageKeyFromState3
-} from "@asgardeo/javascript";
 var initiateStore2 = (store) => {
   switch (store) {
     case "localStorage" /* LocalStorage */:
@@ -3927,7 +3883,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
       return Promise.reject(error);
     });
   };
-  const getDecodedIdToken = () => {
+  const getDecodedIdToken = (sessionId) => {
     const message = {
       type: GET_DECODED_ID_TOKEN
     };
@@ -4047,7 +4003,7 @@ var WebWorkerClient = async (instanceID, config, webWorker, getAuthHelper) => {
 
 // src/__legacy__/client.ts
 var DefaultConfig = {
-  autoLogoutOnTokenRefreshError: true,
+  autoLogoutOnTokenRefreshError: false,
   checkSessionInterval: 3,
   enableOIDCSessionManagement: false,
   periodicTokenRefresh: false,
@@ -4626,9 +4582,9 @@ var _AsgardeoSPAClient = class _AsgardeoSPAClient {
    *
    * @preserve
    */
-  async getDecodedIdToken() {
+  async getDecodedIdToken(sessionId) {
     await this._validateMethod();
-    return this._client?.getDecodedIdToken();
+    return this._client?.getDecodedIdToken(sessionId);
   }
   /**
    * This method returns the IsomorphicCrypto instance.
@@ -5106,8 +5062,8 @@ var WebWorkerCore = async (config, getAuthHelper) => {
   const getUser = async () => {
     return _authenticationHelper.getUser();
   };
-  const getDecodedIdToken = async () => {
-    return _authenticationHelper.getDecodedIdToken();
+  const getDecodedIdToken = async (sessionId) => {
+    return _authenticationHelper.getDecodedIdToken(sessionId);
   };
   const getCrypto = async () => {
     return _authenticationHelper.getCrypto();
@@ -5379,17 +5335,6 @@ var workerReceiver = (getAuthHelper) => {
   };
 };
 
-// src/constants/StyleConstants.ts
-var StyleConstants = class {
-  constructor() {
-  }
-};
-/**
- * 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) => {
   const MATCHER = /[?&]code=[^&]+/;
@@ -5397,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 {
@@ -5411,6 +5350,73 @@ var AsgardeoBrowserClient_default = AsgardeoBrowserClient;
 
 // src/index.ts
 export * from "@asgardeo/javascript";
+
+// src/theme/themeDetection.ts
+var detectThemeMode = (mode, config = {}) => {
+  const {
+    darkClass = "dark",
+    lightClass = "light",
+    targetElement = typeof document !== "undefined" ? document.documentElement : null
+  } = config;
+  if (mode === "light") return "light";
+  if (mode === "dark") return "dark";
+  if (mode === "system") {
+    if (typeof window !== "undefined" && window.matchMedia) {
+      return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+    }
+    return "light";
+  }
+  if (mode === "class") {
+    if (!targetElement) {
+      console.warn("ThemeDetection: targetElement is required for class-based detection, falling back to light mode");
+      return "light";
+    }
+    const classList = targetElement.classList;
+    if (classList.contains(darkClass)) {
+      return "dark";
+    }
+    if (classList.contains(lightClass)) {
+      return "light";
+    }
+    return "light";
+  }
+  return "light";
+};
+var createClassObserver = (targetElement, callback, config = {}) => {
+  const { darkClass = "dark", lightClass = "light" } = config;
+  const observer = new MutationObserver((mutations) => {
+    mutations.forEach((mutation) => {
+      if (mutation.type === "attributes" && mutation.attributeName === "class") {
+        const classList = targetElement.classList;
+        if (classList.contains(darkClass)) {
+          callback(true);
+        } else if (classList.contains(lightClass)) {
+          callback(false);
+        }
+      }
+    });
+  });
+  observer.observe(targetElement, {
+    attributes: true,
+    attributeFilter: ["class"]
+  });
+  return observer;
+};
+var createMediaQueryListener = (callback) => {
+  if (typeof window === "undefined" || !window.matchMedia) {
+    return null;
+  }
+  const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+  const handleChange = (e) => {
+    callback(e.matches);
+  };
+  if (mediaQuery.addEventListener) {
+    mediaQuery.addEventListener("change", handleChange);
+  } else {
+    mediaQuery.addListener(handleChange);
+  }
+  return mediaQuery;
+};
 export {
   AsgardeoBrowserClient_default as AsgardeoBrowserClient,
   AsgardeoSPAClient,
@@ -5431,12 +5437,13 @@ export {
   ResponseType,
   SPAHelper,
   SPAUtils,
-  StyleConstants_default as StyleConstants,
   TOKEN_REQUEST_CONFIG_KEY,
   WebWorkerClass,
   WebWorkerClient,
+  createClassObserver,
+  createMediaQueryListener,
+  detectThemeMode,
   hasAuthParamsInUrl_default as hasAuthParamsInUrl,
-  withVendorCSSClassPrefix_default as withVendorCSSClassPrefix,
   workerReceiver
 };
 /*! Bundled license information: