plugin-data-source-mssql 2.0.2 → 2.0.4

package/dist/tedious/node_modules/@azure/msal-browser/dist/cache/BrowserCacheManager.mjs

@@ -1,8 +1,8 @@
-/*! @azure/msal-browser v4.28.2 2026-02-10 */
+/*! @azure/msal-browser v5.6.2 2026-03-27 */
 'use strict';
-import { CacheManager, TimeUtils, CacheHelpers, DEFAULT_TOKEN_RENEWAL_OFFSET_SEC, AuthToken, getTenantIdFromIdTokenClaims, buildTenantProfile, AccountEntity, createCacheError, CacheErrorCodes, invokeAsync, PerformanceEvents, Constants, PersistentCacheKeys, StringUtils, AuthenticationScheme, CacheError, DEFAULT_CRYPTO_IMPLEMENTATION, CredentialType } from '@azure/msal-common/browser';
+import { CacheManager, TimeUtils, CacheHelpers, Constants, AuthToken, getTenantIdFromIdTokenClaims, buildTenantProfile, AccountEntityUtils, createCacheError, CacheErrorCodes, invokeAsync, PerformanceEvents, StringUtils, CacheError, DEFAULT_CRYPTO_IMPLEMENTATION } from '@azure/msal-common/browser';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
-import { apiIdToName, BrowserCacheLocation, InMemoryCacheKeys, TemporaryCacheKeys, INTERACTION_TYPE, ApiId } from '../utils/BrowserConstants.mjs';
+import { apiIdToName, InMemoryCacheKeys, BrowserCacheLocation, TemporaryCacheKeys, INTERACTION_TYPE, ApiId } from '../utils/BrowserConstants.mjs';
 import { ACCOUNT_SCHEMA_VERSION, CREDENTIAL_SCHEMA_VERSION, VERSION_CACHE_KEY, getTokenKeysCacheKey, getAccountKeysCacheKey, PREFIX, CACHE_KEY_SEPARATOR } from './CacheKeys.mjs';
 import { LocalStorage } from './LocalStorage.mjs';
 import { SessionStorage } from './SessionStorage.mjs';
@@ -12,7 +12,7 @@ import { base64Encode } from '../encode/Base64Encode.mjs';
 import { CookieStorage } from './CookieStorage.mjs';
 import { getAccountKeys, getTokenKeys } from './CacheHelpers.mjs';
 import { EventType } from '../event/EventType.mjs';
-import { clearHash } from '../utils/BrowserUtils.mjs';
+import { clearHash, cancelPendingBridgeResponse } from '../utils/BrowserUtils.mjs';
 import { version } from '../packageMetadata.mjs';
 import { removeElementFromArray } from '../utils/Helpers.mjs';
 import { isEncrypted } from './EncryptedData.mjs';
