@azure/msal-common 14.0.0-alpha.2 → 14.0.0-beta.0

package/dist/index.cjs.js

@@ -1,4 +1,4 @@
-/*! @azure/msal-common v14.0.0-alpha.2 2023-05-17 */
+/*! @azure/msal-common v14.0.0-beta.0 2023-06-19 */
 'use strict';
 'use strict';
 
@@ -74,100 +74,95 @@ const OIDC_SCOPES = [...OIDC_DEFAULT_SCOPES, Constants.EMAIL_SCOPE];
 /**
  * Request header names
  */
-exports.HeaderNames = void 0;
-(function (HeaderNames) {
-    HeaderNames["CONTENT_TYPE"] = "Content-Type";
-    HeaderNames["RETRY_AFTER"] = "Retry-After";
-    HeaderNames["CCS_HEADER"] = "X-AnchorMailbox";
-    HeaderNames["WWWAuthenticate"] = "WWW-Authenticate";
-    HeaderNames["AuthenticationInfo"] = "Authentication-Info";
-    HeaderNames["X_MS_REQUEST_ID"] = "x-ms-request-id";
-    HeaderNames["X_MS_HTTP_VERSION"] = "x-ms-httpver";
-})(exports.HeaderNames || (exports.HeaderNames = {}));
+const HeaderNames = {
+    CONTENT_TYPE: "Content-Type",
+    RETRY_AFTER: "Retry-After",
+    CCS_HEADER: "X-AnchorMailbox",
+    WWWAuthenticate: "WWW-Authenticate",
+    AuthenticationInfo: "Authentication-Info",
+    X_MS_REQUEST_ID: "x-ms-request-id",
+    X_MS_HTTP_VERSION: "x-ms-httpver",
+};
 /**
  * Persistent cache keys MSAL which stay while user is logged in.
  */
-exports.PersistentCacheKeys = void 0;
-(function (PersistentCacheKeys) {
-    PersistentCacheKeys["ID_TOKEN"] = "idtoken";
-    PersistentCacheKeys["CLIENT_INFO"] = "client.info";
-    PersistentCacheKeys["ADAL_ID_TOKEN"] = "adal.idtoken";
-    PersistentCacheKeys["ERROR"] = "error";
-    PersistentCacheKeys["ERROR_DESC"] = "error.description";
-    PersistentCacheKeys["ACTIVE_ACCOUNT"] = "active-account";
-    PersistentCacheKeys["ACTIVE_ACCOUNT_FILTERS"] = "active-account-filters";
-})(exports.PersistentCacheKeys || (exports.PersistentCacheKeys = {}));
+const PersistentCacheKeys = {
+    ID_TOKEN: "idtoken",
+    CLIENT_INFO: "client.info",
+    ADAL_ID_TOKEN: "adal.idtoken",
+    ERROR: "error",
+    ERROR_DESC: "error.description",
+    ACTIVE_ACCOUNT: "active-account",
+    ACTIVE_ACCOUNT_FILTERS: "active-account-filters", // new cache entry for active_account for a more robust version for browser
+};
 /**
  * String constants related to AAD Authority
  */
-exports.AADAuthorityConstants = void 0;
-(function (AADAuthorityConstants) {
-    AADAuthorityConstants["COMMON"] = "common";
-    AADAuthorityConstants["ORGANIZATIONS"] = "organizations";
-    AADAuthorityConstants["CONSUMERS"] = "consumers";
-})(exports.AADAuthorityConstants || (exports.AADAuthorityConstants = {}));
+const AADAuthorityConstants = {
+    COMMON: "common",
+    ORGANIZATIONS: "organizations",
+    CONSUMERS: "consumers",
+};
 /**
  * Keys in the hashParams sent by AAD Server
  */
-exports.AADServerParamKeys = void 0;
-(function (AADServerParamKeys) {
-    AADServerParamKeys["CLIENT_ID"] = "client_id";
-    AADServerParamKeys["REDIRECT_URI"] = "redirect_uri";
-    AADServerParamKeys["RESPONSE_TYPE"] = "response_type";
-    AADServerParamKeys["RESPONSE_MODE"] = "response_mode";
-    AADServerParamKeys["GRANT_TYPE"] = "grant_type";
-    AADServerParamKeys["CLAIMS"] = "claims";
-    AADServerParamKeys["SCOPE"] = "scope";
-    AADServerParamKeys["ERROR"] = "error";
-    AADServerParamKeys["ERROR_DESCRIPTION"] = "error_description";
-    AADServerParamKeys["ACCESS_TOKEN"] = "access_token";
-    AADServerParamKeys["ID_TOKEN"] = "id_token";
-    AADServerParamKeys["REFRESH_TOKEN"] = "refresh_token";
-    AADServerParamKeys["EXPIRES_IN"] = "expires_in";
-    AADServerParamKeys["STATE"] = "state";
-    AADServerParamKeys["NONCE"] = "nonce";
-    AADServerParamKeys["PROMPT"] = "prompt";
-    AADServerParamKeys["SESSION_STATE"] = "session_state";
-    AADServerParamKeys["CLIENT_INFO"] = "client_info";
-    AADServerParamKeys["CODE"] = "code";
-    AADServerParamKeys["CODE_CHALLENGE"] = "code_challenge";
-    AADServerParamKeys["CODE_CHALLENGE_METHOD"] = "code_challenge_method";
-    AADServerParamKeys["CODE_VERIFIER"] = "code_verifier";
-    AADServerParamKeys["CLIENT_REQUEST_ID"] = "client-request-id";
-    AADServerParamKeys["X_CLIENT_SKU"] = "x-client-SKU";
-    AADServerParamKeys["X_CLIENT_VER"] = "x-client-VER";
-    AADServerParamKeys["X_CLIENT_OS"] = "x-client-OS";
-    AADServerParamKeys["X_CLIENT_CPU"] = "x-client-CPU";
-    AADServerParamKeys["X_CLIENT_CURR_TELEM"] = "x-client-current-telemetry";
-    AADServerParamKeys["X_CLIENT_LAST_TELEM"] = "x-client-last-telemetry";
-    AADServerParamKeys["X_MS_LIB_CAPABILITY"] = "x-ms-lib-capability";
-    AADServerParamKeys["X_APP_NAME"] = "x-app-name";
-    AADServerParamKeys["X_APP_VER"] = "x-app-ver";
-    AADServerParamKeys["POST_LOGOUT_URI"] = "post_logout_redirect_uri";
-    AADServerParamKeys["ID_TOKEN_HINT"] = "id_token_hint";
-    AADServerParamKeys["DEVICE_CODE"] = "device_code";
-    AADServerParamKeys["CLIENT_SECRET"] = "client_secret";
-    AADServerParamKeys["CLIENT_ASSERTION"] = "client_assertion";
-    AADServerParamKeys["CLIENT_ASSERTION_TYPE"] = "client_assertion_type";
-    AADServerParamKeys["TOKEN_TYPE"] = "token_type";
-    AADServerParamKeys["REQ_CNF"] = "req_cnf";
-    AADServerParamKeys["OBO_ASSERTION"] = "assertion";
-    AADServerParamKeys["REQUESTED_TOKEN_USE"] = "requested_token_use";
-    AADServerParamKeys["ON_BEHALF_OF"] = "on_behalf_of";
-    AADServerParamKeys["FOCI"] = "foci";
-    AADServerParamKeys["CCS_HEADER"] = "X-AnchorMailbox";
-    AADServerParamKeys["RETURN_SPA_CODE"] = "return_spa_code";
-    AADServerParamKeys["NATIVE_BROKER"] = "nativebroker";
-    AADServerParamKeys["LOGOUT_HINT"] = "logout_hint";
-})(exports.AADServerParamKeys || (exports.AADServerParamKeys = {}));
+const AADServerParamKeys = {
+    CLIENT_ID: "client_id",
+    REDIRECT_URI: "redirect_uri",
+    RESPONSE_TYPE: "response_type",
+    RESPONSE_MODE: "response_mode",
+    GRANT_TYPE: "grant_type",
+    CLAIMS: "claims",
+    SCOPE: "scope",
+    ERROR: "error",
+    ERROR_DESCRIPTION: "error_description",
+    ACCESS_TOKEN: "access_token",
+    ID_TOKEN: "id_token",
+    REFRESH_TOKEN: "refresh_token",
+    EXPIRES_IN: "expires_in",
+    STATE: "state",
+    NONCE: "nonce",
+    PROMPT: "prompt",
+    SESSION_STATE: "session_state",
+    CLIENT_INFO: "client_info",
+    CODE: "code",
+    CODE_CHALLENGE: "code_challenge",
+    CODE_CHALLENGE_METHOD: "code_challenge_method",
+    CODE_VERIFIER: "code_verifier",
+    CLIENT_REQUEST_ID: "client-request-id",
+    X_CLIENT_SKU: "x-client-SKU",
+    X_CLIENT_VER: "x-client-VER",
+    X_CLIENT_OS: "x-client-OS",
+    X_CLIENT_CPU: "x-client-CPU",
+    X_CLIENT_CURR_TELEM: "x-client-current-telemetry",
+    X_CLIENT_LAST_TELEM: "x-client-last-telemetry",
+    X_MS_LIB_CAPABILITY: "x-ms-lib-capability",
+    X_APP_NAME: "x-app-name",
+    X_APP_VER: "x-app-ver",
+    POST_LOGOUT_URI: "post_logout_redirect_uri",
+    ID_TOKEN_HINT: "id_token_hint",
+    DEVICE_CODE: "device_code",
+    CLIENT_SECRET: "client_secret",
+    CLIENT_ASSERTION: "client_assertion",
+    CLIENT_ASSERTION_TYPE: "client_assertion_type",
+    TOKEN_TYPE: "token_type",
+    REQ_CNF: "req_cnf",
+    OBO_ASSERTION: "assertion",
+    REQUESTED_TOKEN_USE: "requested_token_use",
+    ON_BEHALF_OF: "on_behalf_of",
+    FOCI: "foci",
+    CCS_HEADER: "X-AnchorMailbox",
+    RETURN_SPA_CODE: "return_spa_code",
+    NATIVE_BROKER: "nativebroker",
+    LOGOUT_HINT: "logout_hint",
+};
 /**
  * Claims request keys
  */
-exports.ClaimsRequestKeys = void 0;
-(function (ClaimsRequestKeys) {
-    ClaimsRequestKeys["ACCESS_TOKEN"] = "access_token";
-    ClaimsRequestKeys["XMS_CC"] = "xms_cc";
-})(exports.ClaimsRequestKeys || (exports.ClaimsRequestKeys = {}));
+const ClaimsRequestKeys = {
+    ACCESS_TOKEN: "access_token",
+    XMS_CC: "xms_cc",
+};
 /**
  * we considered making this "enum" in the request instead of string, however it looks like the allowed list of
  * prompt values kept changing over past couple of years. There are some undocumented prompt values for some
@@ -184,18 +179,17 @@ const PromptValue = {
 /**
  * SSO Types - generated to populate hints
  */
-exports.SSOTypes = void 0;
-(function (SSOTypes) {
-    SSOTypes["ACCOUNT"] = "account";
-    SSOTypes["SID"] = "sid";
-    SSOTypes["LOGIN_HINT"] = "login_hint";
-    SSOTypes["ID_TOKEN"] = "id_token";
-    SSOTypes["DOMAIN_HINT"] = "domain_hint";
-    SSOTypes["ORGANIZATIONS"] = "organizations";
-    SSOTypes["CONSUMERS"] = "consumers";
-    SSOTypes["ACCOUNT_ID"] = "accountIdentifier";
-    SSOTypes["HOMEACCOUNT_ID"] = "homeAccountIdentifier";
-})(exports.SSOTypes || (exports.SSOTypes = {}));
+const SSOTypes = {
+    ACCOUNT: "account",
+    SID: "sid",
+    LOGIN_HINT: "login_hint",
+    ID_TOKEN: "id_token",
+    DOMAIN_HINT: "domain_hint",
+    ORGANIZATIONS: "organizations",
+    CONSUMERS: "consumers",
+    ACCOUNT_ID: "accountIdentifier",
+    HOMEACCOUNT_ID: "homeAccountIdentifier",
+};
 /**
  * allowed values for codeVerifier
  */
@@ -203,80 +197,65 @@ const CodeChallengeMethodValues = {
     PLAIN: "plain",
     S256: "S256",
 };
-/**
- * The method used to encode the code verifier for the code challenge parameter. can be one
- * of plain or s256. if excluded, code challenge is assumed to be plaintext. for more
- * information, see the pkce rcf: https://tools.ietf.org/html/rfc7636
- */
-[
-    CodeChallengeMethodValues.PLAIN,
-    CodeChallengeMethodValues.S256,
-];
 /**
  * allowed values for response_mode
  */
-exports.ResponseMode = void 0;
-(function (ResponseMode) {
-    ResponseMode["QUERY"] = "query";
-    ResponseMode["FRAGMENT"] = "fragment";
-    ResponseMode["FORM_POST"] = "form_post";
-})(exports.ResponseMode || (exports.ResponseMode = {}));
+const ResponseMode = {
+    QUERY: "query",
+    FRAGMENT: "fragment",
+    FORM_POST: "form_post",
+};
 /**
  * allowed grant_type
  */
-exports.GrantType = void 0;
-(function (GrantType) {
-    GrantType["IMPLICIT_GRANT"] = "implicit";
-    GrantType["AUTHORIZATION_CODE_GRANT"] = "authorization_code";
-    GrantType["CLIENT_CREDENTIALS_GRANT"] = "client_credentials";
-    GrantType["RESOURCE_OWNER_PASSWORD_GRANT"] = "password";
-    GrantType["REFRESH_TOKEN_GRANT"] = "refresh_token";
-    GrantType["DEVICE_CODE_GRANT"] = "device_code";
-    GrantType["JWT_BEARER"] = "urn:ietf:params:oauth:grant-type:jwt-bearer";
-})(exports.GrantType || (exports.GrantType = {}));
+const GrantType = {
+    IMPLICIT_GRANT: "implicit",
+    AUTHORIZATION_CODE_GRANT: "authorization_code",
+    CLIENT_CREDENTIALS_GRANT: "client_credentials",
+    RESOURCE_OWNER_PASSWORD_GRANT: "password",
+    REFRESH_TOKEN_GRANT: "refresh_token",
+    DEVICE_CODE_GRANT: "device_code",
+    JWT_BEARER: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+};
 /**
  * Account types in Cache
  */
-exports.CacheAccountType = void 0;
-(function (CacheAccountType) {
-    CacheAccountType["MSSTS_ACCOUNT_TYPE"] = "MSSTS";
-    CacheAccountType["ADFS_ACCOUNT_TYPE"] = "ADFS";
-    CacheAccountType["MSAV1_ACCOUNT_TYPE"] = "MSA";
-    CacheAccountType["GENERIC_ACCOUNT_TYPE"] = "Generic";
-})(exports.CacheAccountType || (exports.CacheAccountType = {}));
+const CacheAccountType = {
+    MSSTS_ACCOUNT_TYPE: "MSSTS",
+    ADFS_ACCOUNT_TYPE: "ADFS",
+    MSAV1_ACCOUNT_TYPE: "MSA",
+    GENERIC_ACCOUNT_TYPE: "Generic", // NTLM, Kerberos, FBA, Basic etc
+};
 /**
  * Separators used in cache
  */
-var Separators;
-(function (Separators) {
-    Separators["CACHE_KEY_SEPARATOR"] = "-";
-    Separators["CLIENT_INFO_SEPARATOR"] = ".";
-})(Separators || (Separators = {}));
+const Separators = {
+    CACHE_KEY_SEPARATOR: "-",
+    CLIENT_INFO_SEPARATOR: ".",
+};
 /**
  * Credential Type stored in the cache
  */
-exports.CredentialType = void 0;
-(function (CredentialType) {
-    CredentialType["ID_TOKEN"] = "IdToken";
-    CredentialType["ACCESS_TOKEN"] = "AccessToken";
-    CredentialType["ACCESS_TOKEN_WITH_AUTH_SCHEME"] = "AccessToken_With_AuthScheme";
-    CredentialType["REFRESH_TOKEN"] = "RefreshToken";
-})(exports.CredentialType || (exports.CredentialType = {}));
+const CredentialType = {
+    ID_TOKEN: "IdToken",
+    ACCESS_TOKEN: "AccessToken",
+    ACCESS_TOKEN_WITH_AUTH_SCHEME: "AccessToken_With_AuthScheme",
+    REFRESH_TOKEN: "RefreshToken",
+};
 /**
  * Combine all cache types
  */
