@asgardeo/javascript 0.0.1

package/dist/cjs/index.js

@@ -0,0 +1,2227 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ASGARDEO_SESSION_ACTIVE: () => ASGARDEO_SESSION_ACTIVE,
+  AsgardeoAPIError: () => AsgardeoAPIError,
+  AsgardeoAuthClient: () => AsgardeoAuthClient,
+  AsgardeoAuthException: () => AsgardeoAuthException,
+  AsgardeoError: () => AsgardeoError,
+  AsgardeoJavaScriptClient: () => AsgardeoJavaScriptClient_default,
+  AsgardeoRuntimeError: () => AsgardeoRuntimeError,
+  DataLayer: () => DataLayer,
+  IsomorphicCrypto: () => IsomorphicCrypto,
+  OIDCRequestConstants: () => OIDCRequestConstants_default,
+  ResponseMode: () => ResponseMode,
+  TokenConstants: () => TokenConstants_default,
+  WellKnownSchemaIds: () => WellKnownSchemaIds,
+  createTheme: () => createTheme_default,
+  extractPkceStorageKeyFromState: () => extractPkceStorageKeyFromState_default,
+  extractUserClaimsFromIdToken: () => extractUserClaimsFromIdToken_default,
+  getUserInfo: () => getUserInfo_default,
+  removeTrailingSlash: () => removeTrailingSlash_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants/PKCEConstants.ts
+var PKCEConstants = {
+  /**
+   * Storage-related constants for managing PKCE state
+   */
+  Storage: {
+    /**
+     * Collection of storage keys used in PKCE implementation
+     */
+    StorageKeys: {
+      /**
+       * Key used to store the PKCE code verifier in temporary storage.
+       * The code verifier is a cryptographically random string that is
+       * used to generate the code challenge.
+       */
+      CODE_VERIFIER: "pkce_code_verifier",
+      /**
+       * Separator used in storage keys to create unique identifiers
+       * by combining different parts of the key.
+       */
+      SEPARATOR: "#"
+    }
+  }
+};
+var PKCEConstants_default = PKCEConstants;
+
+// src/utils/extractPkceStorageKeyFromState.ts
+var extractPkceStorageKeyFromState = (state) => {
+  const index = parseInt(state.split("request_")[1]);
+  return `${PKCEConstants_default.Storage.StorageKeys.CODE_VERIFIER}${PKCEConstants_default.Storage.StorageKeys.SEPARATOR}${index}`;
+};
+var extractPkceStorageKeyFromState_default = extractPkceStorageKeyFromState;
+
+// src/utils/generateStateParamForRequestCorrelation.ts
+var generateStateParamForRequestCorrelation = (pkceKey, state) => {
+  const index = parseInt(pkceKey.split(PKCEConstants_default.Storage.StorageKeys.SEPARATOR)[1]);
+  return state ? `${state}_request_${index}` : `request_${index}`;
+};
+var generateStateParamForRequestCorrelation_default = generateStateParamForRequestCorrelation;
+
+// src/__legacy__/exception/exception.ts
+var AsgardeoAuthException = class {
+  constructor(code, name, message) {
+    __publicField(this, "name");
+    __publicField(this, "code");
+    __publicField(this, "message");
+    this.message = message;
+    this.name = name;
+    this.code = code;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/utils/extractTenantDomainFromIdTokenPayload.ts
+var extractTenantDomainFromIdTokenPayload = (payload, subjectSeparator = "@") => {
+  const uid = payload.sub;
+  if (!uid) return "";
+  const tokens = uid.split(subjectSeparator);
+  return tokens.length > 2 ? tokens[tokens.length - 1] : "";
+};
+var extractTenantDomainFromIdTokenPayload_default = extractTenantDomainFromIdTokenPayload;
+
+// src/utils/extractUserClaimsFromIdToken.ts
+var extractUserClaimsFromIdToken = (payload) => {
+  const filteredPayload = { ...payload };
+  const protocolClaims = [
+    "iss",
+    "aud",
+    "exp",
+    "iat",
+    "acr",
+    "amr",
+    "azp",
+    "auth_time",
+    "nonce",
+    "c_hash",
+    "at_hash",
+    "nbf",
+    "isk",
+    "sid",
+    "jti",
+    "sub"
+  ];
+  protocolClaims.forEach((claim) => {
+    delete filteredPayload[claim];
+  });
+  const userClaims = {};
+  Object.entries(filteredPayload).forEach(([key, value]) => {
+    const camelCasedKey = key.split("_").map((part, i) => i === 0 ? part : part[0].toUpperCase() + part.slice(1)).join("");
+    userClaims[camelCasedKey] = value;
+  });
+  return userClaims;
+};
+var extractUserClaimsFromIdToken_default = extractUserClaimsFromIdToken;
+
+// src/constants/ScopeConstants.ts
+var ScopeConstants = {
+  /**
+   * The base OpenID Connect scope.
+   * Required for all OpenID Connect flows. Indicates that the client
+   * is initiating an OpenID Connect authentication request.
+   */
+  OPENID: "openid"
+};
+var ScopeConstants_default = ScopeConstants;
+
+// src/constants/OIDCDiscoveryConstants.ts
+var OIDCDiscoveryConstants = {
+  /**
+   * Collection of standard OIDC endpoint paths used for authentication flows.
+   * These endpoints are relative paths that should be appended to the base URL
+   * of your identity provider.
+   */
+  Endpoints: {
+    /**
+     * Authorization endpoint for initiating the OAuth2/OIDC flow.
+     * This endpoint is used to request authorization and receive an authorization code.
+     */
+    AUTHORIZATION: "/oauth2/authorize",
+    /**
+     * Session check iframe endpoint for session management.
+     * Used to monitor the user's session state through a hidden iframe.
+     */
+    SESSION_IFRAME: "/oidc/checksession",
+    /**
+     * End session endpoint for logout functionality.
+     * Used to terminate the user's session and perform logout operations.
+     */
+    END_SESSION: "/oidc/logout",
+    /**
+     * Token issuer endpoint.
+     * The endpoint that issues OAuth2/OIDC tokens.
+     */
+    ISSUER: "/oauth2/token",
+    /**
+     * JSON Web Key Set endpoint for key validation.
+     * Provides the public keys used to verify token signatures.
+     */
+    JWKS: "/oauth2/jwks",
+    /**
+     * Token revocation endpoint.
+     * Used to invalidate access or refresh tokens before they expire.
+     */
+    REVOCATION: "/oauth2/revoke",
+    /**
+     * Token endpoint for obtaining access tokens.
+     * Used to exchange authorization codes for access tokens and refresh tokens.
+     */
+    TOKEN: "/oauth2/token",
+    /**
+     * UserInfo endpoint for obtaining user claims.
+     * Provides authenticated user information when called with a valid access token.
+     */
+    USERINFO: "/oauth2/userinfo"
+  },
+  /**
+   * Storage related constants used for maintaining OIDC state.
+   * These constants define the keys used to store OIDC-related data
+   * in the browser's storage mechanisms.
+   */
+  Storage: {
+    /**
+     * Storage keys for various OIDC endpoints and configurations.
+     * These keys are used to store endpoint URLs and configuration
+     * states in the browser's storage.
+     */
+    StorageKeys: {
+      /**
+       * Collection of storage keys for OIDC endpoints.
+       * These keys are used to store the discovered endpoint URLs
+       * from the OpenID Provider's configuration.
+       */
+      Endpoints: {
+        /**
+         * Storage key for the authorization endpoint URL.
+         * Used to store the URL where authorization requests should be sent.
+         */
+        AUTHORIZATION: "authorization_endpoint",
+        /**
+         * Storage key for the token endpoint URL.
+         * Used to store the URL where token requests should be sent.
+         */
+        TOKEN: "token_endpoint",
+        /**
+         * Storage key for the revocation endpoint URL.
+         * Used to store the URL where token revocation requests should be sent.
+         */
+        REVOCATION: "revocation_endpoint",
+        /**
+         * Storage key for the end session endpoint URL.
+         * Used to store the URL where logout requests should be sent.
+         */
+        END_SESSION: "end_session_endpoint",
+        /**
+         * Storage key for the JWKS URI endpoint URL.
+         * Used to store the URL where JSON Web Key Sets can be retrieved.
+         */
+        JWKS: "jwks_uri",
+        /**
+         * Storage key for the session check iframe URL.
+         * Used to store the URL of the iframe used for session state monitoring.
+         */
+        SESSION_IFRAME: "check_session_iframe",
+        /**
+         * Storage key for the issuer identifier URL.
+         * Used to store the URL that identifies the OpenID Provider.
+         */
+        ISSUER: "issuer",
+        /**
+         * Storage key for the userinfo endpoint URL.
+         * Used to store the URL where user information can be retrieved.
+         */
+        USERINFO: "userinfo_endpoint"
+      },
+      /**
+       * Flag to track if OpenID Provider configuration is initiated.
+       * Used to determine if the OIDC discovery process has been started.
+       * This helps prevent duplicate initialization attempts.
+       */
+      OPENID_PROVIDER_CONFIG_INITIATED: "op_config_initiated"
+    }
+  }
+};
+var OIDCDiscoveryConstants_default = OIDCDiscoveryConstants;
+
+// src/constants/TokenExchangeConstants.ts
+var TokenExchangeConstants = {
+  /**
+   * Collection of placeholder strings used in token exchange operations.
+   * These placeholders are replaced with actual values when processing
+   * token exchange requests.
+   */
+  Placeholders: {
+    /**
+     * Placeholder for the token value in exchange requests.
+     * Usually replaced with an access token or refresh token.
+     */
+    TOKEN: "{{token}}",
+    /**
+     * Placeholder for the username in token exchange operations.
+     * Used when user identity needs to be included in the exchange.
+     */
+    USERNAME: "{{username}}",
+    /**
+     * Placeholder for OAuth scopes in token exchange requests.
+     * Replaced with space-separated scope strings.
+     */
+    SCOPE: "{{scope}}",
+    /**
+     * Placeholder for client ID in token exchange operations.
+     * Required for client authentication.
+     */
+    CLIENT_ID: "{{clientID}}",
+    /**
+     * Placeholder for client secret in token exchange operations.
+     * Used for client authentication in confidential client flows.
+     */
+    CLIENT_SECRET: "{{clientSecret}}"
+  }
+};
+var TokenExchangeConstants_default = TokenExchangeConstants;
+
+// src/__legacy__/helpers/authentication-helper.ts
+var AuthenticationHelper = class {
+  constructor(dataLayer, cryptoHelper) {
+    __publicField(this, "_dataLayer");
+    __publicField(this, "_config");
+    __publicField(this, "_oidcProviderMetaData");
+    __publicField(this, "_cryptoHelper");
+    this._dataLayer = dataLayer;
+    this._config = async () => await this._dataLayer.getConfigData();
+    this._oidcProviderMetaData = async () => await this._dataLayer.getOIDCProviderMetaData();
+    this._cryptoHelper = cryptoHelper;
+  }
+  async resolveEndpoints(response) {
+    const oidcProviderMetaData = {};
+    const configData = await this._config();
+    configData.endpoints && Object.keys(configData.endpoints).forEach((endpointName) => {
+      const snakeCasedName = endpointName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+      oidcProviderMetaData[snakeCasedName] = configData?.endpoints ? configData.endpoints[endpointName] : "";
+    });
+    return { ...response, ...oidcProviderMetaData };
+  }
+  async resolveEndpointsExplicitly() {
+    const oidcProviderMetaData = {};
+    const configData = await this._config();
+    const requiredEndpoints = [
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.AUTHORIZATION,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.END_SESSION,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.JWKS,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.SESSION_IFRAME,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.REVOCATION,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.TOKEN,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.ISSUER,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.USERINFO
+    ];
+    const isRequiredEndpointsContains = configData.endpoints ? requiredEndpoints.every((reqEndpointName) => {
+      return configData.endpoints ? Object.keys(configData.endpoints).some((endpointName) => {
+        const snakeCasedName = endpointName.replace(
+          /[A-Z]/g,
+          (letter) => `_${letter.toLowerCase()}`
+        );
+        return snakeCasedName === reqEndpointName;
+      }) : false;
+    }) : false;
+    if (!isRequiredEndpointsContains) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_HELPER-REE-NF01",
+        "Required endpoints missing",
+        "Some or all of the required endpoints are missing in the object passed to the `endpoints` attribute of the`AuthConfig` object."
+      );
+    }
+    configData.endpoints && Object.keys(configData.endpoints).forEach((endpointName) => {
+      const snakeCasedName = endpointName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+      oidcProviderMetaData[snakeCasedName] = configData?.endpoints ? configData.endpoints[endpointName] : "";
+    });
+    return { ...oidcProviderMetaData };
+  }
+  async resolveEndpointsByBaseURL() {
+    const oidcProviderMetaData = {};
+    const configData = await this._config();
+    const baseUrl = configData.baseUrl;
+    if (!baseUrl) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_HELPER_REBO-NF01",
+        "Base URL not defined.",
+        "Base URL is not defined in AuthClient config."
+      );
+    }
+    configData.endpoints && Object.keys(configData.endpoints).forEach((endpointName) => {
+      const snakeCasedName = endpointName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+      oidcProviderMetaData[snakeCasedName] = configData?.endpoints ? configData.endpoints[endpointName] : "";
+    });
+    const defaultEndpoints = {
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.AUTHORIZATION]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.AUTHORIZATION}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.END_SESSION]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.END_SESSION}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.ISSUER]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.ISSUER}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.JWKS]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.JWKS}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.SESSION_IFRAME]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.SESSION_IFRAME}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.REVOCATION]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.REVOCATION}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.TOKEN]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.TOKEN}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.USERINFO]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.USERINFO}`
+    };
+    return { ...defaultEndpoints, ...oidcProviderMetaData };
+  }
+  async validateIdToken(idToken) {
+    const jwksEndpoint = (await this._dataLayer.getOIDCProviderMetaData()).jwks_uri;
+    const configData = await this._config();
+    if (!jwksEndpoint || jwksEndpoint.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS_AUTH_HELPER-VIT-NF01",
+        "JWKS endpoint not found.",
+        "No JWKS endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the JWKS endpoint passed to the SDK is empty."
+      );
+    }
+    let response;
+    try {
+      response = await fetch(jwksEndpoint, {
+        credentials: configData.sendCookiesInRequests ? "include" : "same-origin"
+      });
+    } catch (error) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_HELPER-VIT-NE02",
+        "Request to jwks endpoint failed.",
+        error ?? "The request sent to get the jwks from the server failed."
+      );
+    }
+    if (response.status !== 200 || !response.ok) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_HELPER-VIT-HE03",
+        `Invalid response status received for jwks request (${response.statusText}).`,
+        await response.json()
+      );
+    }
+    const issuer = (await this._oidcProviderMetaData()).issuer;
+    const { keys } = await response.json();
+    const jwk = await this._cryptoHelper.getJWKForTheIdToken(idToken.split(".")[0], keys);
+    return this._cryptoHelper.isValidIdToken(
+      idToken,
+      jwk,
+      (await this._config()).clientID,
+      issuer ?? "",
+      this._cryptoHelper.decodeIDToken(idToken).sub,
+      (await this._config()).clockTolerance,
+      (await this._config()).validateIDTokenIssuer ?? true
+    );
+  }
+  getAuthenticatedUserInfo(idToken) {
+    const payload = this._cryptoHelper.decodeIDToken(idToken);
+    const tenantDomain = extractTenantDomainFromIdTokenPayload_default(payload);
+    const username = payload?.["username"] ?? "";
+    const givenName = payload?.["given_name"] ?? "";
+    const familyName = payload?.["family_name"] ?? "";
+    const fullName = givenName && familyName ? `${givenName} ${familyName}` : givenName ? givenName : familyName ? familyName : "";
+    const displayName = payload.preferred_username ?? fullName;
+    return {
+      displayName,
+      tenantDomain,
+      username,
+      ...extractUserClaimsFromIdToken_default(payload)
+    };
+  }
+  async replaceCustomGrantTemplateTags(text, userID) {
+    let scope = ScopeConstants_default.OPENID;
+    const configData = await this._config();
+    const sessionData = await this._dataLayer.getSessionData(userID);
+    if (configData.scope && configData.scope.length > 0) {
+      if (!configData.scope.includes(ScopeConstants_default.OPENID)) {
+        configData.scope.push(ScopeConstants_default.OPENID);
+      }
+      scope = configData.scope.join(" ");
+    }
+    return text.replace(TokenExchangeConstants_default.Placeholders.TOKEN, sessionData.access_token).replace(
+      TokenExchangeConstants_default.Placeholders.USERNAME,
+      this.getAuthenticatedUserInfo(sessionData.id_token).username
+    ).replace(TokenExchangeConstants_default.Placeholders.SCOPE, scope).replace(TokenExchangeConstants_default.Placeholders.CLIENT_ID, configData.clientID).replace(TokenExchangeConstants_default.Placeholders.CLIENT_SECRET, configData.clientSecret ?? "");
+  }
+  async clearUserSessionData(userID) {
+    await this._dataLayer.removeTemporaryData(userID);
+    await this._dataLayer.removeSessionData(userID);
+  }
+  async handleTokenResponse(response, userID) {
+    if (response.status !== 200 || !response.ok) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_HELPER-HTR-NE01",
+        `Invalid response status received for token request (${response.statusText}).`,
+        await response.json()
+      );
+    }
+    const parsedResponse = await response.json();
+    parsedResponse.created_at = (/* @__PURE__ */ new Date()).getTime();
+    const shouldValidateIdToken = (await this._config()).validateIDToken;
+    if (shouldValidateIdToken) {
+      return this.validateIdToken(parsedResponse.id_token).then(async () => {
+        await this._dataLayer.setSessionData(parsedResponse, userID);
+        const tokenResponse = {
+          accessToken: parsedResponse.access_token,
+          createdAt: parsedResponse.created_at,
+          expiresIn: parsedResponse.expires_in,
+          idToken: parsedResponse.id_token,
+          refreshToken: parsedResponse.refresh_token,
+          scope: parsedResponse.scope,
+          tokenType: parsedResponse.token_type
+        };
+        return Promise.resolve(tokenResponse);
+      });
+    } else {
+      const tokenResponse = {
+        accessToken: parsedResponse.access_token,
+        createdAt: parsedResponse.created_at,
+        expiresIn: parsedResponse.expires_in,
+        idToken: parsedResponse.id_token,
+        refreshToken: parsedResponse.refresh_token,
+        scope: parsedResponse.scope,
+        tokenType: parsedResponse.token_type
+      };
+      await this._dataLayer.setSessionData(parsedResponse, userID);
+      return Promise.resolve(tokenResponse);
+    }
+  }
+};
+
+// src/utils/generatePkceStorageKey.ts
+var generatePkceStorageKey = (tempStore) => {
+  const keys = [];
+  Object.keys(tempStore).forEach((key) => {
+    if (key.startsWith(PKCEConstants_default.Storage.StorageKeys.CODE_VERIFIER)) {
+      keys.push(key);
+    }
+  });
+  const lastKey = keys.sort().pop();
+  const index = parseInt(lastKey?.split(PKCEConstants_default.Storage.StorageKeys.SEPARATOR)[1] ?? "-1");
+  return `${PKCEConstants_default.Storage.StorageKeys.CODE_VERIFIER}${PKCEConstants_default.Storage.StorageKeys.SEPARATOR}${index + 1}`;
+};
+var generatePkceStorageKey_default = generatePkceStorageKey;
+
+// src/constants/OIDCRequestConstants.ts
+var OIDCRequestConstants = {
+  Params: {
+    /**
+     * The authorization code returned from the authorization endpoint.
+     * Used in the authorization code flow.
+     */
+    AUTHORIZATION_CODE: "code",
+    /**
+     * Session state parameter used for session management between the client and the OP.
+     */
+    SESSION_STATE: "session_state",
+    /**
+     * State parameter used to maintain state between the request and the callback.
+     * Helps in preventing CSRF attacks.
+     */
+    STATE: "state",
+    /**
+     * Indicates whether sign-out was successful during the end-session flow.
+     * May be returned by the OP after a logout request.
+     */
+    SIGN_OUT_SUCCESS: "sign_out_success"
+  },
+  /**
+   * Sign-out related constants for managing the end-session flow in OIDC.
+   */
+  SignOut: {
+    /**
+     * Storage-related constants for managing sign-out state.
+     */
+    Storage: {
+      /**
+       * Collection of storage keys used in sign-out implementation
+       */
+      StorageKeys: {
+        /**
+         * Storage key for the sign-out URL.
+         * Used to store the complete URL where the user should be redirected after
+         * completing the OIDC logout process.
+         */
+        SIGN_OUT_URL: "sign_out_url"
+      }
+    }
+  }
+};
+var OIDCRequestConstants_default = OIDCRequestConstants;
+
+// src/constants/TokenConstants.ts
+var TokenConstants = {
+  /**
+   * Token signature validation constants.
+   * Contains configurations related to token signature verification.
+   */
+  SignatureValidation: {
+    /**
+     * Fallback array of supported signature algorithms for OIDC token validation.
+     * These values are used when the supported algorithms cannot be retrieved from
+     * the .well-known/openid-configuration endpoint.
+     *
+     * Supported algorithms:
+     * - `RS256` - RSASSA-PKCS1-v1_5 using SHA-256
+     * - `RS512` - RSASSA-PKCS1-v1_5 using SHA-512
+     * - `RS384` - RSASSA-PKCS1-v1_5 using SHA-384
+     * - `PS256` - RSASSA-PSS using SHA-256 and MGF1 with SHA-256
+     */
+    SUPPORTED_ALGORITHMS: ["RS256", "RS512", "RS384", "PS256"]
+  },
+  /**
+   * Storage-related constants for OIDC tokens.
+   * Contains keys used to store token-related data in browser storage.
+   */
+  Storage: {
+    /**
+     * Collection of storage keys used in token management.
+     * These keys are used to store and retrieve token-related
+     * information from browser storage.
+     */
+    StorageKeys: {
+      /**
+       * Key used to store the refresh token timer identifier.
+       * This timer is used to schedule token refresh operations
+       * before the current token expires.
+       */
+      REFRESH_TOKEN_TIMER: "refresh_token_timer"
+    }
+  }
+};
+var TokenConstants_default = TokenConstants;
+
+// src/IsomorphicCrypto.ts
+var IsomorphicCrypto = class {
+  constructor(cryptoUtils) {
+    __publicField(this, "_cryptoUtils");
+    this._cryptoUtils = cryptoUtils;
+  }
+  /**
+   * Generate code verifier.
+   *
+   * @returns code verifier.
+   */
+  getCodeVerifier() {
+    return this._cryptoUtils.base64URLEncode(this._cryptoUtils.generateRandomBytes(32));
+  }
+  /**
+   * Derive code challenge from the code verifier.
+   *
+   * @param verifier - Code verifier.
+   *
+   * @returns - code challenge.
+   */
+  getCodeChallenge(verifier) {
+    return this._cryptoUtils.base64URLEncode(this._cryptoUtils.hashSha256(verifier));
+  }
+  /**
+   * Get JWK used for the id_token
+   *
+   * @param jwtHeader - header of the id_token.
+   * @param keys - jwks response.
+   *
+   * @returns public key.
+   *
+   * @throws
+   */
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  getJWKForTheIdToken(jwtHeader, keys) {
+    const headerJSON = JSON.parse(this._cryptoUtils.base64URLDecode(jwtHeader));
+    for (const key of keys) {
+      if (headerJSON["kid"] === key.kid) {
+        return key;
+      }
+    }
+    throw new AsgardeoAuthException(
+      "JS-CRYPTO_UTIL-GJFTIT-IV01",
+      "kid not found.",
+      "Failed to find the 'kid' specified in the id_token. 'kid' found in the header : " + headerJSON["kid"] + ", Expected values: " + keys.map((key) => key.kid).join(", ")
+    );
+  }
+  /**
+   * Verify id token.
+   *
+   * @param idToken - id_token received from the IdP.
+   * @param jwk - public key used for signing.
+   * @param clientID - app identification.
+   * @param issuer - id_token issuer.
+   * @param username - Username.
+   * @param clockTolerance - Allowed leeway for id_tokens (in seconds).
+   *
+   * @returns whether the id_token is valid.
+   *
+   * @throws
+   */
+  isValidIdToken(idToken, jwk, clientID, issuer, username, clockTolerance, validateJwtIssuer) {
+    return this._cryptoUtils.verifyJwt(
+      idToken,
+      jwk,
+      TokenConstants_default.SignatureValidation.SUPPORTED_ALGORITHMS,
+      clientID,
+      issuer,
+      username,
+      clockTolerance,
+      validateJwtIssuer
+    ).then((response) => {
+      if (response) {
+        return Promise.resolve(true);
+      }
+      return Promise.reject(
+        new AsgardeoAuthException(
+          "JS-CRYPTO_HELPER-IVIT-IV01",
+          "Invalid ID token.",
+          "ID token validation returned false"
+        )
+      );
+    });
+  }
+  /**
+   * This function decodes the payload of an id token and returns it.
+   *
+   * @param idToken - The id token to be decoded.
+   *
+   * @returns - The decoded payload of the id token.
+   *
+   * @throws
+   */
+  decodeIDToken(idToken) {
+    try {
+      const utf8String = this._cryptoUtils.base64URLDecode(idToken.split(".")[1]);
+      const payload = JSON.parse(utf8String);
+      return payload;
+    } catch (error) {
+      throw new AsgardeoAuthException("JS-CRYPTO_UTIL-DIT-IV01", "Decoding ID token failed.", error);
+    }
+  }
+};
+
+// src/__legacy__/core/authentication-core.ts
+var AuthenticationCore = class {
+  constructor(dataLayer, cryptoUtils) {
+    __publicField(this, "_dataLayer");
+    __publicField(this, "_config");
+    __publicField(this, "_oidcProviderMetaData");
+    __publicField(this, "_authenticationHelper");
+    __publicField(this, "_cryptoUtils");
+    __publicField(this, "_cryptoHelper");
+    this._cryptoUtils = cryptoUtils;
+    this._cryptoHelper = new IsomorphicCrypto(cryptoUtils);
+    this._authenticationHelper = new AuthenticationHelper(dataLayer, this._cryptoHelper);
+    this._dataLayer = dataLayer;
+    this._config = async () => await this._dataLayer.getConfigData();
+    this._oidcProviderMetaData = async () => await this._dataLayer.getOIDCProviderMetaData();
+  }
+  async getAuthorizationURLParams(config, userID) {
+    const configData = await this._config();
+    const authorizeRequestParams = /* @__PURE__ */ new Map();
+    authorizeRequestParams.set("response_type", "code");
+    authorizeRequestParams.set("client_id", configData.clientID);
+    let scope = ScopeConstants_default.OPENID;
+    if (configData.scope && configData.scope.length > 0) {
+      if (!configData.scope.includes(ScopeConstants_default.OPENID)) {
+        configData.scope.push(ScopeConstants_default.OPENID);
+      }
+      scope = configData.scope.join(" ");
+    }
+    authorizeRequestParams.set("scope", scope);
+    authorizeRequestParams.set("redirect_uri", configData.signInRedirectURL);
+    if (configData.responseMode) {
+      authorizeRequestParams.set("response_mode", configData.responseMode);
+    }
+    const tempStore = await this._dataLayer.getTemporaryData(userID);
+    const pkceKey = await generatePkceStorageKey_default(tempStore);
+    if (configData.enablePKCE) {
+      const codeVerifier = this._cryptoHelper?.getCodeVerifier();
+      const codeChallenge = this._cryptoHelper?.getCodeChallenge(codeVerifier);
+      await this._dataLayer.setTemporaryDataParameter(pkceKey, codeVerifier, userID);
+      authorizeRequestParams.set("code_challenge_method", "S256");
+      authorizeRequestParams.set("code_challenge", codeChallenge);
+    }
+    if (configData.prompt) {
+      authorizeRequestParams.set("prompt", configData.prompt);
+    }
+    const customParams = config;
+    if (customParams) {
+      for (const [key, value] of Object.entries(customParams)) {
+        if (key != "" && value != "" && key !== OIDCRequestConstants_default.Params.STATE) {
+          authorizeRequestParams.set(key, value.toString());
+        }
+      }
+    }
+    authorizeRequestParams.set(
+      OIDCRequestConstants_default.Params.STATE,
+      generateStateParamForRequestCorrelation_default(
+        pkceKey,
+        customParams ? customParams[OIDCRequestConstants_default.Params.STATE]?.toString() : ""
+      )
+    );
+    return authorizeRequestParams;
+  }
+  async getAuthorizationURL(config, userID) {
+    const authorizeEndpoint = await this._dataLayer.getOIDCProviderMetaDataParameter(
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.AUTHORIZATION
+    );
+    if (!authorizeEndpoint || authorizeEndpoint.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-GAU-NF01",
+        "No authorization endpoint found.",
+        "No authorization endpoint was found in the OIDC provider meta data from the well-known endpoint or the authorization endpoint passed to the SDK is empty."
+      );
+    }
+    const authorizeRequest = new URL(authorizeEndpoint);
+    const authorizeRequestParams = await this.getAuthorizationURLParams(config, userID);
+    for (const [key, value] of authorizeRequestParams.entries()) {
+      authorizeRequest.searchParams.append(key, value);
+    }
+    return authorizeRequest.toString();
+  }
+  async requestAccessToken(authorizationCode, sessionState, state, userID, tokenRequestConfig) {
+    const tokenEndpoint = (await this._oidcProviderMetaData()).token_endpoint;
+    const configData = await this._config();
+    if (!tokenEndpoint || tokenEndpoint.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT1-NF01",
+        "Token endpoint not found.",
+        "No token endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the token endpoint passed to the SDK is empty."
+      );
+    }
+    sessionState && await this._dataLayer.setSessionDataParameter(
+      OIDCRequestConstants_default.Params.SESSION_STATE,
+      sessionState,
+      userID
+    );
+    const body = new URLSearchParams();
+    body.set("client_id", configData.clientID);
+    if (configData.clientSecret && configData.clientSecret.trim().length > 0) {
+      body.set("client_secret", configData.clientSecret);
+    }
+    const code = authorizationCode;
+    body.set("code", code);
+    body.set("grant_type", "authorization_code");
+    body.set("redirect_uri", configData.signInRedirectURL);
+    if (tokenRequestConfig?.params) {
+      Object.entries(tokenRequestConfig.params).forEach(([key, value]) => {
+        body.append(key, value);
+      });
+    }
+    if (configData.enablePKCE) {
+      body.set(
+        "code_verifier",
+        `${await this._dataLayer.getTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), userID)}`
+      );
+      await this._dataLayer.removeTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), userID);
+    }
+    let tokenResponse;
+    try {
+      tokenResponse = await fetch(tokenEndpoint, {
+        body,
+        credentials: configData.sendCookiesInRequests ? "include" : "same-origin",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        method: "POST"
+      });
+    } catch (error) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT1-NE02",
+        "Requesting access token failed",
+        error ?? "The request to get the access token from the server failed."
+      );
+    }
+    if (!tokenResponse.ok) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT1-HE03",
+        `Requesting access token failed with ${tokenResponse.statusText}`,
+        await tokenResponse.json()
+      );
+    }
+    return await this._authenticationHelper.handleTokenResponse(tokenResponse, userID);
+  }
+  async refreshAccessToken(userID) {
+    const tokenEndpoint = (await this._oidcProviderMetaData()).token_endpoint;
+    const configData = await this._config();
+    const sessionData = await this._dataLayer.getSessionData(userID);
+    if (!sessionData.refresh_token) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT2-NF01",
+        "No refresh token found.",
+        "There was no refresh token found. Asgardeo doesn't return a refresh token if the refresh token grant is not enabled."
+      );
+    }
+    if (!tokenEndpoint || tokenEndpoint.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT2-NF02",
+        "No refresh token endpoint found.",
+        "No refresh token endpoint was in the OIDC provider meta data returned by the well-known endpoint or the refresh token endpoint passed to the SDK is empty."
+      );
+    }
+    const body = [];
+    body.push(`client_id=${configData.clientID}`);
+    body.push(`refresh_token=${sessionData.refresh_token}`);
+    body.push("grant_type=refresh_token");
+    if (configData.clientSecret && configData.clientSecret.trim().length > 0) {
+      body.push(`client_secret=${configData.clientSecret}`);
+    }
+    let tokenResponse;
+    try {
+      tokenResponse = await fetch(tokenEndpoint, {
+        body: body.join("&"),
+        credentials: configData.sendCookiesInRequests ? "include" : "same-origin",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        method: "POST"
+      });
+    } catch (error) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT2-NR03",
+        "Refresh access token request failed.",
+        error ?? "The request to refresh the access token failed."
+      );
+    }
+    if (!tokenResponse.ok) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT2-HE04",
+        `Refreshing access token failed with ${tokenResponse.statusText}`,
+        await tokenResponse.json()
+      );
+    }
+    return this._authenticationHelper.handleTokenResponse(tokenResponse, userID);
+  }
+  async revokeAccessToken(userID) {
+    const revokeTokenEndpoint = (await this._oidcProviderMetaData()).revocation_endpoint;
+    const configData = await this._config();
+    if (!revokeTokenEndpoint || revokeTokenEndpoint.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT3-NF01",
+        "No revoke access token endpoint found.",
+        "No revoke access token endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the revoke access token endpoint passed to the SDK is empty."
+      );
+    }
+    const body = [];
+    body.push(`client_id=${configData.clientID}`);
+    body.push(`token=${(await this._dataLayer.getSessionData(userID)).access_token}`);
+    body.push("token_type_hint=access_token");
+    if (configData.clientSecret && configData.clientSecret.trim().length > 0) {
+      body.push(`client_secret=${configData.clientSecret}`);
+    }
+    let response;
+    try {
+      response = await fetch(revokeTokenEndpoint, {
+        body: body.join("&"),
+        credentials: configData.sendCookiesInRequests ? "include" : "same-origin",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        method: "POST"
+      });
+    } catch (error) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT3-NE02",
+        "The request to revoke access token failed.",
+        error ?? "The request sent to revoke the access token failed."
+      );
+    }
+    if (response.status !== 200 || !response.ok) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT3-HE03",
+        `Invalid response status received for revoke access token request (${response.statusText}).`,
+        await response.json()
+      );
+    }
+    this._authenticationHelper.clearUserSessionData(userID);
+    return Promise.resolve(response);
+  }
+  async requestCustomGrant(customGrantParams, userID) {
+    const oidcProviderMetadata = await this._oidcProviderMetaData();
+    const configData = await this._config();
+    let tokenEndpoint;
+    if (customGrantParams.tokenEndpoint && customGrantParams.tokenEndpoint.trim().length !== 0) {
+      tokenEndpoint = customGrantParams.tokenEndpoint;
+    } else {
+      tokenEndpoint = oidcProviderMetadata.token_endpoint;
+    }
+    if (!tokenEndpoint || tokenEndpoint.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RCG-NF01",
+        "Token endpoint not found.",
+        "No token endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the token endpoint passed to the SDK is empty."
+      );
+    }
+    const data = await Promise.all(
+      Object.entries(customGrantParams.data).map(async ([key, value]) => {
+        const newValue = await this._authenticationHelper.replaceCustomGrantTemplateTags(
+          value,
+          userID
+        );
+        return `${key}=${newValue}`;
+      })
+    );
+    let requestHeaders = {
+      Accept: "application/json",
+      "Content-Type": "application/x-www-form-urlencoded"
+    };
+    if (customGrantParams.attachToken) {
+      requestHeaders = {
+        ...requestHeaders,
+        Authorization: `Bearer ${(await this._dataLayer.getSessionData(userID)).access_token}`
+      };
+    }
+    const requestConfig = {
+      body: data.join("&"),
+      credentials: configData.sendCookiesInRequests ? "include" : "same-origin",
+      headers: new Headers(requestHeaders),
+      method: "POST"
+    };
+    let response;
+    try {
+      response = await fetch(tokenEndpoint, requestConfig);
+    } catch (error) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RCG-NE02",
+        "The custom grant request failed.",
+        error ?? "The request sent to get the custom grant failed."
+      );
+    }
+    if (response.status !== 200 || !response.ok) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RCG-HE03",
+        `Invalid response status received for the custom grant request. (${response.statusText})`,
+        await response.json()
+      );
+    }
+    if (customGrantParams.returnsSession) {
+      return this._authenticationHelper.handleTokenResponse(response, userID);
+    } else {
+      return Promise.resolve(await response.json());
+    }
+  }
+  async getBasicUserInfo(userID) {
+    const sessionData = await this._dataLayer.getSessionData(userID);
+    const authenticatedUser = this._authenticationHelper.getAuthenticatedUserInfo(
+      sessionData?.id_token
+    );
+    let basicUserInfo = {
+      allowedScopes: sessionData.scope,
+      sessionState: sessionData.session_state
+    };
+    Object.keys(authenticatedUser).forEach((key) => {
+      if (authenticatedUser[key] === void 0 || authenticatedUser[key] === "" || authenticatedUser[key] === null) {
+        delete authenticatedUser[key];
+      }
+    });
+    basicUserInfo = { ...basicUserInfo, ...authenticatedUser };
+    return basicUserInfo;
+  }
+  async getDecodedIDToken(userID) {
+    const idToken = (await this._dataLayer.getSessionData(userID)).id_token;
+    const payload = this._cryptoHelper.decodeIDToken(idToken);
+    return payload;
+  }
+  async getCryptoHelper() {
+    return this._cryptoHelper;
+  }
+  async getIDToken(userID) {
+    return (await this._dataLayer.getSessionData(userID)).id_token;
+  }
+  async getOIDCProviderMetaData(forceInit) {
+    const configData = await this._config();
+    if (!forceInit && await this._dataLayer.getTemporaryDataParameter(
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
+    )) {
+      return Promise.resolve();
+    }
+    const wellKnownEndpoint = configData.wellKnownEndpoint;
+    if (wellKnownEndpoint) {
+      let response;
+      try {
+        response = await fetch(wellKnownEndpoint);
+        if (response.status !== 200 || !response.ok) {
+          throw new Error();
+        }
+      } catch {
+        throw new AsgardeoAuthException(
+          "JS-AUTH_CORE-GOPMD-HE01",
+          "Invalid well-known response",
+          "The well known endpoint response has been failed with an error."
+        );
+      }
+      await this._dataLayer.setOIDCProviderMetaData(
+        await this._authenticationHelper.resolveEndpoints(await response.json())
+      );
+      await this._dataLayer.setTemporaryDataParameter(
+        OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED,
+        true
+      );
+      return Promise.resolve();
+    } else if (configData.baseUrl) {
+      try {
+        await this._dataLayer.setOIDCProviderMetaData(await this._authenticationHelper.resolveEndpointsByBaseURL());
+      } catch (error) {
+        throw new AsgardeoAuthException(
+          "JS-AUTH_CORE-GOPMD-IV02",
+          "Resolving endpoints failed.",
+          error ?? "Resolving endpoints by base url failed."
+        );
+      }
+      await this._dataLayer.setTemporaryDataParameter(
+        OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED,
+        true
+      );
+      return Promise.resolve();
+    } else {
+      await this._dataLayer.setOIDCProviderMetaData(await this._authenticationHelper.resolveEndpointsExplicitly());
+      await this._dataLayer.setTemporaryDataParameter(
+        OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED,
+        true
+      );
+      return Promise.resolve();
+    }
+  }
+  // TODO: Remove `Partial<OIDCEndpoints>` once the refactoring is done.
+  async getOIDCServiceEndpoints() {
+    const oidcProviderMetaData = await this._oidcProviderMetaData();
+    return {
+      authorizationEndpoint: oidcProviderMetaData.authorization_endpoint ?? "",
+      checkSessionIframe: oidcProviderMetaData.check_session_iframe ?? "",
+      endSessionEndpoint: oidcProviderMetaData.end_session_endpoint ?? "",
+      introspectionEndpoint: oidcProviderMetaData.introspection_endpoint ?? "",
+      issuer: oidcProviderMetaData.issuer ?? "",
+      jwksUri: oidcProviderMetaData.jwks_uri ?? "",
+      registrationEndpoint: oidcProviderMetaData.registration_endpoint ?? "",
+      revocationEndpoint: oidcProviderMetaData.revocation_endpoint ?? "",
+      tokenEndpoint: oidcProviderMetaData.token_endpoint ?? "",
+      userinfoEndpoint: oidcProviderMetaData.userinfo_endpoint ?? ""
+    };
+  }
+  async getSignOutURL(userID) {
+    const logoutEndpoint = (await this._oidcProviderMetaData())?.end_session_endpoint;
+    const configData = await this._config();
+    if (!logoutEndpoint || logoutEndpoint.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-GSOU-NF01",
+        "Sign-out endpoint not found.",
+        "No sign-out endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the sign-out endpoint passed to the SDK is empty."
+      );
+    }
+    const callbackURL = configData?.signOutRedirectURL ?? configData?.signInRedirectURL;
+    if (!callbackURL || callbackURL.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-GSOU-NF03",
+        "No sign-out redirect URL found.",
+        "The sign-out redirect URL cannot be found or the URL passed to the SDK is empty. No sign-in redirect URL has been found either. "
+      );
+    }
+    const queryParams = new URLSearchParams();
+    queryParams.set("post_logout_redirect_uri", callbackURL);
+    if (configData.sendIdTokenInLogoutRequest) {
+      const idToken = (await this._dataLayer.getSessionData(userID))?.id_token;
+      if (!idToken || idToken.trim().length === 0) {
+        throw new AsgardeoAuthException(
+          "JS-AUTH_CORE-GSOU-NF02",
+          "ID token not found.",
+          "No ID token could be found. Either the session information is lost or you have not signed in."
+        );
+      }
+      queryParams.set("id_token_hint", idToken);
+    } else {
+      queryParams.set("client_id", configData.clientID);
+    }
+    queryParams.set("state", OIDCRequestConstants_default.Params.SIGN_OUT_SUCCESS);
+    return `${logoutEndpoint}?${queryParams.toString()}`;
+  }
+  async clearUserSessionData(userID) {
+    await this._authenticationHelper.clearUserSessionData(userID);
+  }
+  async getAccessToken(userID) {
+    return (await this._dataLayer.getSessionData(userID))?.access_token;
+  }
+  /**
+   * The created timestamp of the token response in milliseconds.
+   *
+   * @param userID - User ID
+   * @returns Created at timestamp of the token response in milliseconds.
+   */
+  async getCreatedAt(userID) {
+    return (await this._dataLayer.getSessionData(userID))?.created_at;
+  }
+  /**
+   * The expires timestamp of the token response in seconds.
+   *
+   * @param userID - User ID
+   * @returns Expires in timestamp of the token response in seconds.
+   */
+  async getExpiresIn(userID) {
+    return (await this._dataLayer.getSessionData(userID))?.expires_in;
+  }
+  async isAuthenticated(userID) {
+    const isAccessTokenAvailable = Boolean(await this.getAccessToken(userID));
+    const createdAt = await this.getCreatedAt(userID);
+    const expiresInString = await this.getExpiresIn(userID);
+    if (!expiresInString) {
+      return false;
+    }
+    const expiresIn = parseInt(expiresInString) * 1e3;
+    const currentTime = (/* @__PURE__ */ new Date()).getTime();
+    const isAccessTokenValid = createdAt + expiresIn > currentTime;
+    const isAuthenticated = isAccessTokenAvailable && isAccessTokenValid;
+    return isAuthenticated;
+  }
+  async getPKCECode(state, userID) {
+    return await this._dataLayer.getTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), userID);
+  }
+  async setPKCECode(pkce, state, userID) {
+    return await this._dataLayer.setTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), pkce, userID);
+  }
+  async updateConfig(config) {
+    await this._dataLayer.setConfigData(config);
+    await this.getOIDCProviderMetaData(true);
+  }
+};
+
+// src/__legacy__/data/data-layer.ts
+var ASGARDEO_SESSION_ACTIVE = "asgardeo-session-active";
+var DataLayer = class {
+  constructor(instanceID, store) {
+    __publicField(this, "_id");
+    __publicField(this, "_store");
+    this._id = instanceID;
+    this._store = store;
+  }
+  async setDataInBulk(key, data) {
+    const existingDataJSON = await this._store.getData(key) ?? null;
+    const existingData = existingDataJSON && JSON.parse(existingDataJSON);
+    const dataToBeSaved = { ...existingData, ...data };
+    const dataToBeSavedJSON = JSON.stringify(dataToBeSaved);
+    await this._store.setData(key, dataToBeSavedJSON);
+  }
+  async setValue(key, attribute, value) {
+    const existingDataJSON = await this._store.getData(key) ?? null;
+    const existingData = existingDataJSON && JSON.parse(existingDataJSON);
+    const dataToBeSaved = { ...existingData, [attribute]: value };
+    const dataToBeSavedJSON = JSON.stringify(dataToBeSaved);
+    await this._store.setData(key, dataToBeSavedJSON);
+  }
+  async removeValue(key, attribute) {
+    const existingDataJSON = await this._store.getData(key) ?? null;
+    const existingData = existingDataJSON && JSON.parse(existingDataJSON);
+    const dataToBeSaved = { ...existingData };
+    delete dataToBeSaved[attribute];
+    const dataToBeSavedJSON = JSON.stringify(dataToBeSaved);
+    await this._store.setData(key, dataToBeSavedJSON);
+  }
+  _resolveKey(store, userID) {
+    return userID ? `${store}-${this._id}-${userID}` : `${store}-${this._id}`;
+  }
+  isLocalStorageAvailable() {
+    try {
+      const testValue = "__ASGARDEO_AUTH_CORE_LOCAL_STORAGE_TEST__";
+      localStorage.setItem(testValue, testValue);
+      localStorage.removeItem(testValue);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  async setConfigData(config) {
+    await this.setDataInBulk(this._resolveKey("config_data" /* ConfigData */), config);
+  }
+  async setOIDCProviderMetaData(oidcProviderMetaData) {
+    this.setDataInBulk(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */), oidcProviderMetaData);
+  }
+  async setTemporaryData(temporaryData, userID) {
+    this.setDataInBulk(this._resolveKey("temporary_data" /* TemporaryData */, userID), temporaryData);
+  }
+  async setSessionData(sessionData, userID) {
+    this.setDataInBulk(this._resolveKey("session_data" /* SessionData */, userID), sessionData);
+  }
+  async setCustomData(key, customData, userID) {
+    this.setDataInBulk(this._resolveKey(key, userID), customData);
+  }
+  async getConfigData() {
+    return JSON.parse(await this._store.getData(this._resolveKey("config_data" /* ConfigData */)) ?? null);
+  }
+  async getOIDCProviderMetaData() {
+    return JSON.parse(await this._store.getData(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */)) ?? null);
+  }
+  async getTemporaryData(userID) {
+    return JSON.parse(await this._store.getData(this._resolveKey("temporary_data" /* TemporaryData */, userID)) ?? null);
+  }
+  async getSessionData(userID) {
+    return JSON.parse(await this._store.getData(this._resolveKey("session_data" /* SessionData */, userID)) ?? null);
+  }
+  async getCustomData(key, userID) {
+    return JSON.parse(await this._store.getData(this._resolveKey(key, userID)) ?? null);
+  }
+  setSessionStatus(status) {
+    this.isLocalStorageAvailable() && localStorage.setItem(`${ASGARDEO_SESSION_ACTIVE}`, status);
+  }
+  getSessionStatus() {
+    return this.isLocalStorageAvailable() ? localStorage.getItem(`${ASGARDEO_SESSION_ACTIVE}`) ?? "" : "";
+  }
+  removeSessionStatus() {
+    this.isLocalStorageAvailable() && localStorage.removeItem(`${ASGARDEO_SESSION_ACTIVE}`);
+  }
+  async removeConfigData() {
+    await this._store.removeData(this._resolveKey("config_data" /* ConfigData */));
+  }
+  async removeOIDCProviderMetaData() {
+    await this._store.removeData(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */));
+  }
+  async removeTemporaryData(userID) {
+    await this._store.removeData(this._resolveKey("temporary_data" /* TemporaryData */, userID));
+  }
+  async removeSessionData(userID) {
+    await this._store.removeData(this._resolveKey("session_data" /* SessionData */, userID));
+  }
+  async getConfigDataParameter(key) {
+    const data = await this._store.getData(this._resolveKey("config_data" /* ConfigData */));
+    return data && JSON.parse(data)[key];
+  }
+  async getOIDCProviderMetaDataParameter(key) {
+    const data = await this._store.getData(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */));
+    return data && JSON.parse(data)[key];
+  }
+  async getTemporaryDataParameter(key, userID) {
+    const data = await this._store.getData(this._resolveKey("temporary_data" /* TemporaryData */, userID));
+    return data && JSON.parse(data)[key];
+  }
+  async getSessionDataParameter(key, userID) {
+    const data = await this._store.getData(this._resolveKey("session_data" /* SessionData */, userID));
+    return data && JSON.parse(data)[key];
+  }
+  async setConfigDataParameter(key, value) {
+    await this.setValue(this._resolveKey("config_data" /* ConfigData */), key, value);
+  }
+  async setOIDCProviderMetaDataParameter(key, value) {
+    await this.setValue(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */), key, value);
+  }
+  async setTemporaryDataParameter(key, value, userID) {
+    await this.setValue(this._resolveKey("temporary_data" /* TemporaryData */, userID), key, value);
+  }
+  async setSessionDataParameter(key, value, userID) {
+    await this.setValue(this._resolveKey("session_data" /* SessionData */, userID), key, value);
+  }
+  async removeConfigDataParameter(key) {
+    await this.removeValue(this._resolveKey("config_data" /* ConfigData */), key);
+  }
+  async removeOIDCProviderMetaDataParameter(key) {
+    await this.removeValue(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */), key);
+  }
+  async removeTemporaryDataParameter(key, userID) {
+    await this.removeValue(this._resolveKey("temporary_data" /* TemporaryData */, userID), key);
+  }
+  async removeSessionDataParameter(key, userID) {
+    await this.removeValue(this._resolveKey("session_data" /* SessionData */, userID), key);
+  }
+};
+
+// src/models/oauth-response.ts
+var ResponseMode = /* @__PURE__ */ ((ResponseMode2) => {
+  ResponseMode2["FormPost"] = "form_post";
+  ResponseMode2["Query"] = "query";
+  ResponseMode2["Direct"] = "direct";
+  return ResponseMode2;
+})(ResponseMode || {});
+
+// src/__legacy__/client.ts
+var DefaultConfig = {
+  clockTolerance: 300,
+  enablePKCE: true,
+  responseMode: "query" /* Query */,
+  scope: [ScopeConstants_default.OPENID],
+  sendCookiesInRequests: true,
+  validateIDToken: true,
+  validateIDTokenIssuer: true
+};
+var _AsgardeoAuthClient = class _AsgardeoAuthClient {
+  /**
+   * This is the constructor method that returns an instance of the .
+   *
+   * @param store - The store object.
+   *
+   * @example
+   * ```
+   * const _store: Store = new DataStore();
+   * const auth = new AsgardeoAuthClient<CustomClientConfig>(_store);
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#constructor}
+   *
+   * @preserve
+   */
+  constructor() {
+    __publicField(this, "_dataLayer");
+    __publicField(this, "_authenticationCore");
+  }
+  /**
+   *
+   * This method initializes the SDK with the config data.
+   *
+   * @param config - The config object to initialize with.
+   *
+   * @example
+   * const config = \{
+   *     signInRedirectURL: "http://localhost:3000/sign-in",
+   *     clientID: "client ID",
+   *     baseUrl: "https://localhost:9443"
+   * \}
+   *
+   * await auth.initialize(config);
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#initialize}
+   *
+   * @preserve
+   */
+  async initialize(config, store, cryptoUtils, instanceID) {
+    const clientId = config.clientID;
+    if (!_AsgardeoAuthClient._instanceID) {
+      _AsgardeoAuthClient._instanceID = 0;
+    } else {
+      _AsgardeoAuthClient._instanceID += 1;
+    }
+    if (instanceID) {
+      _AsgardeoAuthClient._instanceID = instanceID;
+    }
+    if (!clientId) {
+      this._dataLayer = new DataLayer(`instance_${_AsgardeoAuthClient._instanceID}`, store);
+    } else {
+      this._dataLayer = new DataLayer(`instance_${_AsgardeoAuthClient._instanceID}-${clientId}`, store);
+    }
+    this._authenticationCore = new AuthenticationCore(this._dataLayer, cryptoUtils);
+    _AsgardeoAuthClient._authenticationCore = new AuthenticationCore(this._dataLayer, cryptoUtils);
+    await this._dataLayer.setConfigData({
+      ...DefaultConfig,
+      ...config,
+      scope: [
+        ...DefaultConfig.scope ?? [],
+        ...config.scope?.filter((scope) => !DefaultConfig?.scope?.includes(scope)) ?? []
+      ]
+    });
+  }
+  /**
+   * This method returns the `DataLayer` object that allows you to access authentication data.
+   *
+   * @returns - The `DataLayer` object.
+   *
+   * @example
+   * ```
+   * const data = auth.getDataLayer();
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getDataLayer}
+   *
+   * @preserve
+   */
+  getDataLayer() {
+    return this._dataLayer;
+  }
+  /**
+   * This method returns the `instanceID` variable of the given instance.
+   *
+   * @returns - The `instanceID` number.
+   *
+   * @example
+   * ```
+   * const instanceId = auth.getInstanceID();
+   * ```
+   *
+   * @preserve
+   */
+  getInstanceID() {
+    return _AsgardeoAuthClient._instanceID;
+  }
+  /**
+   * This is an async method that returns a Promise that resolves with the authorization URL parameters.
+   *
+   * @param config - (Optional) A config object to force initialization and pass
+   * custom path parameters such as the `fidp` parameter.
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * @returns - A promise that resolves with the authorization URL parameters.
+   *
+   * @example
+   * ```
+   * auth.getAuthorizationURLParams().then((params)=>{
+   *  // console.log(params);
+   * }).catch((error)=>{
+   *  // console.error(error);
+   * });
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getAuthorizationURLParams}
+   *
+   * @preserve
+   */
+  async getAuthorizationURLParams(config, userID) {
+    const authRequestConfig = { ...config };
+    delete authRequestConfig?.forceInit;
+    if (await this._dataLayer.getTemporaryDataParameter(
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
+    )) {
+      return this._authenticationCore.getAuthorizationURLParams(authRequestConfig, userID);
+    }
+    return this._authenticationCore.getOIDCProviderMetaData(config?.forceInit).then(() => {
+      return this._authenticationCore.getAuthorizationURLParams(authRequestConfig, userID);
+    });
+  }
+  /**
+   * This is an async method that returns a Promise that resolves with the authorization URL.
+   *
+   * @param config - (Optional) A config object to force initialization and pass
+   * custom path parameters such as the fidp parameter.
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * @returns - A promise that resolves with the authorization URL.
+   *
+   * @example
+   * ```
+   * auth.getAuthorizationURL().then((url)=>{
+   *  // console.log(url);
+   * }).catch((error)=>{
+   *  // console.error(error);
+   * });
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getAuthorizationURL}
+   *
+   * @preserve
+   */
+  async getAuthorizationURL(config, userID) {
+    const authRequestConfig = { ...config };
+    delete authRequestConfig?.forceInit;
+    if (await this._dataLayer.getTemporaryDataParameter(
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
+    )) {
+      return this._authenticationCore.getAuthorizationURL(authRequestConfig, userID);
+    }
+    return this._authenticationCore.getOIDCProviderMetaData(config?.forceInit).then(() => {
+      return this._authenticationCore.getAuthorizationURL(authRequestConfig, userID);
+    });
+  }
+  /**
+   * This is an async method that sends a request to obtain the access token and returns a Promise
+   * that resolves with the token and other relevant data.
+   *
+   * @param authorizationCode - The authorization code.
+   * @param sessionState - The session state.
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * @returns - A Promise that resolves with the token response.
+   *
+   * @example
+   * ```
+   * auth.requestAccessToken(authCode, sessionState).then((token)=>{
+   *  // console.log(token);
+   * }).catch((error)=>{
+   *  // console.error(error);
+   * });
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#requestAccessToken}
+   *
+   *
+   * @preserve
+   */
+  async requestAccessToken(authorizationCode, sessionState, state, userID, tokenRequestConfig) {
+    if (await this._dataLayer.getTemporaryDataParameter(
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
+    )) {
+      return this._authenticationCore.requestAccessToken(
+        authorizationCode,
+        sessionState,
+        state,
+        userID,
+        tokenRequestConfig
+      );
+    }
+    return this._authenticationCore.getOIDCProviderMetaData(false).then(() => {
+      return this._authenticationCore.requestAccessToken(
+        authorizationCode,
+        sessionState,
+        state,
+        userID,
+        tokenRequestConfig
+      );
+    });
+  }
+  /**
+   * This method returns the sign-out URL.
+   *
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * **This doesn't clear the authentication data.**
+   *
+   * @returns - A Promise that resolves with the sign-out URL.
+   *
+   * @example
+   * ```
+   * const signOutUrl = await auth.getSignOutURL();
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getSignOutURL}
+   *
+   * @preserve
+   */
+  async getSignOutURL(userID) {
+    return this._authenticationCore.getSignOutURL(userID);
+  }
+  /**
+   * This method returns OIDC service endpoints that are fetched from the `.well-known` endpoint.
+   *
+   * @returns - A Promise that resolves with an object containing the OIDC service endpoints.
+   *
+   * @example
+   * ```
+   * const endpoints = await auth.getOIDCServiceEndpoints();
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getOIDCServiceEndpoints}
+   *
+   * @preserve
+   */
+  async getOIDCServiceEndpoints() {
+    return this._authenticationCore.getOIDCServiceEndpoints();
+  }
+  /**
+   * This method decodes the payload of the ID token and returns it.
+   *
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * @returns - A Promise that resolves with the decoded ID token payload.
+   *
+   * @example
+   * ```
+   * const decodedIdToken = await auth.getDecodedIDToken();
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getDecodedIDToken}
+   *
+   * @preserve
+   */
+  async getDecodedIDToken(userID) {
+    return this._authenticationCore.getDecodedIDToken(userID);
+  }
+  /**
+   * This method returns the ID token.
+   *
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * @returns - A Promise that resolves with the ID token.
+   *
+   * @example
+   * ```
+   * const idToken = await auth.getIDToken();
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getIDToken}
+   *
+   * @preserve
+   */
+  async getIDToken(userID) {
+    return this._authenticationCore.getIDToken(userID);
+  }
+  /**
+   * This method returns the basic user information obtained from the ID token.
+   *
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * @returns - A Promise that resolves with an object containing the basic user information.
+   *
+   * @example
+   * ```
+   * const userInfo = await auth.getBasicUserInfo();
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getBasicUserInfo}
+   *
+   * @preserve
+   */
+  async getBasicUserInfo(userID) {
+    return this._authenticationCore.getBasicUserInfo(userID);
+  }
+  /**
+   * This method returns the crypto helper object.
+   *
+   * @returns - A Promise that resolves with a IsomorphicCrypto object.
+   *
+   * @example
+   * ```
+   * const cryptoHelper = await auth.IsomorphicCrypto();
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getCryptoHelper}
+   *
+   * @preserve
+   */
+  async getCryptoHelper() {
+    return this._authenticationCore.getCryptoHelper();
+  }
+  /**
+   * This method revokes the access token.
+   *
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * **This method also clears the authentication data.**
+   *
+   * @returns - A Promise that returns the response of the revoke-access-token request.
+   *
+   * @example
+   * ```
+   * auth.revokeAccessToken().then((response)=>{
+   *  // console.log(response);
+   * }).catch((error)=>{
+   *  // console.error(error);
+   * });
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#revokeAccessToken}
+   *
+   * @preserve
+   */
+  revokeAccessToken(userID) {
+    return this._authenticationCore.revokeAccessToken(userID);
+  }
+  /**
+   * This method refreshes the access token and returns a Promise that resolves with the new access
+   * token and other relevant data.
+   *
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * @returns - A Promise that resolves with the token response.
+   *
+   * @example
+   * ```
+   * auth.refreshAccessToken().then((response)=>{
+   *  // console.log(response);
+   * }).catch((error)=>{
+   *  // console.error(error);
+   * });
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#refreshAccessToken}
+   *
+   * @preserve
+   */
+  refreshAccessToken(userID) {
+    return this._authenticationCore.refreshAccessToken(userID);
+  }
+  /**
+   * This method returns the access token.
+   *
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * @returns - A Promise that resolves with the access token.
+   *
+   * @example
+   * ```
+   * const accessToken = await auth.getAccessToken();
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getAccessToken}
+   *
+   * @preserve
+   */
+  async getAccessToken(userID) {
+    return this._authenticationCore.getAccessToken(userID);
+  }
+  /**
+   * This method sends a custom-grant request and returns a Promise that resolves with the response
+   * depending on the config passed.
+   *
+   * @param config - A config object containing the custom grant configurations.
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * @returns - A Promise that resolves with the response depending
+   * on your configurations.
+   *
+   * @example
+   * ```
+   * const config = {
+   *   attachToken: false,
+   *   data: {
+   *       client_id: "{{clientID}}",
+   *       grant_type: "account_switch",
+   *       scope: "{{scope}}",
+   *       token: "{{token}}",
+   *   },
+   *   id: "account-switch",
+   *   returnResponse: true,
+   *   returnsSession: true,
+   *   signInRequired: true
+   * }
+   *
+   * auth.requestCustomGrant(config).then((response)=>{
+   *  // console.log(response);
+   * }).catch((error)=>{
+   *  // console.error(error);
+   * });
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#requestCustomGrant}
+   *
+   * @preserve
+   */
+  requestCustomGrant(config, userID) {
+    return this._authenticationCore.requestCustomGrant(config, userID);
+  }
+  /**
+   * This method returns if the user is authenticated or not.
+   *
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * @returns - A Promise that resolves with `true` if the user is authenticated, `false` otherwise.
+   *
+   * @example
+   * ```
+   * await auth.isAuthenticated();
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#isAuthenticated}
+   *
+   * @preserve
+   */
+  async isAuthenticated(userID) {
+    return this._authenticationCore.isAuthenticated(userID);
+  }
+  /**
+   * This method returns the PKCE code generated during the generation of the authentication URL.
+   *
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   * @param state - The state parameter that was passed in the authentication URL.
+   *
+   * @returns - A Promise that resolves with the PKCE code.
+   *
+   * @example
+   * ```
+   * const pkce = await getPKCECode();
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getPKCECode}
+   *
+   * @preserve
+   */
+  async getPKCECode(state, userID) {
+    return this._authenticationCore.getPKCECode(state, userID);
+  }
+  /**
+   * This method sets the PKCE code to the data store.
+   *
+   * @param pkce - The PKCE code.
+   * @param state - The state parameter that was passed in the authentication URL.
+   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * @example
+   * ```
+   * await auth.setPKCECode("pkce_code")
+   * ```
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#setPKCECode}
+   *
+   * @preserve
+   */
+  async setPKCECode(pkce, state, userID) {
+    await this._authenticationCore.setPKCECode(pkce, state, userID);
+  }
+  /**
+   * This method returns if the sign-out is successful or not.
+   *
+   * @param signOutRedirectUrl - The URL to which the user has been redirected to after signing-out.
+   *
+   * **The server appends path parameters to the `signOutRedirectURL` and these path parameters
+   *  are required for this method to function.**
+   *
+   * @returns - `true` if successful, `false` otherwise.
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#isSignOutSuccessful}
+   *
+   * @preserve
+   */
+  static isSignOutSuccessful(signOutRedirectURL) {
+    const url = new URL(signOutRedirectURL);
+    const stateParam = url.searchParams.get(OIDCRequestConstants_default.Params.STATE);
+    const error = Boolean(url.searchParams.get("error"));
+    return stateParam ? stateParam === OIDCRequestConstants_default.Params.SIGN_OUT_SUCCESS && !error : false;
+  }
+  /**
+   * This method returns if the sign-out has failed or not.
+   *
+   * @param signOutRedirectUrl - The URL to which the user has been redirected to after signing-out.
+   *
+   * **The server appends path parameters to the `signOutRedirectURL` and these path parameters
+   *  are required for this method to function.**
+   *
+   * @returns - `true` if successful, `false` otherwise.
+   *
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#didSignOutFail}
+   *
+   * @preserve
+   */
+  static didSignOutFail(signOutRedirectURL) {
+    const url = new URL(signOutRedirectURL);
+    const stateParam = url.searchParams.get(OIDCRequestConstants_default.Params.STATE);
+    const error = Boolean(url.searchParams.get("error"));
+    return stateParam ? stateParam === OIDCRequestConstants_default.Params.SIGN_OUT_SUCCESS && error : false;
+  }
+  /**
+   * This method updates the configuration that was passed into the constructor when instantiating this class.
+   *
+   * @param config - A config object to update the SDK configurations with.
+   *
+   * @example
+   * ```
+   * const config = {
+   *     signInRedirectURL: "http://localhost:3000/sign-in",
+   *     clientID: "client ID",
+   *     baseUrl: "https://localhost:9443"
+   * }
+   *
+   * await auth.updateConfig(config);
+   * ```
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#updateConfig}
+   *
+   * @preserve
+   */
+  async updateConfig(config) {
+    await this._authenticationCore.updateConfig(config);
+  }
+  static async clearUserSessionData(userID) {
+    await this._authenticationCore.clearUserSessionData(userID);
+  }
+};
+__publicField(_AsgardeoAuthClient, "_instanceID");
+__publicField(_AsgardeoAuthClient, "_authenticationCore");
+var AsgardeoAuthClient = _AsgardeoAuthClient;
+
+// src/errors/AsgardeoError.ts
+var AsgardeoError = class _AsgardeoError extends Error {
+  constructor(message, code, origin) {
+    const _origin = _AsgardeoError.resolveOrigin(origin);
+    const prefix = `\u{1F6E1}\uFE0F Asgardeo - ${_origin}:`;
+    const regex = new RegExp(`\u{1F6E1}\uFE0F\\s*Asgardeo\\s*-\\s*${_origin}:`, "i");
+    const sanitized = message.replace(regex, "");
+    const _message = `${prefix} ${sanitized.trim()}
+
+(code="${code}")
+`;
+    super(_message);
+    __publicField(this, "code");
+    __publicField(this, "origin");
+    this.name = new.target.name;
+    this.code = code;
+    this.origin = _origin;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, new.target);
+    }
+  }
+  static resolveOrigin(origin) {
+    if (!origin) {
+      return "@asgardeo/javascript";
+    }
+    return `@asgardeo/${origin}`;
+  }
+  toString() {
+    return `[${this.name}]
+Message: ${this.message}`;
+  }
+};
+
+// src/errors/AsgardeoAPIError.ts
+var AsgardeoAPIError = class extends AsgardeoError {
+  /**
+   * Creates an instance of AsgardeoAPIError.
+   *
+   * @param message - Human-readable description of the error
+   * @param code - A unique error code that identifies the error type
+   * @param statusCode - HTTP status code of the failed request
+   * @param statusText - HTTP status text of the failed request
+   * @param origin - Optional. The SDK origin (e.g. 'react', 'vue'). Defaults to generic 'Asgardeo'
+   * @constructor
+   */
+  constructor(message, code, origin, statusCode, statusText) {
+    super(message, code, origin);
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+    Object.defineProperty(this, "name", {
+      value: "AsgardeoAPIError",
+      configurable: true,
+      writable: true
+    });
+  }
+  /**
+   * Returns a string representation of the API error
+   * @returns Formatted error string with name, code, status, and message
+   */
+  toString() {
+    const status = this.statusCode ? ` (HTTP ${this.statusCode} - ${this.statusText})` : "";
+    return `[${this.name}] (code="${this.code}")${status}
+Message: ${this.message}`;
+  }
+};
+
+// src/api/oidc/getUserInfo.ts
+var getUserInfo = async ({ url, ...requestConfig }) => {
+  try {
+    new URL(url);
+  } catch (error) {
+    throw new AsgardeoAPIError(
+      "Invalid endpoint URL provided",
+      "getUserInfo-ValidationError-001",
+      "javascript",
+      400,
+      "Invalid Request"
+    );
+  }
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    ...requestConfig
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new AsgardeoAPIError(
+      `Failed to fetch user info: ${errorText}`,
+      "getUserInfo-ResponseError-001",
+      "javascript",
+      response.status,
+      response.statusText
+    );
+  }
+  return await response.json();
+};
+var getUserInfo_default = getUserInfo;
+
+// src/errors/AsgardeoRuntimeError.ts
+var AsgardeoRuntimeError = class extends AsgardeoError {
+  /**
+   * Creates an instance of AsgardeoRuntimeError.
+   *
+   * @param message - Human-readable description of the error
+   * @param code - A unique error code that identifies the error type
+   * @param details - Additional details about the error that might be helpful for debugging
+   * @param origin - Optional. The SDK origin (e.g. 'react', 'vue'). Defaults to generic 'Asgardeo'
+   * @constructor
+   */
+  constructor(message, code, origin, details) {
+    super(message, code, origin);
+    this.details = details;
+    Object.defineProperty(this, "name", {
+      value: "AsgardeoRuntimeError",
+      configurable: true,
+      writable: true
+    });
+  }
+  /**
+   * Returns a string representation of the runtime error
+   * @returns Formatted error string with name, code, details, and message
+   */
+  toString() {
+    const details = this.details ? `
+Details: ${JSON.stringify(this.details, null, 2)}` : "";
+    return `[${this.name}] (code="${this.code}")${details}
+Message: ${this.message}`;
+  }
+};
+
+// src/models/scim2-schema.ts
+var WellKnownSchemaIds = /* @__PURE__ */ ((WellKnownSchemaIds2) => {
+  WellKnownSchemaIds2["Core"] = "urn:ietf:params:scim:schemas:core:2.0";
+  WellKnownSchemaIds2["User"] = "urn:ietf:params:scim:schemas:core:2.0:User";
+  WellKnownSchemaIds2["EnterpriseUser"] = "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User";
+  WellKnownSchemaIds2["SystemUser"] = "urn:scim:wso2:schema";
+  WellKnownSchemaIds2["CustomUser"] = "urn:scim:schemas:extension:custom:User";
+  return WellKnownSchemaIds2;
+})(WellKnownSchemaIds || {});
+
+// src/AsgardeoJavaScriptClient.ts
+var AsgardeoJavaScriptClient = class {
+};
+var AsgardeoJavaScriptClient_default = AsgardeoJavaScriptClient;
+
+// src/theme/createTheme.ts
+var lightTheme = {
+  colors: {
+    primary: {
+      main: "#1a73e8",
+      contrastText: "#ffffff"
+    },
+    secondary: {
+      main: "#424242",
+      contrastText: "#ffffff"
+    },
+    background: {
+      surface: "#f5f5f5",
+      disabled: "#f0f0f0",
+      body: {
+        main: "#1a1a1a"
+      }
+    },
+    error: {
+      main: "#d32f2f",
+      contrastText: "#ffffff"
+    },
+    surface: "#f5f5f5",
+    text: {
+      primary: "#1a1a1a",
+      secondary: "#666666"
+    },
+    border: "#e0e0e0"
+  },
+  spacing: {
+    unit: 8
+  },
+  borderRadius: {
+    small: "4px",
+    medium: "8px",
+    large: "16px"
+  }
+};
+var darkTheme = {
+  colors: {
+    primary: {
+      main: "#1a73e8",
+      contrastText: "#ffffff"
+    },
+    secondary: {
+      main: "#424242",
+      contrastText: "#ffffff"
+    },
+    background: {
+      surface: "#121212",
+      disabled: "#1f1f1f",
+      body: {
+        main: "#ffffff"
+      }
+    },
+    error: {
+      main: "#d32f2f",
+      contrastText: "#ffffff"
+    },
+    surface: "#2d2d2d",
+    text: {
+      primary: "#ffffff",
+      secondary: "#b3b3b3"
+    },
+    border: "#404040"
+  },
+  spacing: {
+    unit: 8
+  },
+  borderRadius: {
+    small: "4px",
+    medium: "8px",
+    large: "16px"
+  }
+};
+var toCssVariables = (theme) => {
+  const cssVars = {};
+  cssVars["--asgardeo-color-primary-main"] = theme.colors.primary.main;
+  cssVars["--asgardeo-color-primary-contrastText"] = theme.colors.primary.contrastText;
+  cssVars["--asgardeo-color-secondary-main"] = theme.colors.secondary.main;
+  cssVars["--asgardeo-color-secondary-contrastText"] = theme.colors.secondary.contrastText;
+  cssVars["--asgardeo-color-background-surface"] = theme.colors.background.surface;
+  cssVars["--asgardeo-color-background-disabled"] = theme.colors.background.disabled;
+  cssVars["--asgardeo-color-background-body-main"] = theme.colors.background.body.main;
+  cssVars["--asgardeo-color-error-main"] = theme.colors.error.main;
+  cssVars["--asgardeo-color-error-contrastText"] = theme.colors.error.contrastText;
+  cssVars["--asgardeo-color-surface"] = theme.colors.surface;
+  cssVars["--asgardeo-color-text-primary"] = theme.colors.text.primary;
+  cssVars["--asgardeo-color-text-secondary"] = theme.colors.text.secondary;
+  cssVars["--asgardeo-color-border"] = theme.colors.border;
+  cssVars["--asgardeo-spacing-unit"] = `${theme.spacing.unit}px`;
+  cssVars["--asgardeo-border-radius-small"] = theme.borderRadius.small;
+  cssVars["--asgardeo-border-radius-medium"] = theme.borderRadius.medium;
+  cssVars["--asgardeo-border-radius-large"] = theme.borderRadius.large;
+  return cssVars;
+};
+var createTheme = (config = {}, isDark = false) => {
+  const baseTheme = isDark ? darkTheme : lightTheme;
+  const mergedConfig = {
+    ...baseTheme,
+    ...config,
+    colors: {
+      ...baseTheme.colors,
+      ...config.colors,
+      secondary: {
+        ...baseTheme.colors.secondary,
+        ...config.colors?.secondary || {}
+      }
+    },
+    spacing: {
+      ...baseTheme.spacing,
+      ...config.spacing
+    },
+    borderRadius: {
+      ...baseTheme.borderRadius,
+      ...config.borderRadius
+    }
+  };
+  return {
+    ...mergedConfig,
+    cssVariables: toCssVariables(mergedConfig)
+  };
+};
+var createTheme_default = createTheme;
+
+// src/utils/removeTrailingSlash.ts
+var removeTrailingSlash = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
+var removeTrailingSlash_default = removeTrailingSlash;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ASGARDEO_SESSION_ACTIVE,
+  AsgardeoAPIError,
+  AsgardeoAuthClient,
+  AsgardeoAuthException,
+  AsgardeoError,
+  AsgardeoJavaScriptClient,
+  AsgardeoRuntimeError,
+  DataLayer,
+  IsomorphicCrypto,
+  OIDCRequestConstants,
+  ResponseMode,
+  TokenConstants,
+  WellKnownSchemaIds,
+  createTheme,
+  extractPkceStorageKeyFromState,
+  extractUserClaimsFromIdToken,
+  getUserInfo,
+  removeTrailingSlash
+});
+//# sourceMappingURL=index.js.map