@@ -24,8 +24,6 @@ import { noTokenRequestCacheError, unableToParseTokenRequestCacheError, interact
  */
 /**
  * This class implements the cache storage interface for MSAL through browser local or session storage.
- * Cookies are only used if storeAuthStateInCookie is true, and are only used for
- * parameters such as state and nonce, generally.
  */
 class BrowserCacheManager extends CacheManager {
     constructor(clientId, cacheConfig, cryptoImpl, logger, performanceClient, eventHandler, staticAuthorityOptions) {
@@ -34,7 +32,7 @@ class BrowserCacheManager extends CacheManager {
         this.logger = logger;
         this.internalStorage = new MemoryStorage();
         this.browserStorage = getStorageImplementation(clientId, cacheConfig.cacheLocation, logger, performanceClient);
-        this.temporaryCacheStorage = getStorageImplementation(clientId, cacheConfig.temporaryCacheLocation, logger, performanceClient);
+        this.temporaryCacheStorage = getStorageImplementation(clientId, BrowserCacheLocation.SessionStorage, logger, performanceClient);
         this.cookieStorage = new CookieStorage();
         this.eventHandler = eventHandler;
     }
@@ -115,7 +113,7 @@ class BrowserCacheManager extends CacheManager {
         if ((CacheHelpers.isAccessTokenEntity(decryptedData) ||
             CacheHelpers.isRefreshTokenEntity(decryptedData)) &&
             decryptedData.expiresOn &&
-            TimeUtils.isTokenExpired(decryptedData.expiresOn, DEFAULT_TOKEN_RENEWAL_OFFSET_SEC)) {
+            TimeUtils.isTokenExpired(decryptedData.expiresOn, Constants.DEFAULT_TOKEN_RENEWAL_OFFSET_SEC)) {
             this.browserStorage.removeItem(key);
             this.performanceClient.incrementFields({ expiredCacheRemovedCount: 1 }, correlationId);
             return null;
@@ -277,7 +275,7 @@ class BrowserCacheManager extends CacheManager {
                     tenantProfiles.push(newTenantProfile);
                 }
                 account.tenantProfiles = tenantProfiles;
-                const newAccountKey = this.generateAccountKey(AccountEntity.getAccountInfo(account));
+                const newAccountKey = this.generateAccountKey(AccountEntityUtils.getAccountInfo(account));
                 const kmsi = AuthToken.isKmsi(claims);
                 await this.setUserData(newAccountKey, JSON.stringify(account), correlationId, account.lastUpdatedAt, kmsi);
                 if (!currentAccountKeys.includes(newAccountKey)) {
@@ -312,7 +310,7 @@ class BrowserCacheManager extends CacheManager {
                 removeElementFromArray(credentialKeysToMigrate.accessToken, accessTokenKey);
                 continue;
             }
-            if (!Object.keys(kmsiMap).includes(oldSchemaData.homeAccountId)) {
+            if (!(oldSchemaData.homeAccountId in kmsiMap)) {
                 // Don't migrate tokens if we don't have an idToken for them
                 this.performanceClient.incrementFields({ skipATMigrateCount: 1 }, correlationId);
                 continue;
@@ -359,7 +357,7 @@ class BrowserCacheManager extends CacheManager {
                 removeElementFromArray(credentialKeysToMigrate.refreshToken, refreshTokenKey);
                 continue;
             }
-            if (!Object.keys(kmsiMap).includes(oldSchemaData.homeAccountId)) {
+            if (!(oldSchemaData.homeAccountId in kmsiMap)) {
                 // Don't migrate tokens if we don't have an idToken for them
                 this.performanceClient.incrementFields({ skipRTMigrateCount: 1 }, correlationId);
                 continue;
@@ -390,7 +388,7 @@ class BrowserCacheManager extends CacheManager {
     trackVersionChanges(correlationId) {
         const previousVersion = this.browserStorage.getItem(VERSION_CACHE_KEY);
         if (previousVersion) {
-            this.logger.info(`MSAL.js was last initialized by version: ${previousVersion}`);
+            this.logger.info("1wuc87", correlationId);
             this.performanceClient.addFields({ previousLibraryVersion: previousVersion }, correlationId);
         }
         if (previousVersion !== version) {
@@ -505,7 +503,7 @@ class BrowserCacheManager extends CacheManager {
         for (let i = 0; i <= maxRetries; i++) {
             try {
                 // Attempt to store item in cache, if cache is full this call will throw and we'll attempt to clear space by removing access tokens from the cache one by one, starting with tokens stored by previous versions of MSAL.js
-                await invokeAsync(this.browserStorage.setUserData.bind(this.browserStorage), PerformanceEvents.SetUserData, this.logger, this.performanceClient)(key, value, correlationId, timestamp, kmsi);
+                await invokeAsync(this.browserStorage.setUserData.bind(this.browserStorage), PerformanceEvents.SetUserData, this.logger, this.performanceClient, correlationId)(key, value, correlationId, timestamp, kmsi);
                 if (i > 0) {
                     // If any tokens were removed in order to store this item update the token keys array with the tokens removed
                     for (let schemaVersion = 0; schemaVersion <= CREDENTIAL_SCHEMA_VERSION; schemaVersion++) {
@@ -563,49 +561,36 @@ class BrowserCacheManager extends CacheManager {
      * @returns
      */
     getAccount(accountKey, correlationId) {
-        this.logger.trace("BrowserCacheManager.getAccount called");
+        this.logger.trace("1lfvm6", correlationId);
         const serializedAccount = this.browserStorage.getUserData(accountKey);
         if (!serializedAccount) {
             this.removeAccountKeyFromMap(accountKey, correlationId);
             return null;
         }
         const parsedAccount = this.validateAndParseJson(serializedAccount);
-        if (!parsedAccount || !AccountEntity.isAccountEntity(parsedAccount)) {
+        if (!parsedAccount ||
+            !AccountEntityUtils.isAccountEntity(parsedAccount)) {
             return null;
         }
+        const account = CacheManager.toObject({}, parsedAccount);
         this.performanceClient.addFields({
-            accountCachedBy: apiIdToName(parsedAccount.cachedByApiId),
+            accountCachedBy: apiIdToName(account.cachedByApiId),
         }, correlationId);
-        return CacheManager.toObject(new AccountEntity(), parsedAccount);
+        return account;
     }
     /**
      * set account entity in the platform cache
      * @param account
      */
     async setAccount(account, correlationId, kmsi, apiId) {
-        this.logger.trace("BrowserCacheManager.setAccount called");
-        const key = this.generateAccountKey(AccountEntity.getAccountInfo(account));
+        this.logger.trace("1bz3wr", correlationId);
+        const key = this.generateAccountKey(AccountEntityUtils.getAccountInfo(account));
         const timestamp = Date.now().toString();
         account.lastUpdatedAt = timestamp;
         account.cachedByApiId = apiId;
         await this.setUserData(key, JSON.stringify(account), correlationId, timestamp, kmsi);
-        const wasAdded = this.addAccountKeyToMap(key, correlationId);
+        this.addAccountKeyToMap(key, correlationId);
         this.performanceClient.addFields({ kmsi: kmsi }, correlationId);
-        /**
-         * @deprecated - Remove this in next major version in favor of more consistent LOGIN event
-         */
-        if (this.cacheConfig.cacheLocation ===
-            BrowserCacheLocation.LocalStorage &&
-            wasAdded) {
-            this.eventHandler.emitEvent(EventType.ACCOUNT_ADDED, undefined, AccountEntity.getAccountInfo(account));
-        }
-    }
-    /**
-     * Returns the array of account keys currently cached
-     * @returns
-     */
-    getAccountKeys() {
-        return getAccountKeys(this.browserStorage);
     }
     setAccountKeys(accountKeys, correlationId, schemaVersion = ACCOUNT_SCHEMA_VERSION) {
         if (accountKeys.length === 0) {
@@ -615,23 +600,30 @@ class BrowserCacheManager extends CacheManager {
             this.setItem(getAccountKeysCacheKey(schemaVersion), JSON.stringify(accountKeys), correlationId);
         }
     }
+    /**
+     * Returns the array of account keys currently cached
+     * @returns
+     */
+    getAccountKeys() {
+        return getAccountKeys(this.browserStorage);
+    }
     /**
      * Add a new account to the key map
      * @param key
      */
     addAccountKeyToMap(key, correlationId) {
-        this.logger.trace("BrowserCacheManager.addAccountKeyToMap called");
-        this.logger.tracePii(`BrowserCacheManager.addAccountKeyToMap called with key: ${key}`);
+        this.logger.trace("0rb85k", correlationId);
+        this.logger.tracePii("1l9bdo", correlationId);
         const accountKeys = this.getAccountKeys();
         if (accountKeys.indexOf(key) === -1) {
             // Only add key if it does not already exist in the map
             accountKeys.push(key);
             this.setItem(getAccountKeysCacheKey(), JSON.stringify(accountKeys), correlationId);
-            this.logger.verbose("BrowserCacheManager.addAccountKeyToMap account key added");
+            this.logger.verbose("0xia39", correlationId);
             return true;
         }
         else {
-            this.logger.verbose("BrowserCacheManager.addAccountKeyToMap account key already exists in map");
+            this.logger.verbose("0161kk", correlationId);
             return false;
         }
     }
@@ -640,17 +632,16 @@ class BrowserCacheManager extends CacheManager {
      * @param key
      */
     removeAccountKeyFromMap(key, correlationId) {
-        this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap called");
-        this.logger.tracePii(`BrowserCacheManager.removeAccountKeyFromMap called with key: ${key}`);
+        this.logger.trace("1jpigu", correlationId);
+        this.logger.tracePii("1xzspl", correlationId);
         const accountKeys = this.getAccountKeys();
         const removalIndex = accountKeys.indexOf(key);
         if (removalIndex > -1) {
             accountKeys.splice(removalIndex, 1);
             this.setAccountKeys(accountKeys, correlationId);
-            this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap account key removed");
         }
         else {
-            this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap key not found in existing map");
+            this.logger.trace("1dytu2", correlationId);
         }
     }
     /**
@@ -672,12 +663,6 @@ class BrowserCacheManager extends CacheManager {
                 this.browserStorage.removeItem(key);
             }
         });
-        /**
-         * @deprecated - Remove this in next major version in favor of more consistent LOGOUT event
-         */
-        if (this.cacheConfig.cacheLocation === BrowserCacheLocation.LocalStorage) {
-            this.eventHandler.emitEvent(EventType.ACCOUNT_REMOVED, undefined, account);
-        }
     }
     /**
      * Removes given idToken from the cache and from the key map
@@ -688,7 +673,7 @@ class BrowserCacheManager extends CacheManager {
         const tokenKeys = this.getTokenKeys();
         const idRemoval = tokenKeys.idToken.indexOf(key);
         if (idRemoval > -1) {
-            this.logger.info("idToken removed from tokenKeys map");
+            this.logger.info("05udv9", correlationId);
             tokenKeys.idToken.splice(idRemoval, 1);
             this.setTokenKeys(tokenKeys, correlationId);
         }
@@ -708,7 +693,7 @@ class BrowserCacheManager extends CacheManager {
      * @param tokenKeys
      */
     removeAccessTokenKeys(keys, correlationId, schemaVersion = CREDENTIAL_SCHEMA_VERSION) {
-        this.logger.trace("removeAccessTokenKey called");
+        this.logger.trace("17o18n", correlationId);
         const tokenKeys = this.getTokenKeys(schemaVersion);
         let keysRemoved = 0;
         keys.forEach((key) => {
@@ -719,7 +704,7 @@ class BrowserCacheManager extends CacheManager {
             }
         });
         if (keysRemoved > 0) {
-            this.logger.info(`removed ${keysRemoved} accessToken keys from tokenKeys map`);
+            this.logger.info("15i5d5", correlationId);
             this.setTokenKeys(tokenKeys, correlationId, schemaVersion);
             return;
         }
@@ -733,7 +718,7 @@ class BrowserCacheManager extends CacheManager {
         const tokenKeys = this.getTokenKeys();
         const refreshRemoval = tokenKeys.refreshToken.indexOf(key);
         if (refreshRemoval > -1) {
-            this.logger.info("refreshToken removed from tokenKeys map");
+            this.logger.info("1f4fq3", correlationId);
             tokenKeys.refreshToken.splice(refreshRemoval, 1);
             this.setTokenKeys(tokenKeys, correlationId);
         }
@@ -746,7 +731,7 @@ class BrowserCacheManager extends CacheManager {
         return getTokenKeys(this.clientId, this.browserStorage, schemaVersion);
     }
     /**
-     * Stores the token keys in the cache
+     * Sets the token keys in the cache
      * @param tokenKeys
      * @param correlationId
      * @returns
@@ -770,16 +755,16 @@ class BrowserCacheManager extends CacheManager {
     getIdTokenCredential(idTokenKey, correlationId) {
         const value = this.browserStorage.getUserData(idTokenKey);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getIdTokenCredential: called, no cache hit");
+            this.logger.trace("1jukz6", correlationId);
             this.removeIdToken(idTokenKey, correlationId);
             return null;
         }
         const parsedIdToken = this.validateAndParseJson(value);
         if (!parsedIdToken || !CacheHelpers.isIdTokenEntity(parsedIdToken)) {
-            this.logger.trace("BrowserCacheManager.getIdTokenCredential: called, no cache hit");
+            this.logger.trace("1jukz6", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getIdTokenCredential: cache hit");
+        this.logger.trace("01ju66", correlationId);
         return parsedIdToken;
     }
     /**
@@ -787,14 +772,14 @@ class BrowserCacheManager extends CacheManager {
      * @param idToken
      */
     async setIdTokenCredential(idToken, correlationId, kmsi) {
-        this.logger.trace("BrowserCacheManager.setIdTokenCredential called");
+        this.logger.trace("13hjll", correlationId);
         const idTokenKey = this.generateCredentialKey(idToken);
         const timestamp = Date.now().toString();
         idToken.lastUpdatedAt = timestamp;
         await this.setUserData(idTokenKey, JSON.stringify(idToken), correlationId, timestamp, kmsi);
         const tokenKeys = this.getTokenKeys();
         if (tokenKeys.idToken.indexOf(idTokenKey) === -1) {
-            this.logger.info("BrowserCacheManager: addTokenKey - idToken added to map");
+            this.logger.info("07jy92", correlationId);
             tokenKeys.idToken.push(idTokenKey);
             this.setTokenKeys(tokenKeys, correlationId);
         }
@@ -806,17 +791,17 @@ class BrowserCacheManager extends CacheManager {
     getAccessTokenCredential(accessTokenKey, correlationId) {
         const value = this.browserStorage.getUserData(accessTokenKey);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getAccessTokenCredential: called, no cache hit");
+            this.logger.trace("0bqvx8", correlationId);
             this.removeAccessTokenKeys([accessTokenKey], correlationId);
             return null;
         }
         const parsedAccessToken = this.validateAndParseJson(value);
         if (!parsedAccessToken ||
             !CacheHelpers.isAccessTokenEntity(parsedAccessToken)) {
-            this.logger.trace("BrowserCacheManager.getAccessTokenCredential: called, no cache hit");
+            this.logger.trace("0bqvx8", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getAccessTokenCredential: cache hit");
+        this.logger.trace("1o81rl", correlationId);
         return parsedAccessToken;
     }
     /**
@@ -824,7 +809,7 @@ class BrowserCacheManager extends CacheManager {
      * @param accessToken
      */
     async setAccessTokenCredential(accessToken, correlationId, kmsi) {
-        this.logger.trace("BrowserCacheManager.setAccessTokenCredential called");
+        this.logger.trace("1pondb", correlationId);
         const accessTokenKey = this.generateCredentialKey(accessToken);
         const timestamp = Date.now().toString();
         accessToken.lastUpdatedAt = timestamp;
@@ -834,7 +819,7 @@ class BrowserCacheManager extends CacheManager {
         if (index !== -1) {
             tokenKeys.accessToken.splice(index, 1); // Remove existing key before pushing to the end
         }
-        this.logger.trace(`access token ${index === -1 ? "added to" : "updated in"} map`);
+        this.logger.trace("1onhey", correlationId);
         tokenKeys.accessToken.push(accessTokenKey);
         this.setTokenKeys(tokenKeys, correlationId);
     }
@@ -845,17 +830,17 @@ class BrowserCacheManager extends CacheManager {
     getRefreshTokenCredential(refreshTokenKey, correlationId) {
         const value = this.browserStorage.getUserData(refreshTokenKey);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: called, no cache hit");
+            this.logger.trace("0jlizt", correlationId);
             this.removeRefreshToken(refreshTokenKey, correlationId);
             return null;
         }
         const parsedRefreshToken = this.validateAndParseJson(value);
         if (!parsedRefreshToken ||
             !CacheHelpers.isRefreshTokenEntity(parsedRefreshToken)) {
-            this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: called, no cache hit");
+            this.logger.trace("0jlizt", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: cache hit");
+        this.logger.trace("0nokxi", correlationId);
         return parsedRefreshToken;
     }
     /**
@@ -863,14 +848,14 @@ class BrowserCacheManager extends CacheManager {
      * @param refreshToken
      */
     async setRefreshTokenCredential(refreshToken, correlationId, kmsi) {
-        this.logger.trace("BrowserCacheManager.setRefreshTokenCredential called");
+        this.logger.trace("0tcg8d", correlationId);
         const refreshTokenKey = this.generateCredentialKey(refreshToken);
         const timestamp = Date.now().toString();
         refreshToken.lastUpdatedAt = timestamp;
         await this.setUserData(refreshTokenKey, JSON.stringify(refreshToken), correlationId, timestamp, kmsi);
         const tokenKeys = this.getTokenKeys();
         if (tokenKeys.refreshToken.indexOf(refreshTokenKey) === -1) {
-            this.logger.info("BrowserCacheManager: addTokenKey - refreshToken added to map");
+            this.logger.info("0eckjs", correlationId);
             tokenKeys.refreshToken.push(refreshTokenKey);
             this.setTokenKeys(tokenKeys, correlationId);
         }
@@ -878,48 +863,51 @@ class BrowserCacheManager extends CacheManager {
     /**
      * fetch appMetadata entity from the platform cache
      * @param appMetadataKey
+     * @param correlationId
      */
-    getAppMetadata(appMetadataKey) {
+    getAppMetadata(appMetadataKey, correlationId) {
         const value = this.browserStorage.getItem(appMetadataKey);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getAppMetadata: called, no cache hit");
+            this.logger.trace("1q101h", correlationId);
             return null;
         }
         const parsedMetadata = this.validateAndParseJson(value);
         if (!parsedMetadata ||
             !CacheHelpers.isAppMetadataEntity(appMetadataKey, parsedMetadata)) {
-            this.logger.trace("BrowserCacheManager.getAppMetadata: called, no cache hit");
+            this.logger.trace("1q101h", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getAppMetadata: cache hit");
+        this.logger.trace("19pvg2", correlationId);
         return parsedMetadata;
     }
     /**
      * set appMetadata entity to the platform cache
      * @param appMetadata
+     * @param correlationId
      */
     setAppMetadata(appMetadata, correlationId) {
-        this.logger.trace("BrowserCacheManager.setAppMetadata called");
+        this.logger.trace("0cyma6", correlationId);
         const appMetadataKey = CacheHelpers.generateAppMetadataKey(appMetadata);
         this.setItem(appMetadataKey, JSON.stringify(appMetadata), correlationId);
     }
     /**
      * fetch server telemetry entity from the platform cache
      * @param serverTelemetryKey
+     * @param correlationId
      */
-    getServerTelemetry(serverTelemetryKey) {
+    getServerTelemetry(serverTelemetryKey, correlationId) {
         const value = this.browserStorage.getItem(serverTelemetryKey);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getServerTelemetry: called, no cache hit");
+            this.logger.trace("0jk19c", correlationId);
             return null;
         }
         const parsedEntity = this.validateAndParseJson(value);
         if (!parsedEntity ||
             !CacheHelpers.isServerTelemetryEntity(serverTelemetryKey, parsedEntity)) {
-            this.logger.trace("BrowserCacheManager.getServerTelemetry: called, no cache hit");
+            this.logger.trace("0jk19c", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getServerTelemetry: cache hit");
+        this.logger.trace("12jguk", correlationId);
         return parsedEntity;
     }
     /**
@@ -928,22 +916,22 @@ class BrowserCacheManager extends CacheManager {
      * @param serverTelemetry
      */
     setServerTelemetry(serverTelemetryKey, serverTelemetry, correlationId) {
-        this.logger.trace("BrowserCacheManager.setServerTelemetry called");
+        this.logger.trace("1poh61", correlationId);
         this.setItem(serverTelemetryKey, JSON.stringify(serverTelemetry), correlationId);
     }
     /**
      *
      */
-    getAuthorityMetadata(key) {
+    getAuthorityMetadata(key, correlationId) {
         const value = this.internalStorage.getItem(key);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getAuthorityMetadata: called, no cache hit");
+            this.logger.trace("1r39oe", correlationId);
             return null;
         }
         const parsedMetadata = this.validateAndParseJson(value);
         if (parsedMetadata &&
             CacheHelpers.isAuthorityMetadataEntity(key, parsedMetadata)) {
-            this.logger.trace("BrowserCacheManager.getAuthorityMetadata: cache hit");
+            this.logger.trace("1ohvk3", correlationId);
             return parsedMetadata;
         }
         return null;
@@ -970,40 +958,40 @@ class BrowserCacheManager extends CacheManager {
      * Returns wrapper metadata from in-memory storage
      */
     getWrapperMetadata() {
-        const sku = this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_SKU) ||
-            Constants.EMPTY_STRING;
-        const version = this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_VER) ||
-            Constants.EMPTY_STRING;
+        const sku = this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_SKU) || "";
+        const version = this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_VER) || "";
         return [sku, version];
     }
     /**
      *
+     * @param key
      * @param entity
+     * @param correlationId
      */
-    setAuthorityMetadata(key, entity) {
-        this.logger.trace("BrowserCacheManager.setAuthorityMetadata called");
+    setAuthorityMetadata(key, entity, correlationId) {
+        this.logger.trace("07w8n2", correlationId);
         this.internalStorage.setItem(key, JSON.stringify(entity));
     }
     /**
      * Gets the active account
      */
     getActiveAccount(correlationId) {
-        const activeAccountKeyFilters = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
+        const activeAccountKeyFilters = this.generateCacheKey(Constants.PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
         const activeAccountValueFilters = this.browserStorage.getItem(activeAccountKeyFilters);
         if (!activeAccountValueFilters) {
-            this.logger.trace("BrowserCacheManager.getActiveAccount: No active account filters found");
+            this.logger.trace("08gw0e", correlationId);
             return null;
         }
         const activeAccountValueObj = this.validateAndParseJson(activeAccountValueFilters);
         if (activeAccountValueObj) {
-            this.logger.trace("BrowserCacheManager.getActiveAccount: Active account filters schema found");
+            this.logger.trace("1t3ch7", correlationId);
             return this.getAccountInfoFilteredBy({
                 homeAccountId: activeAccountValueObj.homeAccountId,
                 localAccountId: activeAccountValueObj.localAccountId,
                 tenantId: activeAccountValueObj.tenantId,
             }, correlationId);
         }
-        this.logger.trace("BrowserCacheManager.getActiveAccount: No active account found");
+        this.logger.trace("0me1up", correlationId);
         return null;
     }
     /**
@@ -1011,40 +999,40 @@ class BrowserCacheManager extends CacheManager {
      * @param account
      */
     setActiveAccount(account, correlationId) {
-        const activeAccountKey = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
+        const activeAccountKey = this.generateCacheKey(Constants.PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
         if (account) {
-            this.logger.verbose("setActiveAccount: Active account set");
+            this.logger.verbose("0rsj80", correlationId);
             const activeAccountValue = {
                 homeAccountId: account.homeAccountId,
                 localAccountId: account.localAccountId,
                 tenantId: account.tenantId,
-                lastUpdatedAt: TimeUtils.nowSeconds().toString(),
             };
             this.setItem(activeAccountKey, JSON.stringify(activeAccountValue), correlationId);
         }
         else {
-            this.logger.verbose("setActiveAccount: No account passed, active account not set");
+            this.logger.verbose("1bp5z5", correlationId);
             this.browserStorage.removeItem(activeAccountKey);
         }
-        this.eventHandler.emitEvent(EventType.ACTIVE_ACCOUNT_CHANGED);
+        this.eventHandler.emitEvent(EventType.ACTIVE_ACCOUNT_CHANGED, correlationId);
     }
     /**
      * fetch throttling entity from the platform cache
      * @param throttlingCacheKey
+     * @param correlationId
      */
-    getThrottlingCache(throttlingCacheKey) {
+    getThrottlingCache(throttlingCacheKey, correlationId) {
         const value = this.browserStorage.getItem(throttlingCacheKey);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getThrottlingCache: called, no cache hit");
+            this.logger.trace("1h4wa6", correlationId);
             return null;
         }
         const parsedThrottlingCache = this.validateAndParseJson(value);
         if (!parsedThrottlingCache ||
             !CacheHelpers.isThrottlingEntity(throttlingCacheKey, parsedThrottlingCache)) {
-            this.logger.trace("BrowserCacheManager.getThrottlingCache: called, no cache hit");
+            this.logger.trace("1h4wa6", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getThrottlingCache: cache hit");
+        this.logger.trace("0of6n8", correlationId);
         return parsedThrottlingCache;
     }
     /**
@@ -1053,23 +1041,17 @@ class BrowserCacheManager extends CacheManager {
      * @param throttlingCache
      */
     setThrottlingCache(throttlingCacheKey, throttlingCache, correlationId) {
-        this.logger.trace("BrowserCacheManager.setThrottlingCache called");
+        this.logger.trace("0wfgh6", correlationId);
         this.setItem(throttlingCacheKey, JSON.stringify(throttlingCache), correlationId);
     }
     /**
      * Gets cache item with given key.
-     * Will retrieve from cookies if storeAuthStateInCookie is set to true.
-     * @param key
+     * @param cacheKey
+     * @param correlationId
+     * @param generateKey
      */
-    getTemporaryCache(cacheKey, generateKey) {
+    getTemporaryCache(cacheKey, correlationId, generateKey) {
         const key = generateKey ? this.generateCacheKey(cacheKey) : cacheKey;
-        if (this.cacheConfig.storeAuthStateInCookie) {
-            const itemCookie = this.cookieStorage.getItem(key);
-            if (itemCookie) {
-                this.logger.trace("BrowserCacheManager.getTemporaryCache: storeAuthStateInCookies set to true, retrieving from cookies");
-                return itemCookie;
-            }
-        }
         const value = this.temporaryCacheStorage.getItem(key);
         if (!value) {
             // If temp cache item not found in session/memory, check local storage for items set by old versions
@@ -1077,30 +1059,23 @@ class BrowserCacheManager extends CacheManager {
                 BrowserCacheLocation.LocalStorage) {
                 const item = this.browserStorage.getItem(key);
                 if (item) {
-                    this.logger.trace("BrowserCacheManager.getTemporaryCache: Temporary cache item found in local storage");
+                    this.logger.trace("1yt61y", correlationId);
                     return item;
                 }
             }
-            this.logger.trace("BrowserCacheManager.getTemporaryCache: No cache item found in local storage");
+            this.logger.trace("1qhy81", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getTemporaryCache: Temporary cache item returned");
         return value;
     }
     /**
      * Sets the cache item with the key and value given.
-     * Stores in cookie if storeAuthStateInCookie is set to true.
-     * This can cause cookie overflow if used incorrectly.
      * @param key
      * @param value
      */
     setTemporaryCache(cacheKey, value, generateKey) {
         const key = generateKey ? this.generateCacheKey(cacheKey) : cacheKey;
         this.temporaryCacheStorage.setItem(key, value);
-        if (this.cacheConfig.storeAuthStateInCookie) {
-            this.logger.trace("BrowserCacheManager.setTemporaryCache: storeAuthStateInCookie set to true, setting item cookie");
-            this.cookieStorage.setItem(key, value, undefined, this.cacheConfig.secureCookies);
-        }
     }
     /**
      * Removes the cache item with the given key.
@@ -1111,15 +1086,10 @@ class BrowserCacheManager extends CacheManager {
     }
     /**
      * Removes the temporary cache item with the given key.
-     * Will also clear the cookie item if storeAuthStateInCookie is set to true.
      * @param key
      */
     removeTemporaryItem(key) {
         this.temporaryCacheStorage.removeItem(key);
-        if (this.cacheConfig.storeAuthStateInCookie) {
-            this.logger.trace("BrowserCacheManager.removeItem: storeAuthStateInCookie is true, clearing item cookie");
-            this.cookieStorage.removeItem(key);
-        }
     }
     /**
      * Gets all keys in window.
@@ -1150,30 +1120,6 @@ class BrowserCacheManager extends CacheManager {
         });
         this.internalStorage.clear();
     }
-    /**
-     * Clears all access tokes that have claims prior to saving the current one
-     * @param performanceClient {IPerformanceClient}
-     * @param correlationId {string} correlation id
-     * @returns
-     */
-    clearTokensAndKeysWithClaims(correlationId) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.ClearTokensAndKeysWithClaims, correlationId);
-        const tokenKeys = this.getTokenKeys();
-        let removedAccessTokens = 0;
-        tokenKeys.accessToken.forEach((key) => {
-            // if the access token has claims in its key, remove the token key and the token
-            const credential = this.getAccessTokenCredential(key, correlationId);
-            if (credential?.requestedClaimsHash &&
-                key.includes(credential.requestedClaimsHash.toLowerCase())) {
-                this.removeAccessToken(key, correlationId);
-                removedAccessTokens++;
-            }
-        });
-        // warn if any access tokens are removed
-        if (removedAccessTokens > 0) {
-            this.logger.warning(`${removedAccessTokens} access tokens with claims in the cache keys have been removed from the cache.`);
-        }
-    }
     /**
      * Prepend msal.<client-id> to each key
      * @param key
@@ -1194,12 +1140,13 @@ class BrowserCacheManager extends CacheManager {
      * @returns
      */
     generateCredentialKey(credential) {
-        const familyId = (credential.credentialType === CredentialType.REFRESH_TOKEN &&
+        const familyId = (credential.credentialType ===
+            Constants.CredentialType.REFRESH_TOKEN &&
             credential.familyId) ||
             credential.clientId;
         const scheme = credential.tokenType &&
             credential.tokenType.toLowerCase() !==
-                AuthenticationScheme.BEARER.toLowerCase()
+                Constants.AuthenticationScheme.BEARER.toLowerCase()
             ? credential.tokenType.toLowerCase()
             : "";
         const credentialKey = [
@@ -1210,7 +1157,6 @@ class BrowserCacheManager extends CacheManager {
             familyId,
             credential.realm || "",
             credential.target || "",
-            credential.requestedClaimsHash || "",
             scheme,
         ];
         return credentialKey.join(CACHE_KEY_SEPARATOR).toLowerCase();
@@ -1232,19 +1178,19 @@ class BrowserCacheManager extends CacheManager {
     }
     /**
      * Reset all temporary cache items
-     * @param state
+     * @param correlationId
      */
-    resetRequestCache() {
-        this.logger.trace("BrowserCacheManager.resetRequestCache called");
+    resetRequestCache(correlationId) {
+        this.logger.trace("0h0ynu", correlationId);
         this.removeTemporaryItem(this.generateCacheKey(TemporaryCacheKeys.REQUEST_PARAMS));
         this.removeTemporaryItem(this.generateCacheKey(TemporaryCacheKeys.VERIFIER));
         this.removeTemporaryItem(this.generateCacheKey(TemporaryCacheKeys.ORIGIN_URI));
         this.removeTemporaryItem(this.generateCacheKey(TemporaryCacheKeys.URL_HASH));
         this.removeTemporaryItem(this.generateCacheKey(TemporaryCacheKeys.NATIVE_REQUEST));
-        this.setInteractionInProgress(false);
+        this.setInteractionInProgress(false, undefined);
     }
-    cacheAuthorizeRequest(authCodeRequest, codeVerifier) {
-        this.logger.trace("BrowserCacheManager.cacheAuthorizeRequest called");
+    cacheAuthorizeRequest(authCodeRequest, correlationId, codeVerifier) {
+        this.logger.trace("1tzef5", correlationId);
         const encodedValue = base64Encode(JSON.stringify(authCodeRequest));
         this.setTemporaryCache(TemporaryCacheKeys.REQUEST_PARAMS, encodedValue, true);
         if (codeVerifier) {
@@ -1254,15 +1200,16 @@ class BrowserCacheManager extends CacheManager {
     }
     /**
      * Gets the token exchange parameters from the cache. Throws an error if nothing is found.
+     * @param correlationId
      */
-    getCachedRequest() {
-        this.logger.trace("BrowserCacheManager.getCachedRequest called");
+    getCachedRequest(correlationId) {
+        this.logger.trace("0uen20", correlationId);
         // Get token request from cache and parse as TokenExchangeParameters.
-        const encodedTokenRequest = this.getTemporaryCache(TemporaryCacheKeys.REQUEST_PARAMS, true);
+        const encodedTokenRequest = this.getTemporaryCache(TemporaryCacheKeys.REQUEST_PARAMS, correlationId, true);
         if (!encodedTokenRequest) {
             throw createBrowserAuthError(noTokenRequestCacheError);
         }
-        const encodedVerifier = this.getTemporaryCache(TemporaryCacheKeys.VERIFIER, true);
+        const encodedVerifier = this.getTemporaryCache(TemporaryCacheKeys.VERIFIER, correlationId, true);
         let parsedRequest;
         let verifier = "";
         try {
@@ -1272,25 +1219,26 @@ class BrowserCacheManager extends CacheManager {
             }
         }
         catch (e) {
-            this.logger.errorPii(`Attempted to parse: ${encodedTokenRequest}`);
-            this.logger.error(`Parsing cached token request threw with error: ${e}`);
+            this.logger.errorPii("0ewsey", correlationId);
+            this.logger.error("0tvdic", correlationId);
             throw createBrowserAuthError(unableToParseTokenRequestCacheError);
         }
         return [parsedRequest, verifier];
     }
     /**
      * Gets cached native request for redirect flows
+     * @param correlationId
      */
     getCachedNativeRequest() {
-        this.logger.trace("BrowserCacheManager.getCachedNativeRequest called");
-        const cachedRequest = this.getTemporaryCache(TemporaryCacheKeys.NATIVE_REQUEST, true);
+        this.logger.trace("1yxcdm", "");
+        const cachedRequest = this.getTemporaryCache(TemporaryCacheKeys.NATIVE_REQUEST, "", true);
         if (!cachedRequest) {
-            this.logger.trace("BrowserCacheManager.getCachedNativeRequest: No cached native request found");
+            this.logger.trace("0mnxd4", "");
             return null;
         }
         const parsedRequest = this.validateAndParseJson(cachedRequest);
         if (!parsedRequest) {
-            this.logger.error("BrowserCacheManager.getCachedNativeRequest: Unable to parse native request");
+            this.logger.error("0rrkip", "");
             return null;
         }
         return parsedRequest;
@@ -1306,30 +1254,38 @@ class BrowserCacheManager extends CacheManager {
     }
     getInteractionInProgress() {
         const key = `${PREFIX}.${TemporaryCacheKeys.INTERACTION_STATUS_KEY}`;
-        const value = this.getTemporaryCache(key, false);
+        const value = this.getTemporaryCache(key, "", false);
         try {
             return value ? JSON.parse(value) : null;
         }
         catch (e) {
             // Remove interaction and other temp keys if interaction status can't be parsed
-            this.logger.error(`Cannot parse interaction status. Removing temporary cache items and clearing url hash. Retrying interaction should fix the error`);
+            this.logger.error("0jjyys", "");
             this.removeTemporaryItem(key);
-            this.resetRequestCache();
+            this.resetRequestCache("");
             clearHash(window);
             return null;
         }
     }
-    setInteractionInProgress(inProgress, type = INTERACTION_TYPE.SIGNIN) {
+    setInteractionInProgress(inProgress, type = INTERACTION_TYPE.SIGNIN, allowOverride = false, correlationId = "") {
         // Ensure we don't overwrite interaction in progress for a different clientId
         const key = `${PREFIX}.${TemporaryCacheKeys.INTERACTION_STATUS_KEY}`;
         if (inProgress) {
-            if (this.getInteractionInProgress()) {
-                throw createBrowserAuthError(interactionInProgress);
-            }
-            else {
-                // No interaction is in progress
-                this.setTemporaryCache(key, JSON.stringify({ clientId: this.clientId, type }), false);
+            const existingInteraction = this.getInteractionInProgress();
+            if (existingInteraction) {
+                if (allowOverride) {
+                    this.logger.warning("1pmscr", correlationId);
+                    // Cancel any active bridge monitor from the previous interaction
+                    cancelPendingBridgeResponse(this.logger, correlationId);
+                    // Clear existing interaction to allow new one
+                    this.removeTemporaryItem(key);
+                }
+                else {
+                    throw createBrowserAuthError(interactionInProgress);
+                }
             }
+            // Set new interaction
+            this.setTemporaryCache(key, JSON.stringify({ clientId: this.clientId, type }), false);
         }
         else if (!inProgress &&
             this.getInteractionInProgress()?.clientId === this.clientId) {
@@ -1343,10 +1299,6 @@ class BrowserCacheManager extends CacheManager {
      */
     async hydrateCache(result, request) {
         const idTokenEntity = CacheHelpers.createIdTokenEntity(result.account.homeAccountId, result.account.environment, result.idToken, this.clientId, result.tenantId);
-        let claimsHash;
-        if (request.claims) {
-            claimsHash = await this.cryptoImpl.hashString(request.claims);
-        }
         /**
          * meta data for cache stores time in seconds from epoch
          * AuthenticationResult returns expiresOn and extExpiresOn in milliseconds (as a Date object which is in ms)
@@ -1362,7 +1314,10 @@ class BrowserCacheManager extends CacheManager {
             ? TimeUtils.toSecondsFromDate(result.extExpiresOn)
             : 0, base64Decode, undefined, // refreshOn
         result.tokenType, undefined, // userAssertionHash
-        request.sshKid, request.claims, claimsHash);
+        request.sshKid);
+        if (request.resource) {
+            accessTokenEntity.resource = request.resource;
+        }
         const cacheRecord = {
             idToken: idTokenEntity,
             accessToken: accessTokenEntity,
@@ -1414,7 +1369,7 @@ function getStorageImplementation(clientId, cacheLocation, logger, performanceCl
         }
     }
     catch (e) {
-        logger.error(e);
+        logger.error(e, "");
     }
     return new MemoryStorage();
 }
@@ -1422,11 +1377,6 @@ const DEFAULT_BROWSER_CACHE_MANAGER = (clientId, logger, performanceClient, even
     const cacheOptions = {
         cacheLocation: BrowserCacheLocation.MemoryStorage,
         cacheRetentionDays: 5,
-        temporaryCacheLocation: BrowserCacheLocation.MemoryStorage,
-        storeAuthStateInCookie: false,
-        secureCookies: false,
-        cacheMigrationEnabled: false,
-        claimsBasedCachingEnabled: false,
     };
     return new BrowserCacheManager(clientId, cacheOptions, DEFAULT_CRYPTO_IMPLEMENTATION, logger, performanceClient, eventHandler);
 };