-exports.CacheType = void 0;
-(function (CacheType) {
-    CacheType[CacheType["ADFS"] = 1001] = "ADFS";
-    CacheType[CacheType["MSA"] = 1002] = "MSA";
-    CacheType[CacheType["MSSTS"] = 1003] = "MSSTS";
-    CacheType[CacheType["GENERIC"] = 1004] = "GENERIC";
-    CacheType[CacheType["ACCESS_TOKEN"] = 2001] = "ACCESS_TOKEN";
-    CacheType[CacheType["REFRESH_TOKEN"] = 2002] = "REFRESH_TOKEN";
-    CacheType[CacheType["ID_TOKEN"] = 2003] = "ID_TOKEN";
-    CacheType[CacheType["APP_METADATA"] = 3001] = "APP_METADATA";
-    CacheType[CacheType["UNDEFINED"] = 9999] = "UNDEFINED";
-})(exports.CacheType || (exports.CacheType = {}));
+const CacheType = {
+    ADFS: 1001,
+    MSA: 1002,
+    MSSTS: 1003,
+    GENERIC: 1004,
+    ACCESS_TOKEN: 2001,
+    REFRESH_TOKEN: 2002,
+    ID_TOKEN: 2003,
+    APP_METADATA: 3001,
+    UNDEFINED: 9999,
+};
 /**
  * More Cache related constants
  */
@@ -287,13 +266,12 @@ const AUTHORITY_METADATA_CONSTANTS = {
     CACHE_KEY: "authority-metadata",
     REFRESH_TIME_SECONDS: 3600 * 24, // 24 Hours
 };
-var AuthorityMetadataSource;
-(function (AuthorityMetadataSource) {
-    AuthorityMetadataSource["CONFIG"] = "config";
-    AuthorityMetadataSource["CACHE"] = "cache";
-    AuthorityMetadataSource["NETWORK"] = "network";
-    AuthorityMetadataSource["HARDCODED_VALUES"] = "hardcoded_values";
-})(AuthorityMetadataSource || (AuthorityMetadataSource = {}));
+const AuthorityMetadataSource = {
+    CONFIG: "config",
+    CACHE: "cache",
+    NETWORK: "network",
+    HARDCODED_VALUES: "hardcoded_values",
+};
 const SERVER_TELEM_CONSTANTS = {
     SCHEMA_VERSION: 5,
     MAX_CUR_HEADER_BYTES: 80,
@@ -309,12 +287,11 @@ const SERVER_TELEM_CONSTANTS = {
 /**
  * Type of the authentication request
  */
-exports.AuthenticationScheme = void 0;
-(function (AuthenticationScheme) {
-    AuthenticationScheme["BEARER"] = "Bearer";
-    AuthenticationScheme["POP"] = "pop";
-    AuthenticationScheme["SSH"] = "ssh-cert";
-})(exports.AuthenticationScheme || (exports.AuthenticationScheme = {}));
+const AuthenticationScheme = {
+    BEARER: "Bearer",
+    POP: "pop",
+    SSH: "ssh-cert",
+};
 /**
  * Constants related to throttling
  */
@@ -335,54 +312,48 @@ const Errors = {
 /**
  * Password grant parameters
  */
-exports.PasswordGrantConstants = void 0;
-(function (PasswordGrantConstants) {
-    PasswordGrantConstants["username"] = "username";
-    PasswordGrantConstants["password"] = "password";
-})(exports.PasswordGrantConstants || (exports.PasswordGrantConstants = {}));
+const PasswordGrantConstants = {
+    username: "username",
+    password: "password",
+};
 /**
  * Response codes
  */
-var ResponseCodes;
-(function (ResponseCodes) {
-    ResponseCodes[ResponseCodes["httpSuccess"] = 200] = "httpSuccess";
-    ResponseCodes[ResponseCodes["httpBadRequest"] = 400] = "httpBadRequest";
-})(ResponseCodes || (ResponseCodes = {}));
+const ResponseCodes = {
+    httpSuccess: 200,
+    httpBadRequest: 400,
+};
 /**
  * Region Discovery Sources
  */
-var RegionDiscoverySources;
-(function (RegionDiscoverySources) {
-    RegionDiscoverySources["FAILED_AUTO_DETECTION"] = "1";
-    RegionDiscoverySources["INTERNAL_CACHE"] = "2";
-    RegionDiscoverySources["ENVIRONMENT_VARIABLE"] = "3";
-    RegionDiscoverySources["IMDS"] = "4";
-})(RegionDiscoverySources || (RegionDiscoverySources = {}));
+const RegionDiscoverySources = {
+    FAILED_AUTO_DETECTION: "1",
+    INTERNAL_CACHE: "2",
+    ENVIRONMENT_VARIABLE: "3",
+    IMDS: "4",
+};
 /**
  * Region Discovery Outcomes
  */
-var RegionDiscoveryOutcomes;
-(function (RegionDiscoveryOutcomes) {
-    RegionDiscoveryOutcomes["CONFIGURED_MATCHES_DETECTED"] = "1";
-    RegionDiscoveryOutcomes["CONFIGURED_NO_AUTO_DETECTION"] = "2";
-    RegionDiscoveryOutcomes["CONFIGURED_NOT_DETECTED"] = "3";
-    RegionDiscoveryOutcomes["AUTO_DETECTION_REQUESTED_SUCCESSFUL"] = "4";
-    RegionDiscoveryOutcomes["AUTO_DETECTION_REQUESTED_FAILED"] = "5";
-})(RegionDiscoveryOutcomes || (RegionDiscoveryOutcomes = {}));
-exports.CacheOutcome = void 0;
-(function (CacheOutcome) {
-    CacheOutcome["NO_CACHE_HIT"] = "0";
-    CacheOutcome["FORCE_REFRESH"] = "1";
-    CacheOutcome["NO_CACHED_ACCESS_TOKEN"] = "2";
-    CacheOutcome["CACHED_ACCESS_TOKEN_EXPIRED"] = "3";
-    CacheOutcome["REFRESH_CACHED_ACCESS_TOKEN"] = "4";
-})(exports.CacheOutcome || (exports.CacheOutcome = {}));
-var JsonTypes;
-(function (JsonTypes) {
-    JsonTypes["Jwt"] = "JWT";
-    JsonTypes["Jwk"] = "JWK";
-    JsonTypes["Pop"] = "pop";
-})(JsonTypes || (JsonTypes = {}));
+const RegionDiscoveryOutcomes = {
+    CONFIGURED_MATCHES_DETECTED: "1",
+    CONFIGURED_NO_AUTO_DETECTION: "2",
+    CONFIGURED_NOT_DETECTED: "3",
+    AUTO_DETECTION_REQUESTED_SUCCESSFUL: "4",
+    AUTO_DETECTION_REQUESTED_FAILED: "5",
+};
+const CacheOutcome = {
+    NO_CACHE_HIT: "0",
+    FORCE_REFRESH: "1",
+    NO_CACHED_ACCESS_TOKEN: "2",
+    CACHED_ACCESS_TOKEN_EXPIRED: "3",
+    REFRESH_CACHED_ACCESS_TOKEN: "4",
+};
+const JsonTypes = {
+    Jwt: "JWT",
+    Jwk: "JWK",
+    Pop: "pop",
+};
 const ONE_DAY_IN_MS = 86400000;
 
 /*
@@ -1325,27 +1296,26 @@ class Logger {
 
 /* eslint-disable header/header */
 const name = "@azure/msal-common";
-const version = "14.0.0-alpha.2";
+const version = "14.0.0-beta.0";
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-exports.AzureCloudInstance = void 0;
-(function (AzureCloudInstance) {
+const AzureCloudInstance = {
     // AzureCloudInstance is not specified.
-    AzureCloudInstance[AzureCloudInstance["None"] = 0] = "None";
+    None: "none",
     // Microsoft Azure public cloud
-    AzureCloudInstance["AzurePublic"] = "https://login.microsoftonline.com";
+    AzurePublic: "https://login.microsoftonline.com",
     // Microsoft PPE
-    AzureCloudInstance["AzurePpe"] = "https://login.windows-ppe.net";
+    AzurePpe: "https://login.windows-ppe.net",
     // Microsoft Chinese national cloud
-    AzureCloudInstance["AzureChina"] = "https://login.chinacloudapi.cn";
+    AzureChina: "https://login.chinacloudapi.cn",
     // Microsoft German national cloud ("Black Forest")
-    AzureCloudInstance["AzureGermany"] = "https://login.microsoftonline.de";
+    AzureGermany: "https://login.microsoftonline.de",
     // US Government cloud
-    AzureCloudInstance["AzureUsGovernment"] = "https://login.microsoftonline.us";
-})(exports.AzureCloudInstance || (exports.AzureCloudInstance = {}));
+    AzureUsGovernment: "https://login.microsoftonline.us",
+};
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -1445,8 +1415,12 @@ const ClientConfigurationErrorMessage = {
     },
     invalidAuthenticationHeader: {
         code: "invalid_authentication_header",
-        desc: "Invalid authentication header provided",
+        desc: "Invalid authentication header provided"
     },
+    authorityMismatch: {
+        code: "authority_mismatch",
+        desc: "Authority mismatch error. Authority provided in login request or PublicClientApplication config does not match the environment of the provided account. Please use a matching account or make an interactive request to login to this authority."
+    }
 };
 /**
  * Error thrown when there is an error in configuration of the MSAL.js library.
@@ -1595,6 +1569,12 @@ class ClientConfigurationError extends ClientAuthError {
     static createInvalidAuthenticationHeaderError(invalidHeaderName, details) {
         return new ClientConfigurationError(ClientConfigurationErrorMessage.invalidAuthenticationHeader.code, `${ClientConfigurationErrorMessage.invalidAuthenticationHeader.desc}. Invalid header: ${invalidHeaderName}. Details: ${details}`);
     }
+    /**
+     * Create an error when the authority provided in request does not match authority provided in account or MSAL.js configuration.
+     */
+    static createAuthorityMismatchError() {
+        return new ClientConfigurationError(ClientConfigurationErrorMessage.authorityMismatch.code, ClientConfigurationErrorMessage.authorityMismatch.desc);
+    }
 }
 
 /*
@@ -1840,13 +1820,12 @@ function buildClientInfoFromHomeAccountId(homeAccountId) {
 /**
  * Authority types supported by MSAL.
  */
-exports.AuthorityType = void 0;
-(function (AuthorityType) {
-    AuthorityType[AuthorityType["Default"] = 0] = "Default";
-    AuthorityType[AuthorityType["Adfs"] = 1] = "Adfs";
-    AuthorityType[AuthorityType["Dsts"] = 2] = "Dsts";
-    AuthorityType[AuthorityType["Ciam"] = 3] = "Ciam";
-})(exports.AuthorityType || (exports.AuthorityType = {}));
+const AuthorityType = {
+    Default: 0,
+    Adfs: 1,
+    Dsts: 2,
+    Ciam: 3
+};
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -1900,14 +1879,14 @@ class AccountEntity {
      */
     generateType() {
         switch (this.authorityType) {
-            case exports.CacheAccountType.ADFS_ACCOUNT_TYPE:
-                return exports.CacheType.ADFS;
-            case exports.CacheAccountType.MSAV1_ACCOUNT_TYPE:
-                return exports.CacheType.MSA;
-            case exports.CacheAccountType.MSSTS_ACCOUNT_TYPE:
-                return exports.CacheType.MSSTS;
-            case exports.CacheAccountType.GENERIC_ACCOUNT_TYPE:
-                return exports.CacheType.GENERIC;
+            case CacheAccountType.ADFS_ACCOUNT_TYPE:
+                return CacheType.ADFS;
+            case CacheAccountType.MSAV1_ACCOUNT_TYPE:
+                return CacheType.MSA;
+            case CacheAccountType.MSSTS_ACCOUNT_TYPE:
+                return CacheType.MSSTS;
+            case CacheAccountType.GENERIC_ACCOUNT_TYPE:
+                return CacheType.GENERIC;
             default: {
                 throw ClientAuthError.createUnexpectedAccountTypeError();
             }
@@ -1949,7 +1928,7 @@ class AccountEntity {
      */
     static createAccount(clientInfo, homeAccountId, idToken, authority, cloudGraphHostName, msGraphHost, environment, nativeAccountId) {
         const account = new AccountEntity();
-        account.authorityType = exports.CacheAccountType.MSSTS_ACCOUNT_TYPE;
+        account.authorityType = CacheAccountType.MSSTS_ACCOUNT_TYPE;
         account.clientInfo = clientInfo;
         account.homeAccountId = homeAccountId;
         account.nativeAccountId = nativeAccountId;
@@ -1992,9 +1971,9 @@ class AccountEntity {
     static createGenericAccount(homeAccountId, idToken, authority, cloudGraphHostName, msGraphHost, environment) {
         const account = new AccountEntity();
         account.authorityType =
-            authority && authority.authorityType === exports.AuthorityType.Adfs
-                ? exports.CacheAccountType.ADFS_ACCOUNT_TYPE
-                : exports.CacheAccountType.GENERIC_ACCOUNT_TYPE;
+            authority && authority.authorityType === AuthorityType.Adfs
+                ? CacheAccountType.ADFS_ACCOUNT_TYPE
+                : CacheAccountType.GENERIC_ACCOUNT_TYPE;
         account.homeAccountId = homeAccountId;
         // non AAD scenarios can have empty realm
         account.realm = Constants.EMPTY_STRING;
@@ -2032,8 +2011,8 @@ class AccountEntity {
             ? idToken.claims.sub
             : Constants.EMPTY_STRING;
         // since ADFS does not have tid and does not set client_info
-        if (authType === exports.AuthorityType.Adfs ||
-            authType === exports.AuthorityType.Dsts) {
+        if (authType === AuthorityType.Adfs ||
+            authType === AuthorityType.Dsts) {
             return accountId;
         }
         // for cases where there is clientInfo
@@ -2343,20 +2322,20 @@ class CacheManager {
         }
         const lowerCaseKey = key.toLowerCase();
         // Credential keys must indicate what credential type they represent
-        if (lowerCaseKey.indexOf(exports.CredentialType.ID_TOKEN.toLowerCase()) ===
+        if (lowerCaseKey.indexOf(CredentialType.ID_TOKEN.toLowerCase()) ===
             -1 &&
-            lowerCaseKey.indexOf(exports.CredentialType.ACCESS_TOKEN.toLowerCase()) ===
+            lowerCaseKey.indexOf(CredentialType.ACCESS_TOKEN.toLowerCase()) ===
                 -1 &&
-            lowerCaseKey.indexOf(exports.CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME.toLowerCase()) === -1 &&
-            lowerCaseKey.indexOf(exports.CredentialType.REFRESH_TOKEN.toLowerCase()) ===
+            lowerCaseKey.indexOf(CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME.toLowerCase()) === -1 &&
+            lowerCaseKey.indexOf(CredentialType.REFRESH_TOKEN.toLowerCase()) ===
                 -1) {
             return false;
         }
-        if (lowerCaseKey.indexOf(exports.CredentialType.REFRESH_TOKEN.toLowerCase()) >
+        if (lowerCaseKey.indexOf(CredentialType.REFRESH_TOKEN.toLowerCase()) >
             -1) {
             // Refresh tokens must contain the client id or family id
-            const clientIdValidation = `${exports.CredentialType.REFRESH_TOKEN}${Separators.CACHE_KEY_SEPARATOR}${this.clientId}${Separators.CACHE_KEY_SEPARATOR}`;
-            const familyIdValidation = `${exports.CredentialType.REFRESH_TOKEN}${Separators.CACHE_KEY_SEPARATOR}${THE_FAMILY_ID}${Separators.CACHE_KEY_SEPARATOR}`;
+            const clientIdValidation = `${CredentialType.REFRESH_TOKEN}${Separators.CACHE_KEY_SEPARATOR}${this.clientId}${Separators.CACHE_KEY_SEPARATOR}`;
+            const familyIdValidation = `${CredentialType.REFRESH_TOKEN}${Separators.CACHE_KEY_SEPARATOR}${THE_FAMILY_ID}${Separators.CACHE_KEY_SEPARATOR}`;
             if (lowerCaseKey.indexOf(clientIdValidation.toLowerCase()) === -1 &&
                 lowerCaseKey.indexOf(familyIdValidation.toLowerCase()) === -1) {
                 return false;
@@ -2420,13 +2399,13 @@ class CacheManager {
         }
         // Access Token with Auth Scheme specific matching
         if (entity.credentialType ===
-            exports.CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME) {
+            CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME) {
             if (!!filter.tokenType &&
                 !this.matchTokenType(entity, filter.tokenType)) {
                 return false;
             }
             // KeyId (sshKid) in request must match cached SSH certificate keyId because SSH cert is bound to a specific key
-            if (filter.tokenType === exports.AuthenticationScheme.SSH) {
+            if (filter.tokenType === AuthenticationScheme.SSH) {
                 if (filter.keyId && !this.matchKeyId(entity, filter.keyId)) {
                     return false;
                 }
@@ -2553,8 +2532,8 @@ class CacheManager {
         }
         // Remove Token Binding Key from key store for PoP Tokens Credentials
         if (credential.credentialType.toLowerCase() ===
-            exports.CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME.toLowerCase()) {
-            if (credential.tokenType === exports.AuthenticationScheme.POP) {
+            CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME.toLowerCase()) {
+            if (credential.tokenType === AuthenticationScheme.POP) {
                 const accessTokenWithAuthSchemeEntity = credential;
                 const kid = accessTokenWithAuthSchemeEntity.keyId;
                 if (kid) {
@@ -2626,7 +2605,7 @@ class CacheManager {
         const idTokenFilter = {
             homeAccountId: account.homeAccountId,
             environment: account.environment,
-            credentialType: exports.CredentialType.ID_TOKEN,
+            credentialType: CredentialType.ID_TOKEN,
             clientId: this.clientId,
             realm: account.tenantId,
         };
@@ -2706,16 +2685,16 @@ class CacheManager {
     getAccessToken(account, request, tokenKeys) {
         this.commonLogger.trace("CacheManager - getAccessToken called");
         const scopes = ScopeSet.createSearchScopes(request.scopes);
-        const authScheme = request.authenticationScheme || exports.AuthenticationScheme.BEARER;
+        const authScheme = request.authenticationScheme || AuthenticationScheme.BEARER;
         /*
          * Distinguish between Bearer and PoP/SSH token cache types
          * Cast to lowercase to handle "bearer" from ADFS
          */
         const credentialType = authScheme &&
             authScheme.toLowerCase() !==
-                exports.AuthenticationScheme.BEARER.toLowerCase()
-            ? exports.CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME
-            : exports.CredentialType.ACCESS_TOKEN;
+                AuthenticationScheme.BEARER.toLowerCase()
+            ? CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME
+            : CredentialType.ACCESS_TOKEN;
         const accessTokenFilter = {
             homeAccountId: account.homeAccountId,
             environment: account.environment,
@@ -2825,7 +2804,7 @@ class CacheManager {
         const refreshTokenFilter = {
             homeAccountId: account.homeAccountId,
             environment: account.environment,
-            credentialType: exports.CredentialType.REFRESH_TOKEN,
+            credentialType: CredentialType.REFRESH_TOKEN,
             clientId: this.clientId,
             familyId: id,
         };
@@ -3002,9 +2981,9 @@ class CacheManager {
      * @param target
      */
     matchTarget(entity, target) {
-        const isNotAccessTokenCredential = entity.credentialType !== exports.CredentialType.ACCESS_TOKEN &&
+        const isNotAccessTokenCredential = entity.credentialType !== CredentialType.ACCESS_TOKEN &&
             entity.credentialType !==
-                exports.CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME;
+                CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME;
         if (isNotAccessTokenCredential || !entity.target) {
             return false;
         }
@@ -3197,7 +3176,7 @@ const DEFAULT_CLIENT_CREDENTIALS = {
     clientAssertion: undefined,
 };
 const DEFAULT_AZURE_CLOUD_OPTIONS = {
-    azureCloudInstance: exports.AzureCloudInstance.None,
+    azureCloudInstance: AzureCloudInstance.None,
     tenant: `${Constants.DEFAULT_COMMON_TENANT}`,
 };
 const DEFAULT_TELEMETRY_OPTIONS = {
@@ -3300,7 +3279,7 @@ class ThrottlingUtils {
         if (ThrottlingUtils.checkResponseStatus(response) ||
             ThrottlingUtils.checkResponseForRetryAfter(response)) {
             const thumbprintValue = {
-                throttleTime: ThrottlingUtils.calculateThrottleTime(parseInt(response.headers[exports.HeaderNames.RETRY_AFTER])),
+                throttleTime: ThrottlingUtils.calculateThrottleTime(parseInt(response.headers[HeaderNames.RETRY_AFTER])),
                 error: response.body.error,
                 errorCodes: response.body.error_codes,
                 errorMessage: response.body.error_description,
@@ -3323,7 +3302,7 @@ class ThrottlingUtils {
      */
     static checkResponseForRetryAfter(response) {
         if (response.headers) {
-            return (response.headers.hasOwnProperty(exports.HeaderNames.RETRY_AFTER) &&
+            return (response.headers.hasOwnProperty(HeaderNames.RETRY_AFTER) &&
                 (response.status < 200 || response.status >= 300));
         }
         return false;
@@ -3395,11 +3374,10 @@ class NetworkManager {
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-exports.CcsCredentialType = void 0;
-(function (CcsCredentialType) {
-    CcsCredentialType["HOME_ACCOUNT_ID"] = "home_account_id";
-    CcsCredentialType["UPN"] = "UPN";
-})(exports.CcsCredentialType || (exports.CcsCredentialType = {}));
+const CcsCredentialType = {
+    HOME_ACCOUNT_ID: "home_account_id",
+    UPN: "UPN",
+};
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -3480,8 +3458,7 @@ class RequestValidator {
             }
         });
         // remove empty string parameters
-        return Object.fromEntries(Object.entries(eQParams).filter(([key, value]) => value !== "") // eslint-disable-line @typescript-eslint/no-unused-vars
-        );
+        return Object.fromEntries(Object.entries(eQParams).filter(kv => kv[1] !== ""));
     }
 }
 
@@ -3497,26 +3474,26 @@ class RequestParameterBuilder {
      * add response_type = code
      */
     addResponseTypeCode() {
-        this.parameters.set(exports.AADServerParamKeys.RESPONSE_TYPE, encodeURIComponent(Constants.CODE_RESPONSE_TYPE));
+        this.parameters.set(AADServerParamKeys.RESPONSE_TYPE, encodeURIComponent(Constants.CODE_RESPONSE_TYPE));
     }
     /**
      * add response_type = token id_token
      */
     addResponseTypeForTokenAndIdToken() {
-        this.parameters.set(exports.AADServerParamKeys.RESPONSE_TYPE, encodeURIComponent(`${Constants.TOKEN_RESPONSE_TYPE} ${Constants.ID_TOKEN_RESPONSE_TYPE}`));
+        this.parameters.set(AADServerParamKeys.RESPONSE_TYPE, encodeURIComponent(`${Constants.TOKEN_RESPONSE_TYPE} ${Constants.ID_TOKEN_RESPONSE_TYPE}`));
     }
     /**
      * add response_mode. defaults to query.
      * @param responseMode
      */
     addResponseMode(responseMode) {
-        this.parameters.set(exports.AADServerParamKeys.RESPONSE_MODE, encodeURIComponent(responseMode ? responseMode : exports.ResponseMode.QUERY));
+        this.parameters.set(AADServerParamKeys.RESPONSE_MODE, encodeURIComponent(responseMode ? responseMode : ResponseMode.QUERY));
     }
     /**
      * Add flag to indicate STS should attempt to use WAM if available
      */
     addNativeBroker() {
-        this.parameters.set(exports.AADServerParamKeys.NATIVE_BROKER, encodeURIComponent("1"));
+        this.parameters.set(AADServerParamKeys.NATIVE_BROKER, encodeURIComponent("1"));
     }
     /**
      * add scopes. set addOidcScopes to false to prevent default scopes in non-user scenarios
@@ -3528,14 +3505,14 @@ class RequestParameterBuilder {
             ? [...(scopes || []), ...OIDC_DEFAULT_SCOPES]
             : scopes || [];
         const scopeSet = new ScopeSet(requestScopes);
-        this.parameters.set(exports.AADServerParamKeys.SCOPE, encodeURIComponent(scopeSet.printScopes()));
+        this.parameters.set(AADServerParamKeys.SCOPE, encodeURIComponent(scopeSet.printScopes()));
     }
     /**
      * add clientId
      * @param clientId
      */
     addClientId(clientId) {
-        this.parameters.set(exports.AADServerParamKeys.CLIENT_ID, encodeURIComponent(clientId));
+        this.parameters.set(AADServerParamKeys.CLIENT_ID, encodeURIComponent(clientId));
     }
     /**
      * add redirect_uri
@@ -3543,7 +3520,7 @@ class RequestParameterBuilder {
      */
     addRedirectUri(redirectUri) {
         RequestValidator.validateRedirectUri(redirectUri);
-        this.parameters.set(exports.AADServerParamKeys.REDIRECT_URI, encodeURIComponent(redirectUri));
+        this.parameters.set(AADServerParamKeys.REDIRECT_URI, encodeURIComponent(redirectUri));
     }
     /**
      * add post logout redirectUri
@@ -3551,49 +3528,49 @@ class RequestParameterBuilder {
      */
     addPostLogoutRedirectUri(redirectUri) {
         RequestValidator.validateRedirectUri(redirectUri);
-        this.parameters.set(exports.AADServerParamKeys.POST_LOGOUT_URI, encodeURIComponent(redirectUri));
+        this.parameters.set(AADServerParamKeys.POST_LOGOUT_URI, encodeURIComponent(redirectUri));
     }
     /**
      * add id_token_hint to logout request
      * @param idTokenHint
      */
     addIdTokenHint(idTokenHint) {
-        this.parameters.set(exports.AADServerParamKeys.ID_TOKEN_HINT, encodeURIComponent(idTokenHint));
+        this.parameters.set(AADServerParamKeys.ID_TOKEN_HINT, encodeURIComponent(idTokenHint));
     }
     /**
      * add domain_hint
      * @param domainHint
      */
     addDomainHint(domainHint) {
-        this.parameters.set(exports.SSOTypes.DOMAIN_HINT, encodeURIComponent(domainHint));
+        this.parameters.set(SSOTypes.DOMAIN_HINT, encodeURIComponent(domainHint));
     }
     /**
      * add login_hint
      * @param loginHint
      */
     addLoginHint(loginHint) {
-        this.parameters.set(exports.SSOTypes.LOGIN_HINT, encodeURIComponent(loginHint));
+        this.parameters.set(SSOTypes.LOGIN_HINT, encodeURIComponent(loginHint));
     }
     /**
      * Adds the CCS (Cache Credential Service) query parameter for login_hint
      * @param loginHint
      */
     addCcsUpn(loginHint) {
-        this.parameters.set(exports.HeaderNames.CCS_HEADER, encodeURIComponent(`UPN:${loginHint}`));
+        this.parameters.set(HeaderNames.CCS_HEADER, encodeURIComponent(`UPN:${loginHint}`));
     }
     /**
      * Adds the CCS (Cache Credential Service) query parameter for account object
      * @param loginHint
      */
     addCcsOid(clientInfo) {
-        this.parameters.set(exports.HeaderNames.CCS_HEADER, encodeURIComponent(`Oid:${clientInfo.uid}@${clientInfo.utid}`));
+        this.parameters.set(HeaderNames.CCS_HEADER, encodeURIComponent(`Oid:${clientInfo.uid}@${clientInfo.utid}`));
     }
     /**
      * add sid
      * @param sid
      */
     addSid(sid) {
-        this.parameters.set(exports.SSOTypes.SID, encodeURIComponent(sid));
+        this.parameters.set(SSOTypes.SID, encodeURIComponent(sid));
     }
     /**
      * add claims
@@ -3602,14 +3579,14 @@ class RequestParameterBuilder {
     addClaims(claims, clientCapabilities) {
         const mergedClaims = this.addClientCapabilitiesToClaims(claims, clientCapabilities);
         RequestValidator.validateClaims(mergedClaims);
-        this.parameters.set(exports.AADServerParamKeys.CLAIMS, encodeURIComponent(mergedClaims));
+        this.parameters.set(AADServerParamKeys.CLAIMS, encodeURIComponent(mergedClaims));
     }
     /**
      * add correlationId
      * @param correlationId
      */
     addCorrelationId(correlationId) {
-        this.parameters.set(exports.AADServerParamKeys.CLIENT_REQUEST_ID, encodeURIComponent(correlationId));
+        this.parameters.set(AADServerParamKeys.CLIENT_REQUEST_ID, encodeURIComponent(correlationId));
     }
     /**
      * add library info query params
@@ -3617,13 +3594,13 @@ class RequestParameterBuilder {
      */
     addLibraryInfo(libraryInfo) {
         // Telemetry Info
-        this.parameters.set(exports.AADServerParamKeys.X_CLIENT_SKU, libraryInfo.sku);
-        this.parameters.set(exports.AADServerParamKeys.X_CLIENT_VER, libraryInfo.version);
+        this.parameters.set(AADServerParamKeys.X_CLIENT_SKU, libraryInfo.sku);
+        this.parameters.set(AADServerParamKeys.X_CLIENT_VER, libraryInfo.version);
         if (libraryInfo.os) {
-            this.parameters.set(exports.AADServerParamKeys.X_CLIENT_OS, libraryInfo.os);
+            this.parameters.set(AADServerParamKeys.X_CLIENT_OS, libraryInfo.os);
         }
         if (libraryInfo.cpu) {
-            this.parameters.set(exports.AADServerParamKeys.X_CLIENT_CPU, libraryInfo.cpu);
+            this.parameters.set(AADServerParamKeys.X_CLIENT_CPU, libraryInfo.cpu);
         }
     }
     /**
@@ -3632,10 +3609,10 @@ class RequestParameterBuilder {
      */
     addApplicationTelemetry(appTelemetry) {
         if (appTelemetry?.appName) {
-            this.parameters.set(exports.AADServerParamKeys.X_APP_NAME, appTelemetry.appName);
+            this.parameters.set(AADServerParamKeys.X_APP_NAME, appTelemetry.appName);
         }
         if (appTelemetry?.appVersion) {
-            this.parameters.set(exports.AADServerParamKeys.X_APP_VER, appTelemetry.appVersion);
+            this.parameters.set(AADServerParamKeys.X_APP_VER, appTelemetry.appVersion);
         }
     }
     /**
@@ -3644,7 +3621,7 @@ class RequestParameterBuilder {
      */
     addPrompt(prompt) {
         RequestValidator.validatePrompt(prompt);
-        this.parameters.set(`${exports.AADServerParamKeys.PROMPT}`, encodeURIComponent(prompt));
+        this.parameters.set(`${AADServerParamKeys.PROMPT}`, encodeURIComponent(prompt));
     }
     /**
      * add state
@@ -3652,7 +3629,7 @@ class RequestParameterBuilder {
      */
     addState(state) {
         if (!StringUtils.isEmpty(state)) {
-            this.parameters.set(exports.AADServerParamKeys.STATE, encodeURIComponent(state));
+            this.parameters.set(AADServerParamKeys.STATE, encodeURIComponent(state));
         }
     }
     /**
@@ -3660,7 +3637,7 @@ class RequestParameterBuilder {
      * @param nonce
      */
     addNonce(nonce) {
-        this.parameters.set(exports.AADServerParamKeys.NONCE, encodeURIComponent(nonce));
+        this.parameters.set(AADServerParamKeys.NONCE, encodeURIComponent(nonce));
     }
     /**
      * add code_challenge and code_challenge_method
@@ -3671,8 +3648,8 @@ class RequestParameterBuilder {
     addCodeChallengeParams(codeChallenge, codeChallengeMethod) {
         RequestValidator.validateCodeChallengeParams(codeChallenge, codeChallengeMethod);
         if (codeChallenge && codeChallengeMethod) {
-            this.parameters.set(exports.AADServerParamKeys.CODE_CHALLENGE, encodeURIComponent(codeChallenge));
-            this.parameters.set(exports.AADServerParamKeys.CODE_CHALLENGE_METHOD, encodeURIComponent(codeChallengeMethod));
+            this.parameters.set(AADServerParamKeys.CODE_CHALLENGE, encodeURIComponent(codeChallenge));
+            this.parameters.set(AADServerParamKeys.CODE_CHALLENGE_METHOD, encodeURIComponent(codeChallengeMethod));
         }
         else {
             throw ClientConfigurationError.createInvalidCodeChallengeParamsError();
@@ -3683,35 +3660,35 @@ class RequestParameterBuilder {
      * @param code
      */
     addAuthorizationCode(code) {
-        this.parameters.set(exports.AADServerParamKeys.CODE, encodeURIComponent(code));
+        this.parameters.set(AADServerParamKeys.CODE, encodeURIComponent(code));
     }
     /**
      * add the `authorization_code` passed by the user to exchange for a token
      * @param code
      */
     addDeviceCode(code) {
-        this.parameters.set(exports.AADServerParamKeys.DEVICE_CODE, encodeURIComponent(code));
+        this.parameters.set(AADServerParamKeys.DEVICE_CODE, encodeURIComponent(code));
     }
     /**
      * add the `refreshToken` passed by the user
      * @param refreshToken
      */
     addRefreshToken(refreshToken) {
-        this.parameters.set(exports.AADServerParamKeys.REFRESH_TOKEN, encodeURIComponent(refreshToken));
+        this.parameters.set(AADServerParamKeys.REFRESH_TOKEN, encodeURIComponent(refreshToken));
     }
     /**
      * add the `code_verifier` passed by the user to exchange for a token
      * @param codeVerifier
      */
     addCodeVerifier(codeVerifier) {
-        this.parameters.set(exports.AADServerParamKeys.CODE_VERIFIER, encodeURIComponent(codeVerifier));
+        this.parameters.set(AADServerParamKeys.CODE_VERIFIER, encodeURIComponent(codeVerifier));
     }
     /**
      * add client_secret
      * @param clientSecret
      */
     addClientSecret(clientSecret) {
-        this.parameters.set(exports.AADServerParamKeys.CLIENT_SECRET, encodeURIComponent(clientSecret));
+        this.parameters.set(AADServerParamKeys.CLIENT_SECRET, encodeURIComponent(clientSecret));
     }
     /**
      * add clientAssertion for confidential client flows
@@ -3719,7 +3696,7 @@ class RequestParameterBuilder {
      */
     addClientAssertion(clientAssertion) {
         if (!StringUtils.isEmpty(clientAssertion)) {
-            this.parameters.set(exports.AADServerParamKeys.CLIENT_ASSERTION, encodeURIComponent(clientAssertion));
+            this.parameters.set(AADServerParamKeys.CLIENT_ASSERTION, encodeURIComponent(clientAssertion));
         }
     }
     /**
@@ -3728,7 +3705,7 @@ class RequestParameterBuilder {
      */
     addClientAssertionType(clientAssertionType) {
         if (!StringUtils.isEmpty(clientAssertionType)) {
-            this.parameters.set(exports.AADServerParamKeys.CLIENT_ASSERTION_TYPE, encodeURIComponent(clientAssertionType));
+            this.parameters.set(AADServerParamKeys.CLIENT_ASSERTION_TYPE, encodeURIComponent(clientAssertionType));
         }
     }
     /**
@@ -3736,21 +3713,21 @@ class RequestParameterBuilder {
      * @param clientAssertion
      */
     addOboAssertion(oboAssertion) {
-        this.parameters.set(exports.AADServerParamKeys.OBO_ASSERTION, encodeURIComponent(oboAssertion));
+        this.parameters.set(AADServerParamKeys.OBO_ASSERTION, encodeURIComponent(oboAssertion));
     }
     /**
      * add grant type
      * @param grantType
      */
     addRequestTokenUse(tokenUse) {
-        this.parameters.set(exports.AADServerParamKeys.REQUESTED_TOKEN_USE, encodeURIComponent(tokenUse));
+        this.parameters.set(AADServerParamKeys.REQUESTED_TOKEN_USE, encodeURIComponent(tokenUse));
     }
     /**
      * add grant type
      * @param grantType
      */
     addGrantType(grantType) {
-        this.parameters.set(exports.AADServerParamKeys.GRANT_TYPE, encodeURIComponent(grantType));
+        this.parameters.set(AADServerParamKeys.GRANT_TYPE, encodeURIComponent(grantType));
     }
     /**
      * add client info
@@ -3784,12 +3761,12 @@ class RequestParameterBuilder {
             }
         }
         if (clientCapabilities && clientCapabilities.length > 0) {
-            if (!mergedClaims.hasOwnProperty(exports.ClaimsRequestKeys.ACCESS_TOKEN)) {
+            if (!mergedClaims.hasOwnProperty(ClaimsRequestKeys.ACCESS_TOKEN)) {
                 // Add access_token key to claims object
-                mergedClaims[exports.ClaimsRequestKeys.ACCESS_TOKEN] = {};
+                mergedClaims[ClaimsRequestKeys.ACCESS_TOKEN] = {};
             }
             // Add xms_cc claim with provided clientCapabilities to access_token key
-            mergedClaims[exports.ClaimsRequestKeys.ACCESS_TOKEN][exports.ClaimsRequestKeys.XMS_CC] = {
+            mergedClaims[ClaimsRequestKeys.ACCESS_TOKEN][ClaimsRequestKeys.XMS_CC] = {
                 values: clientCapabilities,
             };
         }
@@ -3800,14 +3777,14 @@ class RequestParameterBuilder {
      * @param username
      */
     addUsername(username) {
-        this.parameters.set(exports.PasswordGrantConstants.username, encodeURIComponent(username));
+        this.parameters.set(PasswordGrantConstants.username, encodeURIComponent(username));
     }
     /**
      * adds `password` for Password Grant flow
      * @param password
      */
     addPassword(password) {
-        this.parameters.set(exports.PasswordGrantConstants.password, encodeURIComponent(password));
+        this.parameters.set(PasswordGrantConstants.password, encodeURIComponent(password));
     }
     /**
      * add pop_jwk to query params
@@ -3815,8 +3792,8 @@ class RequestParameterBuilder {
      */
     addPopToken(cnfString) {
         if (!StringUtils.isEmpty(cnfString)) {
-            this.parameters.set(exports.AADServerParamKeys.TOKEN_TYPE, exports.AuthenticationScheme.POP);
-            this.parameters.set(exports.AADServerParamKeys.REQ_CNF, encodeURIComponent(cnfString));
+            this.parameters.set(AADServerParamKeys.TOKEN_TYPE, AuthenticationScheme.POP);
+            this.parameters.set(AADServerParamKeys.REQ_CNF, encodeURIComponent(cnfString));
         }
     }
     /**
@@ -3824,8 +3801,8 @@ class RequestParameterBuilder {
      */
     addSshJwk(sshJwkString) {
         if (!StringUtils.isEmpty(sshJwkString)) {
-            this.parameters.set(exports.AADServerParamKeys.TOKEN_TYPE, exports.AuthenticationScheme.SSH);
-            this.parameters.set(exports.AADServerParamKeys.REQ_CNF, encodeURIComponent(sshJwkString));
+            this.parameters.set(AADServerParamKeys.TOKEN_TYPE, AuthenticationScheme.SSH);
+            this.parameters.set(AADServerParamKeys.REQ_CNF, encodeURIComponent(sshJwkString));
         }
     }
     /**
@@ -3833,20 +3810,20 @@ class RequestParameterBuilder {
      * @param serverTelemetryManager
      */
     addServerTelemetry(serverTelemetryManager) {
-        this.parameters.set(exports.AADServerParamKeys.X_CLIENT_CURR_TELEM, serverTelemetryManager.generateCurrentRequestHeaderValue());
-        this.parameters.set(exports.AADServerParamKeys.X_CLIENT_LAST_TELEM, serverTelemetryManager.generateLastRequestHeaderValue());
+        this.parameters.set(AADServerParamKeys.X_CLIENT_CURR_TELEM, serverTelemetryManager.generateCurrentRequestHeaderValue());
+        this.parameters.set(AADServerParamKeys.X_CLIENT_LAST_TELEM, serverTelemetryManager.generateLastRequestHeaderValue());
     }
     /**
      * Adds parameter that indicates to the server that throttling is supported
      */
     addThrottling() {
-        this.parameters.set(exports.AADServerParamKeys.X_MS_LIB_CAPABILITY, ThrottlingConstants.X_MS_LIB_CAPABILITY_VALUE);
+        this.parameters.set(AADServerParamKeys.X_MS_LIB_CAPABILITY, ThrottlingConstants.X_MS_LIB_CAPABILITY_VALUE);
     }
     /**
      * Adds logout_hint parameter for "silent" logout which prevent server account picker
      */
     addLogoutHint(logoutHint) {
-        this.parameters.set(exports.AADServerParamKeys.LOGOUT_HINT, encodeURIComponent(logoutHint));
+        this.parameters.set(AADServerParamKeys.LOGOUT_HINT, encodeURIComponent(logoutHint));
     }
     /**
      * Utility to create a URL from the params map
@@ -3893,21 +3870,21 @@ class BaseClient {
      */
     createTokenRequestHeaders(ccsCred) {
         const headers = {};
-        headers[exports.HeaderNames.CONTENT_TYPE] = Constants.URL_FORM_CONTENT_TYPE;
+        headers[HeaderNames.CONTENT_TYPE] = Constants.URL_FORM_CONTENT_TYPE;
         if (!this.config.systemOptions.preventCorsPreflight && ccsCred) {
             switch (ccsCred.type) {
-                case exports.CcsCredentialType.HOME_ACCOUNT_ID:
+                case CcsCredentialType.HOME_ACCOUNT_ID:
                     try {
                         const clientInfo = buildClientInfoFromHomeAccountId(ccsCred.credential);
-                        headers[exports.HeaderNames.CCS_HEADER] = `Oid:${clientInfo.uid}@${clientInfo.utid}`;
+                        headers[HeaderNames.CCS_HEADER] = `Oid:${clientInfo.uid}@${clientInfo.utid}`;
                     }
                     catch (e) {
                         this.logger.verbose("Could not parse home account ID for CCS Header: " +
                             e);
                     }
                     break;
-                case exports.CcsCredentialType.UPN:
-                    headers[exports.HeaderNames.CCS_HEADER] = `UPN: ${ccsCred.credential}`;
+                case CcsCredentialType.UPN:
+                    headers[HeaderNames.CCS_HEADER] = `UPN: ${ccsCred.credential}`;
                     break;
             }
         }
@@ -4009,13 +3986,13 @@ class CredentialEntity {
      */
     generateType() {
         switch (this.credentialType) {
-            case exports.CredentialType.ID_TOKEN:
-                return exports.CacheType.ID_TOKEN;
-            case exports.CredentialType.ACCESS_TOKEN:
-            case exports.CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME:
-                return exports.CacheType.ACCESS_TOKEN;
-            case exports.CredentialType.REFRESH_TOKEN:
-                return exports.CacheType.REFRESH_TOKEN;
+            case CredentialType.ID_TOKEN:
+                return CacheType.ID_TOKEN;
+            case CredentialType.ACCESS_TOKEN:
+            case CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME:
+                return CacheType.ACCESS_TOKEN;
+            case CredentialType.REFRESH_TOKEN:
+                return CacheType.REFRESH_TOKEN;
             default: {
                 throw ClientAuthError.createUnexpectedCredentialTypeError();
             }
@@ -4052,7 +4029,7 @@ class CredentialEntity {
      * @param familyId
      */
     static generateCredentialIdForCacheKey(credentialType, clientId, realm, familyId) {
-        const clientOrFamilyId = credentialType === exports.CredentialType.REFRESH_TOKEN
+        const clientOrFamilyId = credentialType === CredentialType.REFRESH_TOKEN
             ? familyId || clientId
             : clientId;
         const credentialId = [
@@ -4084,7 +4061,7 @@ class CredentialEntity {
          */
         return tokenType &&
             tokenType.toLowerCase() !==
-                exports.AuthenticationScheme.BEARER.toLowerCase()
+                AuthenticationScheme.BEARER.toLowerCase()
             ? tokenType.toLowerCase()
             : Constants.EMPTY_STRING;
     }
@@ -4121,7 +4098,7 @@ class IdTokenEntity extends CredentialEntity {
      */
     static createIdTokenEntity(homeAccountId, environment, idToken, clientId, tenantId) {
         const idTokenEntity = new IdTokenEntity();
-        idTokenEntity.credentialType = exports.CredentialType.ID_TOKEN;
+        idTokenEntity.credentialType = CredentialType.ID_TOKEN;
         idTokenEntity.homeAccountId = homeAccountId;
         idTokenEntity.environment = environment;
         idTokenEntity.clientId = clientId;
@@ -4143,7 +4120,7 @@ class IdTokenEntity extends CredentialEntity {
             entity.hasOwnProperty("realm") &&
             entity.hasOwnProperty("clientId") &&
             entity.hasOwnProperty("secret") &&
-            entity["credentialType"] === exports.CredentialType.ID_TOKEN);
+            entity["credentialType"] === CredentialType.ID_TOKEN);
     }
 }
 
@@ -4236,7 +4213,7 @@ class AccessTokenEntity extends CredentialEntity {
     static createAccessTokenEntity(homeAccountId, environment, accessToken, clientId, tenantId, scopes, expiresOn, extExpiresOn, cryptoUtils, refreshOn, tokenType, userAssertionHash, keyId, requestedClaims, requestedClaimsHash) {
         const atEntity = new AccessTokenEntity();
         atEntity.homeAccountId = homeAccountId;
-        atEntity.credentialType = exports.CredentialType.ACCESS_TOKEN;
+        atEntity.credentialType = CredentialType.ACCESS_TOKEN;
         atEntity.secret = accessToken;
         const currentTime = TimeUtils.nowSeconds();
         atEntity.cachedAt = currentTime.toString();
@@ -4255,7 +4232,7 @@ class AccessTokenEntity extends CredentialEntity {
         atEntity.target = scopes;
         atEntity.userAssertionHash = userAssertionHash;
         atEntity.tokenType = StringUtils.isEmpty(tokenType)
-            ? exports.AuthenticationScheme.BEARER
+            ? AuthenticationScheme.BEARER
             : tokenType;
         if (requestedClaims) {
             atEntity.requestedClaims = requestedClaims;
@@ -4266,11 +4243,11 @@ class AccessTokenEntity extends CredentialEntity {
          * Cast to lower to handle "bearer" from ADFS
          */
         if (atEntity.tokenType?.toLowerCase() !==
-            exports.AuthenticationScheme.BEARER.toLowerCase()) {
+            AuthenticationScheme.BEARER.toLowerCase()) {
             atEntity.credentialType =
-                exports.CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME;
+                CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME;
             switch (atEntity.tokenType) {
-                case exports.AuthenticationScheme.POP:
+                case AuthenticationScheme.POP:
                     // Make sure keyId is present and add it to credential
                     const tokenClaims = AuthToken.extractTokenClaims(accessToken, cryptoUtils);
                     if (!tokenClaims?.cnf?.kid) {
@@ -4278,7 +4255,7 @@ class AccessTokenEntity extends CredentialEntity {
                     }
                     atEntity.keyId = tokenClaims.cnf.kid;
                     break;
-                case exports.AuthenticationScheme.SSH:
+                case AuthenticationScheme.SSH:
                     atEntity.keyId = keyId;
             }
         }
@@ -4299,9 +4276,9 @@ class AccessTokenEntity extends CredentialEntity {
             entity.hasOwnProperty("clientId") &&
             entity.hasOwnProperty("secret") &&
             entity.hasOwnProperty("target") &&
-            (entity["credentialType"] === exports.CredentialType.ACCESS_TOKEN ||
+            (entity["credentialType"] === CredentialType.ACCESS_TOKEN ||
                 entity["credentialType"] ===
-                    exports.CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME));
+                    CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME));
     }
 }
 
@@ -4339,7 +4316,7 @@ class RefreshTokenEntity extends CredentialEntity {
     static createRefreshTokenEntity(homeAccountId, environment, refreshToken, clientId, familyId, userAssertionHash) {
         const rtEntity = new RefreshTokenEntity();
         rtEntity.clientId = clientId;
-        rtEntity.credentialType = exports.CredentialType.REFRESH_TOKEN;
+        rtEntity.credentialType = CredentialType.REFRESH_TOKEN;
         rtEntity.environment = environment;
         rtEntity.homeAccountId = homeAccountId;
         rtEntity.secret = refreshToken;
@@ -4361,7 +4338,7 @@ class RefreshTokenEntity extends CredentialEntity {
             entity.hasOwnProperty("credentialType") &&
             entity.hasOwnProperty("clientId") &&
             entity.hasOwnProperty("secret") &&
-            entity["credentialType"] === exports.CredentialType.REFRESH_TOKEN);
+            entity["credentialType"] === CredentialType.REFRESH_TOKEN);
     }
 }
 
@@ -4623,8 +4600,8 @@ class UrlString {
         const pathArray = urlObject.PathSegments;
         if (tenantId &&
             pathArray.length !== 0 &&
-            (pathArray[0] === exports.AADAuthorityConstants.COMMON ||
-                pathArray[0] === exports.AADAuthorityConstants.ORGANIZATIONS)) {
+            (pathArray[0] === AADAuthorityConstants.COMMON ||
+                pathArray[0] === AADAuthorityConstants.ORGANIZATIONS)) {
             pathArray[0] = tenantId;
         }
         return UrlString.constructAuthorityUriFromObject(urlObject);
@@ -4783,212 +4760,210 @@ class UrlString {
  * @export
  * @enum {number}
  */
-exports.PerformanceEvents = void 0;
-(function (PerformanceEvents) {
+const PerformanceEvents = {
     /**
      * acquireTokenByCode API (msal-browser and msal-node).
      * Used to acquire tokens by trading an authorization code against the token endpoint.
      */
-    PerformanceEvents["AcquireTokenByCode"] = "acquireTokenByCode";
+    AcquireTokenByCode: "acquireTokenByCode",
     /**
      * acquireTokenByRefreshToken API (msal-browser and msal-node).
      * Used to renew an access token using a refresh token against the token endpoint.
      */
-    PerformanceEvents["AcquireTokenByRefreshToken"] = "acquireTokenByRefreshToken";
+    AcquireTokenByRefreshToken: "acquireTokenByRefreshToken",
     /**
      * acquireTokenSilent API (msal-browser and msal-node).
      * Used to silently acquire a new access token (from the cache or the network).
      */
-    PerformanceEvents["AcquireTokenSilent"] = "acquireTokenSilent";
+    AcquireTokenSilent: "acquireTokenSilent",
     /**
      * acquireTokenSilentAsync (msal-browser).
      * Internal API for acquireTokenSilent.
      */
-    PerformanceEvents["AcquireTokenSilentAsync"] = "acquireTokenSilentAsync";
+    AcquireTokenSilentAsync: "acquireTokenSilentAsync",
     /**
      * acquireTokenPopup (msal-browser).
      * Used to acquire a new access token interactively through pop ups
      */
-    PerformanceEvents["AcquireTokenPopup"] = "acquireTokenPopup";
+    AcquireTokenPopup: "acquireTokenPopup",
     /**
      * getPublicKeyThumbprint API in CryptoOpts class (msal-browser).
      * Used to generate a public/private keypair and generate a public key thumbprint for pop requests.
      */
-    PerformanceEvents["CryptoOptsGetPublicKeyThumbprint"] = "cryptoOptsGetPublicKeyThumbprint";
+    CryptoOptsGetPublicKeyThumbprint: "cryptoOptsGetPublicKeyThumbprint",
     /**
      * signJwt API in CryptoOpts class (msal-browser).
      * Used to signed a pop token.
      */
-    PerformanceEvents["CryptoOptsSignJwt"] = "cryptoOptsSignJwt";
+    CryptoOptsSignJwt: "cryptoOptsSignJwt",
     /**
      * acquireToken API in the SilentCacheClient class (msal-browser).
      * Used to read access tokens from the cache.
      */
-    PerformanceEvents["SilentCacheClientAcquireToken"] = "silentCacheClientAcquireToken";
+    SilentCacheClientAcquireToken: "silentCacheClientAcquireToken",
     /**
      * acquireToken API in the SilentIframeClient class (msal-browser).
      * Used to acquire a new set of tokens from the authorize endpoint in a hidden iframe.
      */
-    PerformanceEvents["SilentIframeClientAcquireToken"] = "silentIframeClientAcquireToken";
+    SilentIframeClientAcquireToken: "silentIframeClientAcquireToken",
     /**
      * acquireToken API in SilentRereshClient (msal-browser).
      * Used to acquire a new set of tokens from the token endpoint using a refresh token.
      */
-    PerformanceEvents["SilentRefreshClientAcquireToken"] = "silentRefreshClientAcquireToken";
+    SilentRefreshClientAcquireToken: "silentRefreshClientAcquireToken",
     /**
      * ssoSilent API (msal-browser).
      * Used to silently acquire an authorization code and set of tokens using a hidden iframe.
      */
-    PerformanceEvents["SsoSilent"] = "ssoSilent";
+    SsoSilent: "ssoSilent",
     /**
      * getDiscoveredAuthority API in StandardInteractionClient class (msal-browser).
      * Used to load authority metadata for a request.
      */
-    PerformanceEvents["StandardInteractionClientGetDiscoveredAuthority"] = "standardInteractionClientGetDiscoveredAuthority";
+    StandardInteractionClientGetDiscoveredAuthority: "standardInteractionClientGetDiscoveredAuthority",
     /**
      * acquireToken APIs in msal-browser.
      * Used to make an /authorize endpoint call with native brokering enabled.
      */
-    PerformanceEvents["FetchAccountIdWithNativeBroker"] = "fetchAccountIdWithNativeBroker";
+    FetchAccountIdWithNativeBroker: "fetchAccountIdWithNativeBroker",
     /**
      * acquireToken API in NativeInteractionClient class (msal-browser).
      * Used to acquire a token from Native component when native brokering is enabled.
      */
-    PerformanceEvents["NativeInteractionClientAcquireToken"] = "nativeInteractionClientAcquireToken";
+    NativeInteractionClientAcquireToken: "nativeInteractionClientAcquireToken",
     /**
      * Time spent creating default headers for requests to token endpoint
      */
-    PerformanceEvents["BaseClientCreateTokenRequestHeaders"] = "baseClientCreateTokenRequestHeaders";
+    BaseClientCreateTokenRequestHeaders: "baseClientCreateTokenRequestHeaders",
     /**
      * Used to measure the time taken for completing embedded-broker handshake (PW-Broker).
      */
-    PerformanceEvents["BrokerHandhshake"] = "brokerHandshake";
+    BrokerHandhshake: "brokerHandshake",
     /**
      * acquireTokenByRefreshToken API in BrokerClientApplication (PW-Broker) .
      */
-    PerformanceEvents["AcquireTokenByRefreshTokenInBroker"] = "acquireTokenByRefreshTokenInBroker";
+    AcquireTokenByRefreshTokenInBroker: "acquireTokenByRefreshTokenInBroker",
     /**
      * Time taken for token acquisition by broker
      */
-    PerformanceEvents["AcquireTokenByBroker"] = "acquireTokenByBroker";
+    AcquireTokenByBroker: "acquireTokenByBroker",
     /**
      * Time spent on the network for refresh token acquisition
      */
-    PerformanceEvents["RefreshTokenClientExecuteTokenRequest"] = "refreshTokenClientExecuteTokenRequest";
+    RefreshTokenClientExecuteTokenRequest: "refreshTokenClientExecuteTokenRequest",
     /**
      * Time taken for acquiring refresh token , records RT size
      */
-    PerformanceEvents["RefreshTokenClientAcquireToken"] = "refreshTokenClientAcquireToken";
+    RefreshTokenClientAcquireToken: "refreshTokenClientAcquireToken",
     /**
      * Time taken for acquiring cached refresh token
      */
-    PerformanceEvents["RefreshTokenClientAcquireTokenWithCachedRefreshToken"] = "refreshTokenClientAcquireTokenWithCachedRefreshToken";
+    RefreshTokenClientAcquireTokenWithCachedRefreshToken: "refreshTokenClientAcquireTokenWithCachedRefreshToken",
     /**
      * acquireTokenByRefreshToken API in RefreshTokenClient (msal-common).
      */
-    PerformanceEvents["RefreshTokenClientAcquireTokenByRefreshToken"] = "refreshTokenClientAcquireTokenByRefreshToken";
+    RefreshTokenClientAcquireTokenByRefreshToken: "refreshTokenClientAcquireTokenByRefreshToken",
     /**
      * Helper function to create token request body in RefreshTokenClient (msal-common).
      */
-    PerformanceEvents["RefreshTokenClientCreateTokenRequestBody"] = "refreshTokenClientCreateTokenRequestBody";
+    RefreshTokenClientCreateTokenRequestBody: "refreshTokenClientCreateTokenRequestBody",
     /**
      * acquireTokenFromCache (msal-browser).
      * Internal API for acquiring token from cache
      */
-    PerformanceEvents["AcquireTokenFromCache"] = "acquireTokenFromCache";
+    AcquireTokenFromCache: "acquireTokenFromCache",
     /**
      * acquireTokenBySilentIframe (msal-browser).
      * Internal API for acquiring token by silent Iframe
      */
-    PerformanceEvents["AcquireTokenBySilentIframe"] = "acquireTokenBySilentIframe";
+    AcquireTokenBySilentIframe: "acquireTokenBySilentIframe",
     /**
      * Internal API for initializing base request in BaseInteractionClient (msal-browser)
      */
-    PerformanceEvents["InitializeBaseRequest"] = "initializeBaseRequest";
+    InitializeBaseRequest: "initializeBaseRequest",
     /**
      * Internal API for initializing silent request in SilentCacheClient (msal-browser)
      */
-    PerformanceEvents["InitializeSilentRequest"] = "initializeSilentRequest";
-    PerformanceEvents["InitializeClientApplication"] = "initializeClientApplication";
+    InitializeSilentRequest: "initializeSilentRequest",
+    InitializeClientApplication: "initializeClientApplication",
     /**
      * Helper function in SilentIframeClient class (msal-browser).
      */
-    PerformanceEvents["SilentIframeClientTokenHelper"] = "silentIframeClientTokenHelper";
+    SilentIframeClientTokenHelper: "silentIframeClientTokenHelper",
     /**
      * SilentHandler
      */
-    PerformanceEvents["SilentHandlerInitiateAuthRequest"] = "silentHandlerInitiateAuthRequest";
-    PerformanceEvents["SilentHandlerMonitorIframeForHash"] = "silentHandlerMonitorIframeForHash";
-    PerformanceEvents["SilentHandlerLoadFrame"] = "silentHandlerLoadFrame";
+    SilentHandlerInitiateAuthRequest: "silentHandlerInitiateAuthRequest",
+    SilentHandlerMonitorIframeForHash: "silentHandlerMonitorIframeForHash",
+    SilentHandlerLoadFrame: "silentHandlerLoadFrame",
     /**
      * Helper functions in StandardInteractionClient class (msal-browser)
      */
-    PerformanceEvents["StandardInteractionClientCreateAuthCodeClient"] = "standardInteractionClientCreateAuthCodeClient";
-    PerformanceEvents["StandardInteractionClientGetClientConfiguration"] = "standardInteractionClientGetClientConfiguration";
-    PerformanceEvents["StandardInteractionClientInitializeAuthorizationRequest"] = "standardInteractionClientInitializeAuthorizationRequest";
-    PerformanceEvents["StandardInteractionClientInitializeAuthorizationCodeRequest"] = "standardInteractionClientInitializeAuthorizationCodeRequest";
+    StandardInteractionClientCreateAuthCodeClient: "standardInteractionClientCreateAuthCodeClient",
+    StandardInteractionClientGetClientConfiguration: "standardInteractionClientGetClientConfiguration",
+    StandardInteractionClientInitializeAuthorizationRequest: "standardInteractionClientInitializeAuthorizationRequest",
+    StandardInteractionClientInitializeAuthorizationCodeRequest: "standardInteractionClientInitializeAuthorizationCodeRequest",
     /**
      * getAuthCodeUrl API (msal-browser and msal-node).
      */
-    PerformanceEvents["GetAuthCodeUrl"] = "getAuthCodeUrl";
+    GetAuthCodeUrl: "getAuthCodeUrl",
     /**
      * Functions from InteractionHandler (msal-browser)
      */
-    PerformanceEvents["HandleCodeResponseFromServer"] = "handleCodeResponseFromServer";
-    PerformanceEvents["HandleCodeResponseFromHash"] = "handleCodeResponseFromHash";
-    PerformanceEvents["UpdateTokenEndpointAuthority"] = "updateTokenEndpointAuthority";
+    HandleCodeResponseFromServer: "handleCodeResponseFromServer",
+    HandleCodeResponseFromHash: "handleCodeResponseFromHash",
+    UpdateTokenEndpointAuthority: "updateTokenEndpointAuthority",
     /**
      * APIs in Authorization Code Client (msal-common)
      */
-    PerformanceEvents["AuthClientAcquireToken"] = "authClientAcquireToken";
-    PerformanceEvents["AuthClientExecuteTokenRequest"] = "authClientExecuteTokenRequest";
-    PerformanceEvents["AuthClientCreateTokenRequestBody"] = "authClientCreateTokenRequestBody";
-    PerformanceEvents["AuthClientCreateQueryString"] = "authClientCreateQueryString";
+    AuthClientAcquireToken: "authClientAcquireToken",
+    AuthClientExecuteTokenRequest: "authClientExecuteTokenRequest",
+    AuthClientCreateTokenRequestBody: "authClientCreateTokenRequestBody",
+    AuthClientCreateQueryString: "authClientCreateQueryString",
     /**
      * Generate functions in PopTokenGenerator (msal-common)
      */
-    PerformanceEvents["PopTokenGenerateCnf"] = "popTokenGenerateCnf";
-    PerformanceEvents["PopTokenGenerateKid"] = "popTokenGenerateKid";
+    PopTokenGenerateCnf: "popTokenGenerateCnf",
+    PopTokenGenerateKid: "popTokenGenerateKid",
     /**
      * handleServerTokenResponse API in ResponseHandler (msal-common)
      */
-    PerformanceEvents["HandleServerTokenResponse"] = "handleServerTokenResponse";
+    HandleServerTokenResponse: "handleServerTokenResponse",
     /**
      * Authority functions
      */
-    PerformanceEvents["AuthorityFactoryCreateDiscoveredInstance"] = "authorityFactoryCreateDiscoveredInstance";
-    PerformanceEvents["AuthorityResolveEndpointsAsync"] = "authorityResolveEndpointsAsync";
-    PerformanceEvents["AuthorityGetCloudDiscoveryMetadataFromNetwork"] = "authorityGetCloudDiscoveryMetadataFromNetwork";
-    PerformanceEvents["AuthorityUpdateCloudDiscoveryMetadata"] = "authorityUpdateCloudDiscoveryMetadata";
-    PerformanceEvents["AuthorityGetEndpointMetadataFromNetwork"] = "authorityGetEndpointMetadataFromNetwork";
-    PerformanceEvents["AuthorityUpdateEndpointMetadata"] = "authorityUpdateEndpointMetadata";
-    PerformanceEvents["AuthorityUpdateMetadataWithRegionalInformation"] = "authorityUpdateMetadataWithRegionalInformation";
+    AuthorityFactoryCreateDiscoveredInstance: "authorityFactoryCreateDiscoveredInstance",
+    AuthorityResolveEndpointsAsync: "authorityResolveEndpointsAsync",
+    AuthorityGetCloudDiscoveryMetadataFromNetwork: "authorityGetCloudDiscoveryMetadataFromNetwork",
+    AuthorityUpdateCloudDiscoveryMetadata: "authorityUpdateCloudDiscoveryMetadata",
+    AuthorityGetEndpointMetadataFromNetwork: "authorityGetEndpointMetadataFromNetwork",
+    AuthorityUpdateEndpointMetadata: "authorityUpdateEndpointMetadata",
+    AuthorityUpdateMetadataWithRegionalInformation: "authorityUpdateMetadataWithRegionalInformation",
     /**
      * Region Discovery functions
      */
-    PerformanceEvents["RegionDiscoveryDetectRegion"] = "regionDiscoveryDetectRegion";
-    PerformanceEvents["RegionDiscoveryGetRegionFromIMDS"] = "regionDiscoveryGetRegionFromIMDS";
-    PerformanceEvents["RegionDiscoveryGetCurrentVersion"] = "regionDiscoveryGetCurrentVersion";
-    PerformanceEvents["AcquireTokenByCodeAsync"] = "acquireTokenByCodeAsync";
-    PerformanceEvents["GetEndpointMetadataFromNetwork"] = "getEndpointMetadataFromNetwork";
-    PerformanceEvents["GetCloudDiscoveryMetadataFromNetworkMeasurement"] = "getCloudDiscoveryMetadataFromNetworkMeasurement";
-    PerformanceEvents["HandleRedirectPromiseMeasurement"] = "handleRedirectPromiseMeasurement";
-    PerformanceEvents["UpdateCloudDiscoveryMetadataMeasurement"] = "updateCloudDiscoveryMetadataMeasurement";
-    PerformanceEvents["UsernamePasswordClientAcquireToken"] = "usernamePasswordClientAcquireToken";
-    PerformanceEvents["NativeMessageHandlerHandshake"] = "nativeMessageHandlerHandshake";
-})(exports.PerformanceEvents || (exports.PerformanceEvents = {}));
+    RegionDiscoveryDetectRegion: "regionDiscoveryDetectRegion",
+    RegionDiscoveryGetRegionFromIMDS: "regionDiscoveryGetRegionFromIMDS",
+    RegionDiscoveryGetCurrentVersion: "regionDiscoveryGetCurrentVersion",
+    AcquireTokenByCodeAsync: "acquireTokenByCodeAsync",
+    GetEndpointMetadataFromNetwork: "getEndpointMetadataFromNetwork",
+    GetCloudDiscoveryMetadataFromNetworkMeasurement: "getCloudDiscoveryMetadataFromNetworkMeasurement",
+    HandleRedirectPromiseMeasurement: "handleRedirectPromiseMeasurement",
+    UpdateCloudDiscoveryMetadataMeasurement: "updateCloudDiscoveryMetadataMeasurement",
+    UsernamePasswordClientAcquireToken: "usernamePasswordClientAcquireToken",
+    NativeMessageHandlerHandshake: "nativeMessageHandlerHandshake",
+};
 /**
  * State of the performance event.
  *
  * @export
  * @enum {number}
  */
-exports.PerformanceEventStatus = void 0;
-(function (PerformanceEventStatus) {
-    PerformanceEventStatus[PerformanceEventStatus["NotStarted"] = 0] = "NotStarted";
-    PerformanceEventStatus[PerformanceEventStatus["InProgress"] = 1] = "InProgress";
-    PerformanceEventStatus[PerformanceEventStatus["Completed"] = 2] = "Completed";
-})(exports.PerformanceEventStatus || (exports.PerformanceEventStatus = {}));
+const PerformanceEventStatus = {
+    NotStarted: 0,
+    InProgress: 1,
+    Completed: 2,
+};
 const IntFields = new Set([
     "accessTokenSize",
     "durationMs",
@@ -5005,11 +4980,10 @@ const IntFields = new Set([
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-var KeyLocation;
-(function (KeyLocation) {
-    KeyLocation["SW"] = "sw";
-    KeyLocation["UHW"] = "uhw";
-})(KeyLocation || (KeyLocation = {}));
+const KeyLocation = {
+    SW: "sw",
+    UHW: "uhw",
+};
 class PopTokenGenerator {
     constructor(cryptoUtils, performanceClient) {
         this.cryptoUtils = cryptoUtils;
@@ -5022,8 +4996,8 @@ class PopTokenGenerator {
      * @returns
      */
     async generateCnf(request) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.PopTokenGenerateCnf, request.correlationId);
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.PopTokenGenerateKid, request.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.PopTokenGenerateCnf, request.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.PopTokenGenerateKid, request.correlationId);
         const reqCnf = await this.generateKid(request);
         const reqCnfString = this.cryptoUtils.base64Encode(JSON.stringify(reqCnf));
         return {
@@ -5038,7 +5012,7 @@ class PopTokenGenerator {
      * @returns
      */
     async generateKid(request) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.PopTokenGenerateKid, request.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.PopTokenGenerateKid, request.correlationId);
         const kidThumbprint = await this.cryptoUtils.getPublicKeyThumbprint(request);
         return {
             kid: kidThumbprint,
@@ -5246,7 +5220,7 @@ class ResponseHandler {
      * @param authority
      */
     async handleServerTokenResponse(serverTokenResponse, authority, reqTimestamp, request, authCodePayload, userAssertionHash, handlingRefreshTokenResponse, forceCacheRefreshTokenResponse, serverRequestId) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.HandleServerTokenResponse, serverTokenResponse.correlation_id);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.HandleServerTokenResponse, serverTokenResponse.correlation_id);
         // create an idToken object (not entity)
         let idTokenObj;
         if (serverTokenResponse.id_token) {
@@ -5389,7 +5363,7 @@ class ResponseHandler {
             ? authCodePayload.msgraph_host
             : Constants.EMPTY_STRING;
         // ADFS does not require client_info in the response
-        if (authorityType === exports.AuthorityType.Adfs) {
+        if (authorityType === AuthorityType.Adfs) {
             this.logger.verbose("Authority type is ADFS, creating ADFS account");
             return AccountEntity.createGenericAccount(this.homeAccountIdentifier, idToken, authority, cloudGraphHostName, msGraphhost);
         }
@@ -5419,7 +5393,7 @@ class ResponseHandler {
         let extExpiresOn;
         let familyId = Constants.EMPTY_STRING;
         if (cacheRecord.accessToken) {
-            if (cacheRecord.accessToken.tokenType === exports.AuthenticationScheme.POP) {
+            if (cacheRecord.accessToken.tokenType === AuthenticationScheme.POP) {
                 const popTokenGenerator = new PopTokenGenerator(cryptoObj);
                 const { secret, keyId } = cacheRecord.accessToken;
                 if (!keyId) {
@@ -5503,8 +5477,8 @@ class AuthorizationCodeClient extends BaseClient {
      * @param request
      */
     async getAuthCodeUrl(request) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.GetAuthCodeUrl, request.correlationId);
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.AuthClientCreateQueryString, request.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.GetAuthCodeUrl, request.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.AuthClientCreateQueryString, request.correlationId);
         const queryString = await this.createAuthCodeUrlQueryString(request);
         return UrlString.appendQueryString(this.authority.authorizationEndpoint, queryString);
     }
@@ -5517,17 +5491,17 @@ class AuthorizationCodeClient extends BaseClient {
         if (!request || !request.code) {
             throw ClientAuthError.createTokenRequestCannotBeMadeError();
         }
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.AuthClientAcquireToken, request.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthClientAcquireToken, request.correlationId);
         const atsMeasurement = this.performanceClient?.startMeasurement(
         // @ts-ignore
         "AuthCodeClientAcquireToken", request.correlationId);
         this.logger.info("in acquireToken call in auth-code client");
         const reqTimestamp = TimeUtils.nowSeconds();
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.AuthClientExecuteTokenRequest, request.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.AuthClientExecuteTokenRequest, request.correlationId);
         const response = await this.executeTokenRequest(this.authority, request);
         // Retrieve requestId from response headers
-        const requestId = response.headers?.[exports.HeaderNames.X_MS_REQUEST_ID];
-        const httpVerAuthority = response.headers?.[exports.HeaderNames.X_MS_HTTP_VERSION];
+        const requestId = response.headers?.[HeaderNames.X_MS_REQUEST_ID];
+        const httpVerAuthority = response.headers?.[HeaderNames.X_MS_HTTP_VERSION];
         if (httpVerAuthority) {
             atsMeasurement?.addStaticFields({
                 httpVerAuthority,
@@ -5536,7 +5510,7 @@ class AuthorizationCodeClient extends BaseClient {
         const responseHandler = new ResponseHandler(this.config.authOptions.clientId, this.cacheManager, this.cryptoUtils, this.logger, this.config.serializableCache, this.config.persistencePlugin, this.performanceClient);
         // Validate response. This function throws a server error if an error is returned by the server.
         responseHandler.validateTokenResponse(response.body);
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.HandleServerTokenResponse, request.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.HandleServerTokenResponse, request.correlationId);
         return responseHandler
             .handleServerTokenResponse(response.body, this.authority, reqTimestamp, request, authCodePayload, undefined, undefined, undefined, requestId)
             .then((result) => {
@@ -5599,8 +5573,8 @@ class AuthorizationCodeClient extends BaseClient {
      * @param request
      */
     async executeTokenRequest(authority, request) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.AuthClientExecuteTokenRequest, request.correlationId);
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.AuthClientCreateTokenRequestBody, request.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthClientExecuteTokenRequest, request.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.AuthClientCreateTokenRequestBody, request.correlationId);
         const queryParametersString = this.createTokenQueryParameters(request);
         const endpoint = UrlString.appendQueryString(authority.tokenEndpoint, queryParametersString);
         const requestBody = await this.createTokenRequestBody(request);
@@ -5610,7 +5584,7 @@ class AuthorizationCodeClient extends BaseClient {
                 const clientInfo = buildClientInfo(request.clientInfo, this.cryptoUtils);
                 ccsCredential = {
                     credential: `${clientInfo.uid}${Separators.CLIENT_INFO_SEPARATOR}${clientInfo.utid}`,
-                    type: exports.CcsCredentialType.HOME_ACCOUNT_ID,
+                    type: CcsCredentialType.HOME_ACCOUNT_ID,
                 };
             }
             catch (e) {
@@ -5636,7 +5610,7 @@ class AuthorizationCodeClient extends BaseClient {
      * @param request
      */
     async createTokenRequestBody(request) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.AuthClientCreateTokenRequestBody, request.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthClientCreateTokenRequestBody, request.correlationId);
         const parameterBuilder = new RequestParameterBuilder();
         parameterBuilder.addClientId(this.config.authOptions.clientId);
         /*
@@ -5674,16 +5648,16 @@ class AuthorizationCodeClient extends BaseClient {
             parameterBuilder.addClientAssertion(clientAssertion.assertion);
             parameterBuilder.addClientAssertionType(clientAssertion.assertionType);
         }
-        parameterBuilder.addGrantType(exports.GrantType.AUTHORIZATION_CODE_GRANT);
+        parameterBuilder.addGrantType(GrantType.AUTHORIZATION_CODE_GRANT);
         parameterBuilder.addClientInfo();
-        if (request.authenticationScheme === exports.AuthenticationScheme.POP) {
+        if (request.authenticationScheme === AuthenticationScheme.POP) {
             const popTokenGenerator = new PopTokenGenerator(this.cryptoUtils, this.performanceClient);
-            this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.PopTokenGenerateCnf, request.correlationId);
+            this.performanceClient?.setPreQueueTime(PerformanceEvents.PopTokenGenerateCnf, request.correlationId);
             const reqCnfData = await popTokenGenerator.generateCnf(request);
             // SPA PoP requires full Base64Url encoded req_cnf string (unhashed)
             parameterBuilder.addPopToken(reqCnfData.reqCnfString);
         }
-        else if (request.authenticationScheme === exports.AuthenticationScheme.SSH) {
+        else if (request.authenticationScheme === AuthenticationScheme.SSH) {
             if (request.sshJwk) {
                 parameterBuilder.addSshJwk(request.sshJwk);
             }
@@ -5705,7 +5679,7 @@ class AuthorizationCodeClient extends BaseClient {
                 const clientInfo = buildClientInfo(request.clientInfo, this.cryptoUtils);
                 ccsCred = {
                     credential: `${clientInfo.uid}${Separators.CLIENT_INFO_SEPARATOR}${clientInfo.utid}`,
-                    type: exports.CcsCredentialType.HOME_ACCOUNT_ID,
+                    type: CcsCredentialType.HOME_ACCOUNT_ID,
                 };
             }
             catch (e) {
@@ -5718,7 +5692,7 @@ class AuthorizationCodeClient extends BaseClient {
         // Adds these as parameters in the request instead of headers to prevent CORS preflight request
         if (this.config.systemOptions.preventCorsPreflight && ccsCred) {
             switch (ccsCred.type) {
-                case exports.CcsCredentialType.HOME_ACCOUNT_ID:
+                case CcsCredentialType.HOME_ACCOUNT_ID:
                     try {
                         const clientInfo = buildClientInfoFromHomeAccountId(ccsCred.credential);
                         parameterBuilder.addCcsOid(clientInfo);
@@ -5728,7 +5702,7 @@ class AuthorizationCodeClient extends BaseClient {
                             e);
                     }
                     break;
-                case exports.CcsCredentialType.UPN:
+                case CcsCredentialType.UPN:
                     parameterBuilder.addCcsUpn(ccsCred.credential);
                     break;
             }
@@ -5739,9 +5713,9 @@ class AuthorizationCodeClient extends BaseClient {
         // Add hybrid spa parameters if not already provided
         if (request.enableSpaAuthorizationCode &&
             (!request.tokenBodyParameters ||
-                !request.tokenBodyParameters[exports.AADServerParamKeys.RETURN_SPA_CODE])) {
+                !request.tokenBodyParameters[AADServerParamKeys.RETURN_SPA_CODE])) {
             parameterBuilder.addExtraQueryParameters({
-                [exports.AADServerParamKeys.RETURN_SPA_CODE]: "1",
+                [AADServerParamKeys.RETURN_SPA_CODE]: "1",
             });
         }
         return parameterBuilder.createQueryString();
@@ -5751,7 +5725,7 @@ class AuthorizationCodeClient extends BaseClient {
      * @param request
      */
     async createAuthCodeUrlQueryString(request) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.AuthClientCreateQueryString, request.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthClientCreateQueryString, request.correlationId);
         const parameterBuilder = new RequestParameterBuilder();
         parameterBuilder.addClientId(this.config.authOptions.clientId);
         const requestScopes = [
@@ -5866,7 +5840,7 @@ class AuthorizationCodeClient extends BaseClient {
             // signal ests that this is a WAM call
             parameterBuilder.addNativeBroker();
             // pass the req_cnf for POP
-            if (request.authenticationScheme === exports.AuthenticationScheme.POP) {
+            if (request.authenticationScheme === AuthenticationScheme.POP) {
                 const popTokenGenerator = new PopTokenGenerator(this.cryptoUtils);
                 // to reduce the URL length, it is recommended to send the hash of the req_cnf instead of the whole string
                 const reqCnfData = await popTokenGenerator.generateCnf(request);
@@ -5925,13 +5899,13 @@ class RefreshTokenClient extends BaseClient {
         super(configuration, performanceClient);
     }
     async acquireToken(request) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.RefreshTokenClientAcquireToken, request.correlationId);
-        const atsMeasurement = this.performanceClient?.startMeasurement(exports.PerformanceEvents.RefreshTokenClientAcquireToken, request.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RefreshTokenClientAcquireToken, request.correlationId);
+        const atsMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.RefreshTokenClientAcquireToken, request.correlationId);
         this.logger.verbose("RefreshTokenClientAcquireToken called", request.correlationId);
         const reqTimestamp = TimeUtils.nowSeconds();
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.RefreshTokenClientExecuteTokenRequest, request.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.RefreshTokenClientExecuteTokenRequest, request.correlationId);
         const response = await this.executeTokenRequest(request, this.authority);
-        const httpVerToken = response.headers?.[exports.HeaderNames.X_MS_HTTP_VERSION];
+        const httpVerToken = response.headers?.[HeaderNames.X_MS_HTTP_VERSION];
         atsMeasurement?.addStaticFields({
             refreshTokenSize: response.body.refresh_token?.length || 0,
         });
@@ -5941,10 +5915,10 @@ class RefreshTokenClient extends BaseClient {
             });
         }
         // Retrieve requestId from response headers
-        const requestId = response.headers?.[exports.HeaderNames.X_MS_REQUEST_ID];
+        const requestId = response.headers?.[HeaderNames.X_MS_REQUEST_ID];
         const responseHandler = new ResponseHandler(this.config.authOptions.clientId, this.cacheManager, this.cryptoUtils, this.logger, this.config.serializableCache, this.config.persistencePlugin);
         responseHandler.validateTokenResponse(response.body);
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.HandleServerTokenResponse, request.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.HandleServerTokenResponse, request.correlationId);
         return responseHandler
             .handleServerTokenResponse(response.body, this.authority, reqTimestamp, request, undefined, undefined, true, request.forceCache, requestId)
             .then((result) => {
@@ -5972,7 +5946,7 @@ class RefreshTokenClient extends BaseClient {
         if (!request) {
             throw ClientConfigurationError.createEmptyTokenRequestError();
         }
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.RefreshTokenClientAcquireTokenByRefreshToken, request.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RefreshTokenClientAcquireTokenByRefreshToken, request.correlationId);
         // We currently do not support silent flow for account === null use cases; This will be revisited for confidential flow usecases
         if (!request.account) {
             throw ClientAuthError.createNoAccountInSilentRequestError();
@@ -5982,7 +5956,7 @@ class RefreshTokenClient extends BaseClient {
         // if the app is part of the family, retrive a Family refresh token if present and make a refreshTokenRequest
         if (isFOCI) {
             try {
-                this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
+                this.performanceClient?.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
                 return this.acquireTokenWithCachedRefreshToken(request, true);
             }
             catch (e) {
@@ -5995,7 +5969,7 @@ class RefreshTokenClient extends BaseClient {
                     e.subError === Errors.CLIENT_MISMATCH_ERROR;
                 // if family Refresh Token (FRT) cache acquisition fails or if client_mismatch error is seen with FRT, reattempt with application Refresh Token (ART)
                 if (noFamilyRTInCache || clientMismatchErrorWithFamilyRT) {
-                    this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
+                    this.performanceClient?.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
                     return this.acquireTokenWithCachedRefreshToken(request, false);
                     // throw in all other cases
                 }
@@ -6005,7 +5979,7 @@ class RefreshTokenClient extends BaseClient {
             }
         }
         // fall back to application refresh token acquisition
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
         return this.acquireTokenWithCachedRefreshToken(request, false);
     }
     /**
@@ -6013,9 +5987,9 @@ class RefreshTokenClient extends BaseClient {
      * @param request
      */
     async acquireTokenWithCachedRefreshToken(request, foci) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
         // fetches family RT or application RT based on FOCI value
-        const atsMeasurement = this.performanceClient?.startMeasurement(exports.PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
+        const atsMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
         this.logger.verbose("RefreshTokenClientAcquireTokenWithCachedRefreshToken called", request.correlationId);
         const refreshToken = this.cacheManager.getRefreshToken(request.account, foci);
         if (!refreshToken) {
@@ -6029,13 +6003,13 @@ class RefreshTokenClient extends BaseClient {
         const refreshTokenRequest = {
             ...request,
             refreshToken: refreshToken.secret,
-            authenticationScheme: request.authenticationScheme || exports.AuthenticationScheme.BEARER,
+            authenticationScheme: request.authenticationScheme || AuthenticationScheme.BEARER,
             ccsCredential: {
                 credential: request.account.homeAccountId,
-                type: exports.CcsCredentialType.HOME_ACCOUNT_ID,
+                type: CcsCredentialType.HOME_ACCOUNT_ID,
             },
         };
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.RefreshTokenClientAcquireToken, request.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireToken, request.correlationId);
         return this.acquireToken(refreshTokenRequest);
     }
     /**
@@ -6044,9 +6018,9 @@ class RefreshTokenClient extends BaseClient {
      * @param authority
      */
     async executeTokenRequest(request, authority) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.RefreshTokenClientExecuteTokenRequest, request.correlationId);
-        const acquireTokenMeasurement = this.performanceClient?.startMeasurement(exports.PerformanceEvents.RefreshTokenClientExecuteTokenRequest, request.correlationId);
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.RefreshTokenClientCreateTokenRequestBody, request.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RefreshTokenClientExecuteTokenRequest, request.correlationId);
+        const acquireTokenMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.RefreshTokenClientExecuteTokenRequest, request.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.RefreshTokenClientCreateTokenRequestBody, request.correlationId);
         const queryParametersString = this.createTokenQueryParameters(request);
         const endpoint = UrlString.appendQueryString(authority.tokenEndpoint, queryParametersString);
         const requestBody = await this.createTokenRequestBody(request);
@@ -6081,13 +6055,13 @@ class RefreshTokenClient extends BaseClient {
      * @param request
      */
     async createTokenRequestBody(request) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.RefreshTokenClientCreateTokenRequestBody, request.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RefreshTokenClientCreateTokenRequestBody, request.correlationId);
         const correlationId = request.correlationId;
-        const acquireTokenMeasurement = this.performanceClient?.startMeasurement(exports.PerformanceEvents.BaseClientCreateTokenRequestHeaders, correlationId);
+        const acquireTokenMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.BaseClientCreateTokenRequestHeaders, correlationId);
         const parameterBuilder = new RequestParameterBuilder();
         parameterBuilder.addClientId(this.config.authOptions.clientId);
         parameterBuilder.addScopes(request.scopes);
-        parameterBuilder.addGrantType(exports.GrantType.REFRESH_TOKEN_GRANT);
+        parameterBuilder.addGrantType(GrantType.REFRESH_TOKEN_GRANT);
         parameterBuilder.addClientInfo();
         parameterBuilder.addLibraryInfo(this.config.libraryInfo);
         parameterBuilder.addApplicationTelemetry(this.config.telemetry.application);
@@ -6105,14 +6079,14 @@ class RefreshTokenClient extends BaseClient {
             parameterBuilder.addClientAssertion(clientAssertion.assertion);
             parameterBuilder.addClientAssertionType(clientAssertion.assertionType);
         }
-        if (request.authenticationScheme === exports.AuthenticationScheme.POP) {
+        if (request.authenticationScheme === AuthenticationScheme.POP) {
             const popTokenGenerator = new PopTokenGenerator(this.cryptoUtils, this.performanceClient);
-            this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.PopTokenGenerateCnf, request.correlationId);
+            this.performanceClient?.setPreQueueTime(PerformanceEvents.PopTokenGenerateCnf, request.correlationId);
             const reqCnfData = await popTokenGenerator.generateCnf(request);
             // SPA PoP requires full Base64Url encoded req_cnf string (unhashed)
             parameterBuilder.addPopToken(reqCnfData.reqCnfString);
         }
-        else if (request.authenticationScheme === exports.AuthenticationScheme.SSH) {
+        else if (request.authenticationScheme === AuthenticationScheme.SSH) {
             if (request.sshJwk) {
                 parameterBuilder.addSshJwk(request.sshJwk);
             }
@@ -6131,7 +6105,7 @@ class RefreshTokenClient extends BaseClient {
         if (this.config.systemOptions.preventCorsPreflight &&
             request.ccsCredential) {
             switch (request.ccsCredential.type) {
-                case exports.CcsCredentialType.HOME_ACCOUNT_ID:
+                case CcsCredentialType.HOME_ACCOUNT_ID:
                     try {
                         const clientInfo = buildClientInfoFromHomeAccountId(request.ccsCredential.credential);
                         parameterBuilder.addCcsOid(clientInfo);
@@ -6141,7 +6115,7 @@ class RefreshTokenClient extends BaseClient {
                             e);
                     }
                     break;
-                case exports.CcsCredentialType.UPN:
+                case CcsCredentialType.UPN:
                     parameterBuilder.addCcsUpn(request.ccsCredential.credential);
                     break;
             }
@@ -6192,7 +6166,7 @@ class SilentFlowClient extends BaseClient {
         }
         if (request.forceRefresh) {
             // Must refresh due to present force_refresh flag.
-            this.serverTelemetryManager?.setCacheOutcome(exports.CacheOutcome.FORCE_REFRESH);
+            this.serverTelemetryManager?.setCacheOutcome(CacheOutcome.FORCE_REFRESH);
             this.logger.info("SilentFlowClient:acquireCachedToken - Skipping cache because forceRefresh is true.");
             throw ClientAuthError.createRefreshRequiredError();
         }
@@ -6204,21 +6178,21 @@ class SilentFlowClient extends BaseClient {
         const cacheRecord = this.cacheManager.readCacheRecord(request.account, request, environment);
         if (!cacheRecord.accessToken) {
             // Must refresh due to non-existent access_token.
-            this.serverTelemetryManager?.setCacheOutcome(exports.CacheOutcome.NO_CACHED_ACCESS_TOKEN);
+            this.serverTelemetryManager?.setCacheOutcome(CacheOutcome.NO_CACHED_ACCESS_TOKEN);
             this.logger.info("SilentFlowClient:acquireCachedToken - No access token found in cache for the given properties.");
             throw ClientAuthError.createRefreshRequiredError();
         }
         else if (TimeUtils.wasClockTurnedBack(cacheRecord.accessToken.cachedAt) ||
             TimeUtils.isTokenExpired(cacheRecord.accessToken.expiresOn, this.config.systemOptions.tokenRenewalOffsetSeconds)) {
             // Must refresh due to expired access_token.
-            this.serverTelemetryManager?.setCacheOutcome(exports.CacheOutcome.CACHED_ACCESS_TOKEN_EXPIRED);
+            this.serverTelemetryManager?.setCacheOutcome(CacheOutcome.CACHED_ACCESS_TOKEN_EXPIRED);
             this.logger.info(`SilentFlowClient:acquireCachedToken - Cached access token is expired or will expire within ${this.config.systemOptions.tokenRenewalOffsetSeconds} seconds.`);
             throw ClientAuthError.createRefreshRequiredError();
         }
         else if (cacheRecord.accessToken.refreshOn &&
             TimeUtils.isTokenExpired(cacheRecord.accessToken.refreshOn, 0)) {
             // Must refresh due to the refresh_in value.
-            this.serverTelemetryManager?.setCacheOutcome(exports.CacheOutcome.REFRESH_CACHED_ACCESS_TOKEN);
+            this.serverTelemetryManager?.setCacheOutcome(CacheOutcome.REFRESH_CACHED_ACCESS_TOKEN);
             this.logger.info("SilentFlowClient:acquireCachedToken - Cached access token's refreshOn property has been exceeded'.");
             throw ClientAuthError.createRefreshRequiredError();
         }
@@ -7143,11 +7117,10 @@ const InstanceDiscoveryMetadata = rawMetdataJSON.instanceDiscoveryMetadata;
 /**
  * Protocol modes supported by MSAL.
  */
-exports.ProtocolMode = void 0;
-(function (ProtocolMode) {
-    ProtocolMode["AAD"] = "AAD";
-    ProtocolMode["OIDC"] = "OIDC";
-})(exports.ProtocolMode || (exports.ProtocolMode = {}));
+const ProtocolMode = {
+    AAD: "AAD",
+    OIDC: "OIDC",
+};
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -7261,14 +7234,14 @@ class RegionDiscovery {
      * @returns Promise<string | null>
      */
     async detectRegion(environmentRegion, regionDiscoveryMetadata) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.RegionDiscoveryDetectRegion, this.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RegionDiscoveryDetectRegion, this.correlationId);
         // Initialize auto detected region with the region from the envrionment
         let autodetectedRegionName = environmentRegion;
         // Check if a region was detected from the environment, if not, attempt to get the region from IMDS
         if (!autodetectedRegionName) {
             const options = RegionDiscovery.IMDS_OPTIONS;
             try {
-                this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.RegionDiscoveryGetRegionFromIMDS, this.correlationId);
+                this.performanceClient?.setPreQueueTime(PerformanceEvents.RegionDiscoveryGetRegionFromIMDS, this.correlationId);
                 const localIMDSVersionResponse = await this.getRegionFromIMDS(Constants.IMDS_VERSION, options);
                 if (localIMDSVersionResponse.status ===
                     ResponseCodes.httpSuccess) {
@@ -7279,14 +7252,14 @@ class RegionDiscovery {
                 // If the response using the local IMDS version failed, try to fetch the current version of IMDS and retry.
                 if (localIMDSVersionResponse.status ===
                     ResponseCodes.httpBadRequest) {
-                    this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.RegionDiscoveryGetCurrentVersion, this.correlationId);
+                    this.performanceClient?.setPreQueueTime(PerformanceEvents.RegionDiscoveryGetCurrentVersion, this.correlationId);
                     const currentIMDSVersion = await this.getCurrentVersion(options);
                     if (!currentIMDSVersion) {
                         regionDiscoveryMetadata.region_source =
                             RegionDiscoverySources.FAILED_AUTO_DETECTION;
                         return null;
                     }
-                    this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.RegionDiscoveryGetRegionFromIMDS, this.correlationId);
+                    this.performanceClient?.setPreQueueTime(PerformanceEvents.RegionDiscoveryGetRegionFromIMDS, this.correlationId);
                     const currentIMDSVersionResponse = await this.getRegionFromIMDS(currentIMDSVersion, options);
                     if (currentIMDSVersionResponse.status ===
                         ResponseCodes.httpSuccess) {
@@ -7321,7 +7294,7 @@ class RegionDiscovery {
      * @returns Promise<NetworkResponse<string>>
      */
     async getRegionFromIMDS(version, options) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.RegionDiscoveryGetRegionFromIMDS, this.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RegionDiscoveryGetRegionFromIMDS, this.correlationId);
         return this.networkInterface.sendGetRequestAsync(`${Constants.IMDS_ENDPOINT}?api-version=${version}&format=text`, options, Constants.IMDS_TIMEOUT);
     }
     /**
@@ -7330,7 +7303,7 @@ class RegionDiscovery {
      * @returns Promise<string | null>
      */
     async getCurrentVersion(options) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.RegionDiscoveryGetCurrentVersion, this.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RegionDiscoveryGetCurrentVersion, this.correlationId);
         try {
             const response = await this.networkInterface.sendGetRequestAsync(`${Constants.IMDS_ENDPOINT}?format=json`, options);
             // When IMDS endpoint is called without the api version query param, bad request response comes back with latest version.
@@ -7387,18 +7360,18 @@ class Authority {
     getAuthorityType(authorityUri) {
         // CIAM auth url pattern is being standardized as: <tenant>.ciamlogin.com
         if (authorityUri.HostNameAndPort.endsWith(Constants.CIAM_AUTH_URL)) {
-            return exports.AuthorityType.Ciam;
+            return AuthorityType.Ciam;
         }
         const pathSegments = authorityUri.PathSegments;
         if (pathSegments.length) {
             switch (pathSegments[0].toLowerCase()) {
                 case Constants.ADFS:
-                    return exports.AuthorityType.Adfs;
+                    return AuthorityType.Adfs;
                 case Constants.DSTS:
-                    return exports.AuthorityType.Dsts;
+                    return AuthorityType.Dsts;
             }
         }
-        return exports.AuthorityType.Default;
+        return AuthorityType.Default;
     }
     // See above for AuthorityType
     get authorityType() {
@@ -7527,8 +7500,8 @@ class Authority {
     canReplaceTenant(authorityUri) {
         return authorityUri.PathSegments.length === 1
             && !Authority.reservedTenantDomains.has(authorityUri.PathSegments[0])
-            && this.getAuthorityType(authorityUri) === exports.AuthorityType.Default
-            && this.protocolMode === exports.ProtocolMode.AAD;
+            && this.getAuthorityType(authorityUri) === AuthorityType.Default
+            && this.protocolMode === ProtocolMode.AAD;
     }
     /**
      * Replaces tenant in url path with current tenant. Defaults to common.
@@ -7571,8 +7544,8 @@ class Authority {
      * The default open id configuration endpoint for any canonical authority.
      */
     get defaultOpenIdConfigurationEndpoint() {
-        if (this.authorityType === exports.AuthorityType.Adfs ||
-            this.protocolMode === exports.ProtocolMode.OIDC) {
+        if (this.authorityType === AuthorityType.Adfs ||
+            this.protocolMode === ProtocolMode.OIDC) {
             return `${this.canonicalAuthority}.well-known/openid-configuration`;
         }
         return `${this.canonicalAuthority}v2.0/.well-known/openid-configuration`;
@@ -7588,16 +7561,16 @@ class Authority {
      * and the /authorize, /token and logout endpoints.
      */
     async resolveEndpointsAsync() {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.AuthorityResolveEndpointsAsync, this.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthorityResolveEndpointsAsync, this.correlationId);
         let metadataEntity = this.cacheManager.getAuthorityMetadataByAlias(this.hostnameAndPort);
         if (!metadataEntity) {
             metadataEntity = new AuthorityMetadataEntity();
             metadataEntity.updateCanonicalAuthority(this.canonicalAuthority);
         }
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.AuthorityUpdateCloudDiscoveryMetadata, this.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.AuthorityUpdateCloudDiscoveryMetadata, this.correlationId);
         const cloudDiscoverySource = await this.updateCloudDiscoveryMetadata(metadataEntity);
         this.canonicalAuthority = this.canonicalAuthority.replace(this.hostnameAndPort, metadataEntity.preferred_network);
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.AuthorityUpdateEndpointMetadata, this.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.AuthorityUpdateEndpointMetadata, this.correlationId);
         const endpointSource = await this.updateEndpointMetadata(metadataEntity);
         if (cloudDiscoverySource !== AuthorityMetadataSource.CACHE &&
             endpointSource !== AuthorityMetadataSource.CACHE) {
@@ -7614,7 +7587,7 @@ class Authority {
      * @param metadataEntity
      */
     async updateEndpointMetadata(metadataEntity) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.AuthorityUpdateEndpointMetadata, this.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthorityUpdateEndpointMetadata, this.correlationId);
         let metadata = this.getEndpointMetadataFromConfig();
         if (metadata) {
             metadataEntity.updateEndpointMetadata(metadata, false);
@@ -7626,12 +7599,12 @@ class Authority {
             // No need to update
             return AuthorityMetadataSource.CACHE;
         }
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.AuthorityGetEndpointMetadataFromNetwork, this.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.AuthorityGetEndpointMetadataFromNetwork, this.correlationId);
         metadata = await this.getEndpointMetadataFromNetwork();
         if (metadata) {
             // If the user prefers to use an azure region replace the global endpoints with regional information.
             if (this.authorityOptions.azureRegionConfiguration?.azureRegion) {
-                this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.AuthorityUpdateMetadataWithRegionalInformation, this.correlationId);
+                this.performanceClient?.setPreQueueTime(PerformanceEvents.AuthorityUpdateMetadataWithRegionalInformation, this.correlationId);
                 metadata = await this.updateMetadataWithRegionalInformation(metadata);
             }
             metadataEntity.updateEndpointMetadata(metadata, true);
@@ -7642,7 +7615,7 @@ class Authority {
             !this.authorityOptions.skipAuthorityMetadataCache) {
             // If the user prefers to use an azure region replace the global endpoints with regional information.
             if (this.authorityOptions.azureRegionConfiguration?.azureRegion) {
-                this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.AuthorityUpdateMetadataWithRegionalInformation, this.correlationId);
+                this.performanceClient?.setPreQueueTime(PerformanceEvents.AuthorityUpdateMetadataWithRegionalInformation, this.correlationId);
                 harcodedMetadata =
                     await this.updateMetadataWithRegionalInformation(harcodedMetadata);
             }
@@ -7685,8 +7658,8 @@ class Authority {
      * @param hasHardcodedMetadata boolean
      */
     async getEndpointMetadataFromNetwork() {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.AuthorityGetEndpointMetadataFromNetwork, this.correlationId);
-        const perfEvent = this.performanceClient?.startMeasurement(exports.PerformanceEvents.AuthorityGetEndpointMetadataFromNetwork, this.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthorityGetEndpointMetadataFromNetwork, this.correlationId);
+        const perfEvent = this.performanceClient?.startMeasurement(PerformanceEvents.AuthorityGetEndpointMetadataFromNetwork, this.correlationId);
         const options = {};
         /*
          * TODO: Add a timeout if the authority exists in our library's
@@ -7726,8 +7699,8 @@ class Authority {
      * Update the retrieved metadata with regional information.
      */
     async updateMetadataWithRegionalInformation(metadata) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.AuthorityUpdateMetadataWithRegionalInformation, this.correlationId);
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.RegionDiscoveryDetectRegion, this.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthorityUpdateMetadataWithRegionalInformation, this.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.RegionDiscoveryDetectRegion, this.correlationId);
         const autodetectedRegionName = await this.regionDiscovery.detectRegion(this.authorityOptions.azureRegionConfiguration?.environmentRegion, this.regionDiscoveryMetadata);
         const azureRegion = this.authorityOptions.azureRegionConfiguration?.azureRegion ===
             Constants.AZURE_REGION_AUTO_DISCOVER_FLAG
@@ -7765,7 +7738,7 @@ class Authority {
      * @returns AuthorityMetadataSource
      */
     async updateCloudDiscoveryMetadata(metadataEntity) {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.AuthorityUpdateCloudDiscoveryMetadata, this.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthorityUpdateCloudDiscoveryMetadata, this.correlationId);
         this.logger.verbose("Attempting to get cloud discovery metadata in the config");
         this.logger.verbosePii(`Known Authorities: ${this.authorityOptions.knownAuthorities ||
             Constants.NOT_APPLICABLE}`);
@@ -7792,7 +7765,7 @@ class Authority {
             this.logger.verbose("The metadata entity is expired.");
         }
         this.logger.verbose("Did not find cloud discovery metadata in the cache... Attempting to get cloud discovery metadata from the network.");
-        this.performanceClient?.setPreQueueTime(exports.PerformanceEvents.AuthorityGetCloudDiscoveryMetadataFromNetwork, this.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.AuthorityGetCloudDiscoveryMetadataFromNetwork, this.correlationId);
         metadata = await this.getCloudDiscoveryMetadataFromNetwork();
         if (metadata) {
             this.logger.verbose("cloud discovery metadata was successfully returned from getCloudDiscoveryMetadataFromNetwork()");
@@ -7815,7 +7788,7 @@ class Authority {
      */
     getCloudDiscoveryMetadataFromConfig() {
         // CIAM does not support cloud discovery metadata
-        if (this.authorityType === exports.AuthorityType.Ciam) {
+        if (this.authorityType === AuthorityType.Ciam) {
             this.logger.verbose("CIAM authorities do not support cloud discovery metadata, generate the aliases from authority host.");
             return Authority.createCloudDiscoveryMetadataFromHost(this.hostnameAndPort);
         }
@@ -7853,7 +7826,7 @@ class Authority {
      * @param hasHardcodedMetadata boolean
      */
     async getCloudDiscoveryMetadataFromNetwork() {
-        this.performanceClient?.addQueueMeasurement(exports.PerformanceEvents.AuthorityGetCloudDiscoveryMetadataFromNetwork, this.correlationId);
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthorityGetCloudDiscoveryMetadataFromNetwork, this.correlationId);
         const instanceDiscoveryEndpoint = `${Constants.AAD_INSTANCE_DISCOVERY_ENDPT}${this.canonicalAuthority}oauth2/v2.0/authorize`;
         const options = {};
         /*
@@ -7936,7 +7909,7 @@ class Authority {
     static generateAuthority(authorityString, azureCloudOptions) {
         let authorityAzureCloudInstance;
         if (azureCloudOptions &&
-            azureCloudOptions.azureCloudInstance !== exports.AzureCloudInstance.None) {
+            azureCloudOptions.azureCloudInstance !== AzureCloudInstance.None) {
             const tenant = azureCloudOptions.tenant
                 ? azureCloudOptions.tenant
                 : Constants.DEFAULT_COMMON_TENANT;
@@ -8065,9 +8038,9 @@ class Authority {
 Authority.reservedTenantDomains = (new Set([
     "{tenant}",
     "{tenantid}",
-    exports.AADAuthorityConstants.COMMON,
-    exports.AADAuthorityConstants.CONSUMERS,
-    exports.AADAuthorityConstants.ORGANIZATIONS
+    AADAuthorityConstants.COMMON,
+    AADAuthorityConstants.CONSUMERS,
+    AADAuthorityConstants.ORGANIZATIONS
 ]));
 
 /*
@@ -8086,12 +8059,12 @@ class AuthorityFactory {
      * @param protocolMode
      */
     static async createDiscoveredInstance(authorityUri, networkClient, cacheManager, authorityOptions, logger, performanceClient, correlationId) {
-        performanceClient?.addQueueMeasurement(exports.PerformanceEvents.AuthorityFactoryCreateDiscoveredInstance, correlationId);
+        performanceClient?.addQueueMeasurement(PerformanceEvents.AuthorityFactoryCreateDiscoveredInstance, correlationId);
         const authorityUriFinal = Authority.transformCIAMAuthority(authorityUri);
         // Initialize authority and perform discovery endpoint check.
         const acquireTokenAuthority = AuthorityFactory.createInstance(authorityUriFinal, networkClient, cacheManager, authorityOptions, logger, performanceClient, correlationId);
         try {
-            performanceClient?.setPreQueueTime(exports.PerformanceEvents.AuthorityResolveEndpointsAsync, correlationId);
+            performanceClient?.setPreQueueTime(PerformanceEvents.AuthorityResolveEndpointsAsync, correlationId);
             await acquireTokenAuthority.resolveEndpointsAsync();
             return acquireTokenAuthority;
         }
@@ -8280,22 +8253,22 @@ class AuthenticationHeaderParser {
      */
     getShrNonce() {
         // Attempt to parse nonce from Authentiacation-Info
-        const authenticationInfo = this.headers[exports.HeaderNames.AuthenticationInfo];
+        const authenticationInfo = this.headers[HeaderNames.AuthenticationInfo];
         if (authenticationInfo) {
             const authenticationInfoChallenges = this.parseChallenges(authenticationInfo);
             if (authenticationInfoChallenges.nextnonce) {
                 return authenticationInfoChallenges.nextnonce;
             }
-            throw ClientConfigurationError.createInvalidAuthenticationHeaderError(exports.HeaderNames.AuthenticationInfo, "nextnonce challenge is missing.");
+            throw ClientConfigurationError.createInvalidAuthenticationHeaderError(HeaderNames.AuthenticationInfo, "nextnonce challenge is missing.");
         }
         // Attempt to parse nonce from WWW-Authenticate
-        const wwwAuthenticate = this.headers[exports.HeaderNames.WWWAuthenticate];
+        const wwwAuthenticate = this.headers[HeaderNames.WWWAuthenticate];
         if (wwwAuthenticate) {
             const wwwAuthenticateChallenges = this.parseChallenges(wwwAuthenticate);
             if (wwwAuthenticateChallenges.nonce) {
                 return wwwAuthenticateChallenges.nonce;
             }
-            throw ClientConfigurationError.createInvalidAuthenticationHeaderError(exports.HeaderNames.WWWAuthenticate, "nonce challenge is missing.");
+            throw ClientConfigurationError.createInvalidAuthenticationHeaderError(HeaderNames.WWWAuthenticate, "nonce challenge is missing.");
         }
         // If neither header is present, throw missing headers error
         throw ClientConfigurationError.createMissingNonceAuthenticationHeadersError();
@@ -8324,7 +8297,7 @@ class AuthenticationHeaderParser {
  */
 class ServerTelemetryManager {
     constructor(telemetryRequest, cacheManager) {
-        this.cacheOutcome = exports.CacheOutcome.NO_CACHE_HIT;
+        this.cacheOutcome = CacheOutcome.NO_CACHE_HIT;
         this.cacheManager = cacheManager;
         this.apiId = telemetryRequest.apiId;
         this.correlationId = telemetryRequest.correlationId;
@@ -8665,7 +8638,7 @@ class PerformanceClient {
         performanceMeasurement.startMeasurement();
         const inProgressEvent = {
             eventId: this.generateId(),
-            status: exports.PerformanceEventStatus.InProgress,
+            status: PerformanceEventStatus.InProgress,
             authority: this.authority,
             libraryName: this.libraryName,
             libraryVersion: this.libraryVersion,
@@ -8757,7 +8730,7 @@ class PerformanceClient {
             queuedTimeMs: queueInfo.totalQueueTime,
             queuedCount: queueInfo.totalQueueCount,
             queuedManuallyCompletedCount: queueInfo.manuallyCompletedCount,
-            status: exports.PerformanceEventStatus.Completed,
+            status: PerformanceEventStatus.Completed,
             incompleteSubsCount,
         };
         this.truncateIntegralFields(finalEvent, this.getIntFields());
@@ -8927,13 +8900,9 @@ class PerformanceClient {
  * Licensed under the MIT License.
  */
 class StubPerformanceMeasurement {
-    /* eslint-disable-next-line @typescript-eslint/no-empty-function */
-    startMeasurement() { }
-    /* eslint-disable-next-line @typescript-eslint/no-empty-function */
-    endMeasurement() { }
-    flushMeasurement() {
-        return null;
-    }
+    startMeasurement() { return; }
+    endMeasurement() { return; }
+    flushMeasurement() { return null; }
 }
 class StubPerformanceClient extends PerformanceClient {
     generateId() {
@@ -8942,23 +8911,15 @@ class StubPerformanceClient extends PerformanceClient {
     startPerformanceMeasurement() {
         return new StubPerformanceMeasurement();
     }
-    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
-    calculateQueuedTime(preQueueTime, currentTime) {
+    calculateQueuedTime() {
         return 0;
     }
-    addQueueMeasurement(eventName, // eslint-disable-line @typescript-eslint/no-unused-vars
-    correlationId, // eslint-disable-line @typescript-eslint/no-unused-vars
-    queueTime // eslint-disable-line @typescript-eslint/no-unused-vars
-    ) {
-        return;
-    }
-    setPreQueueTime(eventName, // eslint-disable-line @typescript-eslint/no-unused-vars
-    correlationId // eslint-disable-line @typescript-eslint/no-unused-vars
-    ) {
-        return;
-    }
+    addQueueMeasurement() { return; }
+    setPreQueueTime() { return; }
 }
 
+exports.AADAuthorityConstants = AADAuthorityConstants;
+exports.AADServerParamKeys = AADServerParamKeys;
 exports.AccessTokenEntity = AccessTokenEntity;
 exports.AccountEntity = AccountEntity;
 exports.AppMetadataEntity = AppMetadataEntity;
@@ -8966,13 +8927,21 @@ exports.AuthError = AuthError;
 exports.AuthErrorMessage = AuthErrorMessage;
 exports.AuthToken = AuthToken;
 exports.AuthenticationHeaderParser = AuthenticationHeaderParser;
+exports.AuthenticationScheme = AuthenticationScheme;
 exports.Authority = Authority;
 exports.AuthorityFactory = AuthorityFactory;
 exports.AuthorityMetadataEntity = AuthorityMetadataEntity;
+exports.AuthorityType = AuthorityType;
 exports.AuthorizationCodeClient = AuthorizationCodeClient;
+exports.AzureCloudInstance = AzureCloudInstance;
 exports.BaseClient = BaseClient;
+exports.CacheAccountType = CacheAccountType;
 exports.CacheManager = CacheManager;
+exports.CacheOutcome = CacheOutcome;
 exports.CacheRecord = CacheRecord;
+exports.CacheType = CacheType;
+exports.CcsCredentialType = CcsCredentialType;
+exports.ClaimsRequestKeys = ClaimsRequestKeys;
 exports.ClientAuthError = ClientAuthError;
 exports.ClientAuthErrorMessage = ClientAuthErrorMessage;
 exports.ClientConfigurationError = ClientConfigurationError;
@@ -8980,10 +8949,13 @@ exports.ClientConfigurationErrorMessage = ClientConfigurationErrorMessage;
 exports.CodeChallengeMethodValues = CodeChallengeMethodValues;
 exports.Constants = Constants;
 exports.CredentialEntity = CredentialEntity;
+exports.CredentialType = CredentialType;
 exports.DEFAULT_CRYPTO_IMPLEMENTATION = DEFAULT_CRYPTO_IMPLEMENTATION;
 exports.DEFAULT_SYSTEM_OPTIONS = DEFAULT_SYSTEM_OPTIONS;
 exports.DefaultStorageClass = DefaultStorageClass;
 exports.Errors = Errors;
+exports.GrantType = GrantType;
+exports.HeaderNames = HeaderNames;
 exports.IdToken = AuthToken;
 exports.IdTokenEntity = IdTokenEntity;
 exports.IntFields = IntFields;
@@ -8994,14 +8966,21 @@ exports.Logger = Logger;
 exports.NetworkManager = NetworkManager;
 exports.OIDC_DEFAULT_SCOPES = OIDC_DEFAULT_SCOPES;
 exports.ONE_DAY_IN_MS = ONE_DAY_IN_MS;
+exports.PasswordGrantConstants = PasswordGrantConstants;
 exports.PerformanceClient = PerformanceClient;
+exports.PerformanceEventStatus = PerformanceEventStatus;
+exports.PerformanceEvents = PerformanceEvents;
+exports.PersistentCacheKeys = PersistentCacheKeys;
 exports.PopTokenGenerator = PopTokenGenerator;
 exports.PromptValue = PromptValue;
+exports.ProtocolMode = ProtocolMode;
 exports.ProtocolUtils = ProtocolUtils;
 exports.RefreshTokenClient = RefreshTokenClient;
 exports.RefreshTokenEntity = RefreshTokenEntity;
 exports.RequestParameterBuilder = RequestParameterBuilder;
 exports.ResponseHandler = ResponseHandler;
+exports.ResponseMode = ResponseMode;
+exports.SSOTypes = SSOTypes;
 exports.ScopeSet = ScopeSet;
 exports.ServerError = ServerError;
 exports.ServerTelemetryEntity = ServerTelemetryEntity;