@azure/msal-common 13.0.0 → 14.0.0-alpha.1

package/dist/cache/CacheManager.js

@@ -1,6 +1,5 @@
-/*! @azure/msal-common v13.0.0 2023-05-01 */
+/*! @azure/msal-common v14.0.0-alpha.1 2023-05-08 */
 'use strict';
-import { __awaiter, __generator, __assign, __extends } from '../_virtual/_tslib.js';
 import { Separators, CredentialType, AuthenticationScheme, THE_FAMILY_ID, APP_METADATA, AUTHORITY_METADATA_CONSTANTS } from '../utils/Constants.js';
 import { ScopeSet } from '../request/ScopeSet.js';
 import { AccountEntity } from './entities/AccountEntity.js';
@@ -16,8 +15,8 @@ import { name, version } from '../packageMetadata.js';
 /**
  * Interface class which implement cache storage functions used by MSAL to perform validity checks, and store tokens.
  */
-var CacheManager = /** @class */ (function () {
-    function CacheManager(clientId, cryptoImpl, logger) {
+class CacheManager {
+    constructor(clientId, cryptoImpl, logger) {
         this.clientId = clientId;
         this.cryptoImpl = cryptoImpl;
         this.commonLogger = logger.clone(name, version);
@@ -25,14 +24,13 @@ var CacheManager = /** @class */ (function () {
     /**
      * Returns all accounts in cache
      */
-    CacheManager.prototype.getAllAccounts = function () {
-        var _this = this;
-        var allAccountKeys = this.getAccountKeys();
+    getAllAccounts() {
+        const allAccountKeys = this.getAccountKeys();
         if (allAccountKeys.length < 1) {
             return [];
         }
-        var accountEntities = allAccountKeys.reduce(function (accounts, key) {
-            var entity = _this.getAccount(key);
+        const accountEntities = allAccountKeys.reduce((accounts, key) => {
+            const entity = this.getAccount(key);
             if (!entity) {
                 return accounts;
             }
@@ -43,112 +41,90 @@ var CacheManager = /** @class */ (function () {
             return [];
         }
         else {
-            var allAccounts = accountEntities.map(function (accountEntity) {
-                return _this.getAccountInfoFromEntity(accountEntity);
+            const allAccounts = accountEntities.map((accountEntity) => {
+                return this.getAccountInfoFromEntity(accountEntity);
             });
             return allAccounts;
         }
-    };
+    }
     /**
      * Gets accountInfo object based on provided filters
      */
-    CacheManager.prototype.getAccountInfoFilteredBy = function (accountFilter) {
-        var allAccounts = this.getAccountsFilteredBy(accountFilter);
+    getAccountInfoFilteredBy(accountFilter) {
+        const allAccounts = this.getAccountsFilteredBy(accountFilter);
         if (allAccounts.length > 0) {
             return this.getAccountInfoFromEntity(allAccounts[0]);
         }
         else {
             return null;
         }
-    };
-    CacheManager.prototype.getAccountInfoFromEntity = function (accountEntity) {
-        var accountInfo = accountEntity.getAccountInfo();
-        var idToken = this.getIdToken(accountInfo);
+    }
+    getAccountInfoFromEntity(accountEntity) {
+        const accountInfo = accountEntity.getAccountInfo();
+        const idToken = this.getIdToken(accountInfo);
         if (idToken) {
             accountInfo.idToken = idToken.secret;
             accountInfo.idTokenClaims = new AuthToken(idToken.secret, this.cryptoImpl).claims;
         }
         return accountInfo;
-    };
+    }
     /**
      * saves a cache record
      * @param cacheRecord
      */
-    CacheManager.prototype.saveCacheRecord = function (cacheRecord) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!cacheRecord) {
-                            throw ClientAuthError.createNullOrUndefinedCacheRecord();
-                        }
-                        if (!!cacheRecord.account) {
-                            this.setAccount(cacheRecord.account);
-                        }
-                        if (!!cacheRecord.idToken) {
-                            this.setIdTokenCredential(cacheRecord.idToken);
-                        }
-                        if (!!!cacheRecord.accessToken) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.saveAccessToken(cacheRecord.accessToken)];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        if (!!cacheRecord.refreshToken) {
-                            this.setRefreshTokenCredential(cacheRecord.refreshToken);
-                        }
-                        if (!!cacheRecord.appMetadata) {
-                            this.setAppMetadata(cacheRecord.appMetadata);
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async saveCacheRecord(cacheRecord) {
+        if (!cacheRecord) {
+            throw ClientAuthError.createNullOrUndefinedCacheRecord();
+        }
+        if (!!cacheRecord.account) {
+            this.setAccount(cacheRecord.account);
+        }
+        if (!!cacheRecord.idToken) {
+            this.setIdTokenCredential(cacheRecord.idToken);
+        }
+        if (!!cacheRecord.accessToken) {
+            await this.saveAccessToken(cacheRecord.accessToken);
+        }
+        if (!!cacheRecord.refreshToken) {
+            this.setRefreshTokenCredential(cacheRecord.refreshToken);
+        }
+        if (!!cacheRecord.appMetadata) {
+            this.setAppMetadata(cacheRecord.appMetadata);
+        }
+    }
     /**
      * saves access token credential
      * @param credential
      */
-    CacheManager.prototype.saveAccessToken = function (credential) {
-        return __awaiter(this, void 0, void 0, function () {
-            var accessTokenFilter, tokenKeys, currentScopes, removedAccessTokens;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        accessTokenFilter = {
-                            clientId: credential.clientId,
-                            credentialType: credential.credentialType,
-                            environment: credential.environment,
-                            homeAccountId: credential.homeAccountId,
-                            realm: credential.realm,
-                            tokenType: credential.tokenType,
-                            requestedClaimsHash: credential.requestedClaimsHash
-                        };
-                        tokenKeys = this.getTokenKeys();
-                        currentScopes = ScopeSet.fromString(credential.target);
-                        removedAccessTokens = [];
-                        tokenKeys.accessToken.forEach(function (key) {
-                            if (!_this.accessTokenKeyMatchesFilter(key, accessTokenFilter, false)) {
-                                return;
-                            }
-                            var tokenEntity = _this.getAccessTokenCredential(key);
-                            if (tokenEntity && _this.credentialMatchesFilter(tokenEntity, accessTokenFilter)) {
-                                var tokenScopeSet = ScopeSet.fromString(tokenEntity.target);
-                                if (tokenScopeSet.intersectingScopeSets(currentScopes)) {
-                                    removedAccessTokens.push(_this.removeAccessToken(key));
-                                }
-                            }
-                        });
-                        return [4 /*yield*/, Promise.all(removedAccessTokens)];
-                    case 1:
-                        _a.sent();
-                        this.setAccessTokenCredential(credential);
-                        return [2 /*return*/];
+    async saveAccessToken(credential) {
+        const accessTokenFilter = {
+            clientId: credential.clientId,
+            credentialType: credential.credentialType,
+            environment: credential.environment,
+            homeAccountId: credential.homeAccountId,
+            realm: credential.realm,
+            tokenType: credential.tokenType,
+            requestedClaimsHash: credential.requestedClaimsHash,
+        };
+        const tokenKeys = this.getTokenKeys();
+        const currentScopes = ScopeSet.fromString(credential.target);
+        const removedAccessTokens = [];
+        tokenKeys.accessToken.forEach((key) => {
+            if (!this.accessTokenKeyMatchesFilter(key, accessTokenFilter, false)) {
+                return;
+            }
+            const tokenEntity = this.getAccessTokenCredential(key);
+            if (tokenEntity &&
+                this.credentialMatchesFilter(tokenEntity, accessTokenFilter)) {
+                const tokenScopeSet = ScopeSet.fromString(tokenEntity.target);
+                if (tokenScopeSet.intersectingScopeSets(currentScopes)) {
+                    removedAccessTokens.push(this.removeAccessToken(key));
                 }
-            });
+            }
         });
-    };
+        await Promise.all(removedAccessTokens);
+        this.setAccessTokenCredential(credential);
+    }
     /**
      * retrieve accounts matching all provided filters; if no filter is set, get all accounts
      * not checking for casing as keys are all generated in lower case, remember to convert to lower case if object properties are compared
@@ -156,41 +132,46 @@ var CacheManager = /** @class */ (function () {
      * @param environment
      * @param realm
      */
-    CacheManager.prototype.getAccountsFilteredBy = function (accountFilter) {
-        var _this = this;
-        var allAccountKeys = this.getAccountKeys();
-        var matchingAccounts = [];
-        allAccountKeys.forEach(function (cacheKey) {
-            if (!_this.isAccountKey(cacheKey, accountFilter.homeAccountId, accountFilter.realm)) {
+    getAccountsFilteredBy(accountFilter) {
+        const allAccountKeys = this.getAccountKeys();
+        const matchingAccounts = [];
+        allAccountKeys.forEach((cacheKey) => {
+            if (!this.isAccountKey(cacheKey, accountFilter.homeAccountId, accountFilter.realm)) {
                 // Don't parse value if the key doesn't match the account filters
                 return;
             }
-            var entity = _this.getAccount(cacheKey);
+            const entity = this.getAccount(cacheKey);
             if (!entity) {
                 return;
             }
-            if (!!accountFilter.homeAccountId && !_this.matchHomeAccountId(entity, accountFilter.homeAccountId)) {
+            if (!!accountFilter.homeAccountId &&
+                !this.matchHomeAccountId(entity, accountFilter.homeAccountId)) {
                 return;
             }
-            if (!!accountFilter.localAccountId && !_this.matchLocalAccountId(entity, accountFilter.localAccountId)) {
+            if (!!accountFilter.localAccountId &&
+                !this.matchLocalAccountId(entity, accountFilter.localAccountId)) {
                 return;
             }
-            if (!!accountFilter.username && !_this.matchUsername(entity, accountFilter.username)) {
+            if (!!accountFilter.username &&
+                !this.matchUsername(entity, accountFilter.username)) {
                 return;
             }
-            if (!!accountFilter.environment && !_this.matchEnvironment(entity, accountFilter.environment)) {
+            if (!!accountFilter.environment &&
+                !this.matchEnvironment(entity, accountFilter.environment)) {
                 return;
             }
-            if (!!accountFilter.realm && !_this.matchRealm(entity, accountFilter.realm)) {
+            if (!!accountFilter.realm &&
+                !this.matchRealm(entity, accountFilter.realm)) {
                 return;
             }
-            if (!!accountFilter.nativeAccountId && !_this.matchNativeAccountId(entity, accountFilter.nativeAccountId)) {
+            if (!!accountFilter.nativeAccountId &&
+                !this.matchNativeAccountId(entity, accountFilter.nativeAccountId)) {
                 return;
             }
             matchingAccounts.push(entity);
         });
         return matchingAccounts;
-    };
+    }
     /**
      * Returns true if the given key matches our account key schema. Also matches homeAccountId and/or tenantId if provided
      * @param key
@@ -198,12 +179,13 @@ var CacheManager = /** @class */ (function () {
      * @param tenantId
      * @returns
      */
-    CacheManager.prototype.isAccountKey = function (key, homeAccountId, tenantId) {
+    isAccountKey(key, homeAccountId, tenantId) {
         if (key.split(Separators.CACHE_KEY_SEPARATOR).length < 3) {
             // Account cache keys contain 3 items separated by '-' (each item may also contain '-')
             return false;
         }
-        if (homeAccountId && !key.toLowerCase().includes(homeAccountId.toLowerCase())) {
+        if (homeAccountId &&
+            !key.toLowerCase().includes(homeAccountId.toLowerCase())) {
             return false;
         }
         if (tenantId && !key.toLowerCase().includes(tenantId.toLowerCase())) {
@@ -211,29 +193,34 @@ var CacheManager = /** @class */ (function () {
         }
         // Do not check environment as aliasing can cause false negatives
         return true;
-    };
+    }
     /**
      * Returns true if the given key matches our credential key schema.
      * @param key
      */
-    CacheManager.prototype.isCredentialKey = function (key) {
+    isCredentialKey(key) {
         if (key.split(Separators.CACHE_KEY_SEPARATOR).length < 6) {
             // Credential cache keys contain 6 items separated by '-' (each item may also contain '-')
             return false;
         }
-        var lowerCaseKey = key.toLowerCase();
+        const lowerCaseKey = key.toLowerCase();
         // Credential keys must indicate what credential type they represent
-        if (lowerCaseKey.indexOf(CredentialType.ID_TOKEN.toLowerCase()) === -1 &&
-            lowerCaseKey.indexOf(CredentialType.ACCESS_TOKEN.toLowerCase()) === -1 &&
+        if (lowerCaseKey.indexOf(CredentialType.ID_TOKEN.toLowerCase()) ===
+            -1 &&
+            lowerCaseKey.indexOf(CredentialType.ACCESS_TOKEN.toLowerCase()) ===
+                -1 &&
             lowerCaseKey.indexOf(CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME.toLowerCase()) === -1 &&
-            lowerCaseKey.indexOf(CredentialType.REFRESH_TOKEN.toLowerCase()) === -1) {
+            lowerCaseKey.indexOf(CredentialType.REFRESH_TOKEN.toLowerCase()) ===
+                -1) {
             return false;
         }
-        if (lowerCaseKey.indexOf(CredentialType.REFRESH_TOKEN.toLowerCase()) > -1) {
+        if (lowerCaseKey.indexOf(CredentialType.REFRESH_TOKEN.toLowerCase()) >
+            -1) {
             // Refresh tokens must contain the client id or family id
-            var clientIdValidation = "" + CredentialType.REFRESH_TOKEN + Separators.CACHE_KEY_SEPARATOR + this.clientId + Separators.CACHE_KEY_SEPARATOR;
-            var 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) {
+            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;
             }
         }
@@ -242,34 +229,38 @@ var CacheManager = /** @class */ (function () {
             return false;
         }
         return true;
-    };
+    }
     /**
      * Returns whether or not the given credential entity matches the filter
      * @param entity
      * @param filter
      * @returns
      */
-    CacheManager.prototype.credentialMatchesFilter = function (entity, filter) {
+    credentialMatchesFilter(entity, filter) {
         if (!!filter.clientId && !this.matchClientId(entity, filter.clientId)) {
             return false;
         }
-        if (!!filter.userAssertionHash && !this.matchUserAssertionHash(entity, filter.userAssertionHash)) {
+        if (!!filter.userAssertionHash &&
+            !this.matchUserAssertionHash(entity, filter.userAssertionHash)) {
             return false;
         }
         /*
          * homeAccountId can be undefined, and we want to filter out cached items that have a homeAccountId of ""
          * because we don't want a client_credential request to return a cached token that has a homeAccountId
          */
-        if ((typeof filter.homeAccountId === "string") && !this.matchHomeAccountId(entity, filter.homeAccountId)) {
+        if (typeof filter.homeAccountId === "string" &&
+            !this.matchHomeAccountId(entity, filter.homeAccountId)) {
             return false;
         }
-        if (!!filter.environment && !this.matchEnvironment(entity, filter.environment)) {
+        if (!!filter.environment &&
+            !this.matchEnvironment(entity, filter.environment)) {
             return false;
         }
         if (!!filter.realm && !this.matchRealm(entity, filter.realm)) {
             return false;
         }
-        if (!!filter.credentialType && !this.matchCredentialType(entity, filter.credentialType)) {
+        if (!!filter.credentialType &&
+            !this.matchCredentialType(entity, filter.credentialType)) {
             return false;
         }
         if (!!filter.familyId && !this.matchFamilyId(entity, filter.familyId)) {
@@ -290,8 +281,10 @@ var CacheManager = /** @class */ (function () {
             }
         }
         // Access Token with Auth Scheme specific matching
-        if (entity.credentialType === CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME) {
-            if (!!filter.tokenType && !this.matchTokenType(entity, filter.tokenType)) {
+        if (entity.credentialType ===
+            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
@@ -302,58 +295,57 @@ var CacheManager = /** @class */ (function () {
             }
         }
         return true;
-    };
+    }
     /**
      * retrieve appMetadata matching all provided filters; if no filter is set, get all appMetadata
      * @param filter
      */
-    CacheManager.prototype.getAppMetadataFilteredBy = function (filter) {
+    getAppMetadataFilteredBy(filter) {
         return this.getAppMetadataFilteredByInternal(filter.environment, filter.clientId);
-    };
+    }
     /**
      * Support function to help match appMetadata
      * @param environment
      * @param clientId
      */
-    CacheManager.prototype.getAppMetadataFilteredByInternal = function (environment, clientId) {
-        var _this = this;
-        var allCacheKeys = this.getKeys();
-        var matchingAppMetadata = {};
-        allCacheKeys.forEach(function (cacheKey) {
+    getAppMetadataFilteredByInternal(environment, clientId) {
+        const allCacheKeys = this.getKeys();
+        const matchingAppMetadata = {};
+        allCacheKeys.forEach((cacheKey) => {
             // don't parse any non-appMetadata type cache entities
-            if (!_this.isAppMetadata(cacheKey)) {
+            if (!this.isAppMetadata(cacheKey)) {
                 return;
             }
             // Attempt retrieval
-            var entity = _this.getAppMetadata(cacheKey);
+            const entity = this.getAppMetadata(cacheKey);
             if (!entity) {
                 return;
             }
-            if (!!environment && !_this.matchEnvironment(entity, environment)) {
+            if (!!environment && !this.matchEnvironment(entity, environment)) {
                 return;
             }
-            if (!!clientId && !_this.matchClientId(entity, clientId)) {
+            if (!!clientId && !this.matchClientId(entity, clientId)) {
                 return;
             }
             matchingAppMetadata[cacheKey] = entity;
         });
         return matchingAppMetadata;
-    };
+    }
     /**
      * retrieve authorityMetadata that contains a matching alias
      * @param filter
      */
-    CacheManager.prototype.getAuthorityMetadataByAlias = function (host) {
-        var _this = this;
-        var allCacheKeys = this.getAuthorityMetadataKeys();
-        var matchedEntity = null;
-        allCacheKeys.forEach(function (cacheKey) {
+    getAuthorityMetadataByAlias(host) {
+        const allCacheKeys = this.getAuthorityMetadataKeys();
+        let matchedEntity = null;
+        allCacheKeys.forEach((cacheKey) => {
             // don't parse any non-authorityMetadata type cache entities
-            if (!_this.isAuthorityMetadata(cacheKey) || cacheKey.indexOf(_this.clientId) === -1) {
+            if (!this.isAuthorityMetadata(cacheKey) ||
+                cacheKey.indexOf(this.clientId) === -1) {
                 return;
             }
             // Attempt retrieval
-            var entity = _this.getAuthorityMetadata(cacheKey);
+            const entity = this.getAuthorityMetadata(cacheKey);
             if (!entity) {
                 return;
             }
@@ -363,137 +355,94 @@ var CacheManager = /** @class */ (function () {
             matchedEntity = entity;
         });
         return matchedEntity;
-    };
+    }
     /**
      * Removes all accounts and related tokens from cache.
      */
-    CacheManager.prototype.removeAllAccounts = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var allAccountKeys, removedAccounts;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        allAccountKeys = this.getAccountKeys();
-                        removedAccounts = [];
-                        allAccountKeys.forEach(function (cacheKey) {
-                            removedAccounts.push(_this.removeAccount(cacheKey));
-                        });
-                        return [4 /*yield*/, Promise.all(removedAccounts)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
+    async removeAllAccounts() {
+        const allAccountKeys = this.getAccountKeys();
+        const removedAccounts = [];
+        allAccountKeys.forEach((cacheKey) => {
+            removedAccounts.push(this.removeAccount(cacheKey));
         });
-    };
+        await Promise.all(removedAccounts);
+    }
     /**
      * Removes the account and related tokens for a given account key
      * @param account
      */
-    CacheManager.prototype.removeAccount = function (accountKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var account;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        account = this.getAccount(accountKey);
-                        if (!account) {
-                            throw ClientAuthError.createNoAccountFoundError();
-                        }
-                        return [4 /*yield*/, this.removeAccountContext(account)];
-                    case 1:
-                        _a.sent();
-                        this.removeItem(accountKey);
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async removeAccount(accountKey) {
+        const account = this.getAccount(accountKey);
+        if (!account) {
+            return;
+        }
+        await this.removeAccountContext(account);
+        this.removeItem(accountKey);
+    }
     /**
      * Removes credentials associated with the provided account
      * @param account
      */
-    CacheManager.prototype.removeAccountContext = function (account) {
-        return __awaiter(this, void 0, void 0, function () {
-            var allTokenKeys, accountId, removedCredentials;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        allTokenKeys = this.getTokenKeys();
-                        accountId = account.generateAccountId();
-                        removedCredentials = [];
-                        allTokenKeys.idToken.forEach(function (key) {
-                            if (key.indexOf(accountId) === 0) {
-                                _this.removeIdToken(key);
-                            }
-                        });
-                        allTokenKeys.accessToken.forEach(function (key) {
-                            if (key.indexOf(accountId) === 0) {
-                                removedCredentials.push(_this.removeAccessToken(key));
-                            }
-                        });
-                        allTokenKeys.refreshToken.forEach(function (key) {
-                            if (key.indexOf(accountId) === 0) {
-                                _this.removeRefreshToken(key);
-                            }
-                        });
-                        return [4 /*yield*/, Promise.all(removedCredentials)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
+    async removeAccountContext(account) {
+        const allTokenKeys = this.getTokenKeys();
+        const accountId = account.generateAccountId();
+        const removedCredentials = [];
+        allTokenKeys.idToken.forEach((key) => {
+            if (key.indexOf(accountId) === 0) {
+                this.removeIdToken(key);
+            }
+        });
+        allTokenKeys.accessToken.forEach((key) => {
+            if (key.indexOf(accountId) === 0) {
+                removedCredentials.push(this.removeAccessToken(key));
+            }
+        });
+        allTokenKeys.refreshToken.forEach((key) => {
+            if (key.indexOf(accountId) === 0) {
+                this.removeRefreshToken(key);
+            }
         });
-    };
+        await Promise.all(removedCredentials);
+    }
     /**
      * returns a boolean if the given credential is removed
      * @param credential
      */
-    CacheManager.prototype.removeAccessToken = function (key) {
-        return __awaiter(this, void 0, void 0, function () {
-            var credential, accessTokenWithAuthSchemeEntity, kid;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        credential = this.getAccessTokenCredential(key);
-                        if (!credential) {
-                            return [2 /*return*/];
-                        }
-                        if (!(credential.credentialType.toLowerCase() === CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME.toLowerCase())) return [3 /*break*/, 4];
-                        if (!(credential.tokenType === AuthenticationScheme.POP)) return [3 /*break*/, 4];
-                        accessTokenWithAuthSchemeEntity = credential;
-                        kid = accessTokenWithAuthSchemeEntity.keyId;
-                        if (!kid) return [3 /*break*/, 4];
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.cryptoImpl.removeTokenBindingKey(kid)];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _a.sent();
+    async removeAccessToken(key) {
+        const credential = this.getAccessTokenCredential(key);
+        if (!credential) {
+            return;
+        }
+        // Remove Token Binding Key from key store for PoP Tokens Credentials
+        if (credential.credentialType.toLowerCase() ===
+            CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME.toLowerCase()) {
+            if (credential.tokenType === AuthenticationScheme.POP) {
+                const accessTokenWithAuthSchemeEntity = credential;
+                const kid = accessTokenWithAuthSchemeEntity.keyId;
+                if (kid) {
+                    try {
+                        await this.cryptoImpl.removeTokenBindingKey(kid);
+                    }
+                    catch (error) {
                         throw ClientAuthError.createBindingKeyNotRemovedError();
-                    case 4: return [2 /*return*/, this.removeItem(key)];
+                    }
                 }
-            });
-        });
-    };
+            }
+        }
+        return this.removeItem(key);
+    }
     /**
      * Removes all app metadata objects from cache.
      */
-    CacheManager.prototype.removeAppMetadata = function () {
-        var _this = this;
-        var allCacheKeys = this.getKeys();
-        allCacheKeys.forEach(function (cacheKey) {
-            if (_this.isAppMetadata(cacheKey)) {
-                _this.removeItem(cacheKey);
+    removeAppMetadata() {
+        const allCacheKeys = this.getKeys();
+        allCacheKeys.forEach((cacheKey) => {
+            if (this.isAppMetadata(cacheKey)) {
+                this.removeItem(cacheKey);
             }
         });
         return true;
-    };
+    }
     /**
      * Retrieve the cached credentials into a cacherecord
      * @param account
@@ -502,13 +451,13 @@ var CacheManager = /** @class */ (function () {
      * @param environment
      * @param authScheme
      */
-    CacheManager.prototype.readCacheRecord = function (account, request, environment) {
-        var tokenKeys = this.getTokenKeys();
-        var cachedAccount = this.readAccountFromCache(account);
-        var cachedIdToken = this.getIdToken(account, tokenKeys);
-        var cachedAccessToken = this.getAccessToken(account, request, tokenKeys);
-        var cachedRefreshToken = this.getRefreshToken(account, false, tokenKeys);
-        var cachedAppMetadata = this.readAppMetadataFromCache(environment);
+    readCacheRecord(account, request, environment) {
+        const tokenKeys = this.getTokenKeys();
+        const cachedAccount = this.readAccountFromCache(account);
+        const cachedIdToken = this.getIdToken(account, tokenKeys);
+        const cachedAccessToken = this.getAccessToken(account, request, tokenKeys);
+        const cachedRefreshToken = this.getRefreshToken(account, false, tokenKeys);
+        const cachedAppMetadata = this.readAppMetadataFromCache(environment);
         if (cachedAccount && cachedIdToken) {
             cachedAccount.idTokenClaims = new AuthToken(cachedIdToken.secret, this.cryptoImpl).claims;
         }
@@ -519,32 +468,32 @@ var CacheManager = /** @class */ (function () {
             refreshToken: cachedRefreshToken,
             appMetadata: cachedAppMetadata,
         };
-    };
+    }
     /**
      * Retrieve AccountEntity from cache
      * @param account
      */
-    CacheManager.prototype.readAccountFromCache = function (account) {
-        var accountKey = AccountEntity.generateAccountCacheKey(account);
+    readAccountFromCache(account) {
+        const accountKey = AccountEntity.generateAccountCacheKey(account);
         return this.getAccount(accountKey);
-    };
+    }
     /**
      * Retrieve IdTokenEntity from cache
      * @param clientId
      * @param account
      * @param inputRealm
      */
-    CacheManager.prototype.getIdToken = function (account, tokenKeys) {
+    getIdToken(account, tokenKeys) {
         this.commonLogger.trace("CacheManager - getIdToken called");
-        var idTokenFilter = {
+        const idTokenFilter = {
             homeAccountId: account.homeAccountId,
             environment: account.environment,
             credentialType: CredentialType.ID_TOKEN,
             clientId: this.clientId,
             realm: account.tenantId,
         };
-        var idTokens = this.getIdTokensByFilter(idTokenFilter, tokenKeys);
-        var numIdTokens = idTokens.length;
+        const idTokens = this.getIdTokensByFilter(idTokenFilter, tokenKeys);
+        const numIdTokens = idTokens.length;
         if (numIdTokens < 1) {
             this.commonLogger.info("CacheManager:getIdToken - No token found");
             return null;
@@ -554,57 +503,61 @@ var CacheManager = /** @class */ (function () {
         }
         this.commonLogger.info("CacheManager:getIdToken - Returning id token");
         return idTokens[0];
-    };
+    }
     /**
      * Gets all idTokens matching the given filter
      * @param filter
      * @returns
      */
-    CacheManager.prototype.getIdTokensByFilter = function (filter, tokenKeys) {
-        var _this = this;
-        var idTokenKeys = tokenKeys && tokenKeys.idToken || this.getTokenKeys().idToken;
-        var idTokens = [];
-        idTokenKeys.forEach(function (key) {
-            if (!_this.idTokenKeyMatchesFilter(key, __assign({ clientId: _this.clientId }, filter))) {
+    getIdTokensByFilter(filter, tokenKeys) {
+        const idTokenKeys = (tokenKeys && tokenKeys.idToken) || this.getTokenKeys().idToken;
+        const idTokens = [];
+        idTokenKeys.forEach((key) => {
+            if (!this.idTokenKeyMatchesFilter(key, {
+                clientId: this.clientId,
+                ...filter,
+            })) {
                 return;
             }
-            var idToken = _this.getIdTokenCredential(key);
-            if (idToken && _this.credentialMatchesFilter(idToken, filter)) {
+            const idToken = this.getIdTokenCredential(key);
+            if (idToken && this.credentialMatchesFilter(idToken, filter)) {
                 idTokens.push(idToken);
             }
         });
         return idTokens;
-    };
+    }
     /**
      * Validate the cache key against filter before retrieving and parsing cache value
      * @param key
      * @param filter
      * @returns
      */
-    CacheManager.prototype.idTokenKeyMatchesFilter = function (inputKey, filter) {
-        var key = inputKey.toLowerCase();
-        if (filter.clientId && key.indexOf(filter.clientId.toLowerCase()) === -1) {
+    idTokenKeyMatchesFilter(inputKey, filter) {
+        const key = inputKey.toLowerCase();
+        if (filter.clientId &&
+            key.indexOf(filter.clientId.toLowerCase()) === -1) {
             return false;
         }
-        if (filter.homeAccountId && key.indexOf(filter.homeAccountId.toLowerCase()) === -1) {
+        if (filter.homeAccountId &&
+            key.indexOf(filter.homeAccountId.toLowerCase()) === -1) {
             return false;
         }
         return true;
-    };
+    }
     /**
      * Removes idToken from the cache
      * @param key
      */
-    CacheManager.prototype.removeIdToken = function (key) {
+    removeIdToken(key) {
         this.removeItem(key);
-    };
+    }
     /**
      * Removes refresh token from the cache
      * @param key
      */
-    CacheManager.prototype.removeRefreshToken = function (key) {
+    removeRefreshToken(key) {
         this.removeItem(key);
-    };
+    }
     /**
      * Retrieve AccessTokenEntity from cache
      * @param clientId
@@ -612,17 +565,20 @@ var CacheManager = /** @class */ (function () {
      * @param scopes
      * @param authScheme
      */
-    CacheManager.prototype.getAccessToken = function (account, request, tokenKeys) {
-        var _this = this;
+    getAccessToken(account, request, tokenKeys) {
         this.commonLogger.trace("CacheManager - getAccessToken called");
-        var scopes = ScopeSet.createSearchScopes(request.scopes);
-        var authScheme = request.authenticationScheme || AuthenticationScheme.BEARER;
+        const scopes = ScopeSet.createSearchScopes(request.scopes);
+        const authScheme = request.authenticationScheme || AuthenticationScheme.BEARER;
         /*
          * Distinguish between Bearer and PoP/SSH token cache types
          * Cast to lowercase to handle "bearer" from ADFS
          */
-        var credentialType = (authScheme && authScheme.toLowerCase() !== AuthenticationScheme.BEARER.toLowerCase()) ? CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME : CredentialType.ACCESS_TOKEN;
-        var accessTokenFilter = {
+        const credentialType = authScheme &&
+            authScheme.toLowerCase() !==
+                AuthenticationScheme.BEARER.toLowerCase()
+            ? CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME
+            : CredentialType.ACCESS_TOKEN;
+        const accessTokenFilter = {
             homeAccountId: account.homeAccountId,
             environment: account.environment,
             credentialType: credentialType,
@@ -633,19 +589,21 @@ var CacheManager = /** @class */ (function () {
             keyId: request.sshKid,
             requestedClaimsHash: request.requestedClaimsHash,
         };
-        var accessTokenKeys = tokenKeys && tokenKeys.accessToken || this.getTokenKeys().accessToken;
-        var accessTokens = [];
-        accessTokenKeys.forEach(function (key) {
+        const accessTokenKeys = (tokenKeys && tokenKeys.accessToken) ||
+            this.getTokenKeys().accessToken;
+        const accessTokens = [];
+        accessTokenKeys.forEach((key) => {
             // Validate key
-            if (_this.accessTokenKeyMatchesFilter(key, accessTokenFilter, true)) {
-                var accessToken = _this.getAccessTokenCredential(key);
+            if (this.accessTokenKeyMatchesFilter(key, accessTokenFilter, true)) {
+                const accessToken = this.getAccessTokenCredential(key);
                 // Validate value
-                if (accessToken && _this.credentialMatchesFilter(accessToken, accessTokenFilter)) {
+                if (accessToken &&
+                    this.credentialMatchesFilter(accessToken, accessTokenFilter)) {
                     accessTokens.push(accessToken);
                 }
             }
         });
-        var numAccessTokens = accessTokens.length;
+        const numAccessTokens = accessTokens.length;
         if (numAccessTokens < 1) {
             this.commonLogger.info("CacheManager:getAccessToken - No token found");
             return null;
@@ -655,7 +613,7 @@ var CacheManager = /** @class */ (function () {
         }
         this.commonLogger.info("CacheManager:getAccessToken - Returning access token");
         return accessTokens[0];
-    };
+    }
     /**
      * Validate the cache key against filter before retrieving and parsing cache value
      * @param key
@@ -663,85 +621,91 @@ var CacheManager = /** @class */ (function () {
      * @param keyMustContainAllScopes
      * @returns
      */
-    CacheManager.prototype.accessTokenKeyMatchesFilter = function (inputKey, filter, keyMustContainAllScopes) {
-        var key = inputKey.toLowerCase();
-        if (filter.clientId && key.indexOf(filter.clientId.toLowerCase()) === -1) {
+    accessTokenKeyMatchesFilter(inputKey, filter, keyMustContainAllScopes) {
+        const key = inputKey.toLowerCase();
+        if (filter.clientId &&
+            key.indexOf(filter.clientId.toLowerCase()) === -1) {
             return false;
         }
-        if (filter.homeAccountId && key.indexOf(filter.homeAccountId.toLowerCase()) === -1) {
+        if (filter.homeAccountId &&
+            key.indexOf(filter.homeAccountId.toLowerCase()) === -1) {
             return false;
         }
         if (filter.realm && key.indexOf(filter.realm.toLowerCase()) === -1) {
             return false;
         }
-        if (filter.requestedClaimsHash && key.indexOf(filter.requestedClaimsHash.toLowerCase()) === -1) {
+        if (filter.requestedClaimsHash &&
+            key.indexOf(filter.requestedClaimsHash.toLowerCase()) === -1) {
             return false;
         }
         if (filter.target) {
-            var scopes = filter.target.asArray();
-            for (var i = 0; i < scopes.length; i++) {
-                if (keyMustContainAllScopes && !key.includes(scopes[i].toLowerCase())) {
+            const scopes = filter.target.asArray();
+            for (let i = 0; i < scopes.length; i++) {
+                if (keyMustContainAllScopes &&
+                    !key.includes(scopes[i].toLowerCase())) {
                     // When performing a cache lookup a missing scope would be a cache miss
                     return false;
                 }
-                else if (!keyMustContainAllScopes && key.includes(scopes[i].toLowerCase())) {
+                else if (!keyMustContainAllScopes &&
+                    key.includes(scopes[i].toLowerCase())) {
                     // When performing a cache write, any token with a subset of requested scopes should be replaced
                     return true;
                 }
             }
         }
         return true;
-    };
+    }
     /**
      * Gets all access tokens matching the filter
      * @param filter
      * @returns
      */
-    CacheManager.prototype.getAccessTokensByFilter = function (filter) {
-        var _this = this;
-        var tokenKeys = this.getTokenKeys();
-        var accessTokens = [];
-        tokenKeys.accessToken.forEach(function (key) {
-            if (!_this.accessTokenKeyMatchesFilter(key, filter, true)) {
+    getAccessTokensByFilter(filter) {
+        const tokenKeys = this.getTokenKeys();
+        const accessTokens = [];
+        tokenKeys.accessToken.forEach((key) => {
+            if (!this.accessTokenKeyMatchesFilter(key, filter, true)) {
                 return;
             }
-            var accessToken = _this.getAccessTokenCredential(key);
-            if (accessToken && _this.credentialMatchesFilter(accessToken, filter)) {
+            const accessToken = this.getAccessTokenCredential(key);
+            if (accessToken &&
+                this.credentialMatchesFilter(accessToken, filter)) {
                 accessTokens.push(accessToken);
             }
         });
         return accessTokens;
-    };
+    }
     /**
      * Helper to retrieve the appropriate refresh token from cache
      * @param clientId
      * @param account
      * @param familyRT
      */
-    CacheManager.prototype.getRefreshToken = function (account, familyRT, tokenKeys) {
-        var _this = this;
+    getRefreshToken(account, familyRT, tokenKeys) {
         this.commonLogger.trace("CacheManager - getRefreshToken called");
-        var id = familyRT ? THE_FAMILY_ID : undefined;
-        var refreshTokenFilter = {
+        const id = familyRT ? THE_FAMILY_ID : undefined;
+        const refreshTokenFilter = {
             homeAccountId: account.homeAccountId,
             environment: account.environment,
             credentialType: CredentialType.REFRESH_TOKEN,
             clientId: this.clientId,
             familyId: id,
         };
-        var refreshTokenKeys = tokenKeys && tokenKeys.refreshToken || this.getTokenKeys().refreshToken;
-        var refreshTokens = [];
-        refreshTokenKeys.forEach(function (key) {
+        const refreshTokenKeys = (tokenKeys && tokenKeys.refreshToken) ||
+            this.getTokenKeys().refreshToken;
+        const refreshTokens = [];
+        refreshTokenKeys.forEach((key) => {
             // Validate key
-            if (_this.refreshTokenKeyMatchesFilter(key, refreshTokenFilter)) {
-                var refreshToken = _this.getRefreshTokenCredential(key);
+            if (this.refreshTokenKeyMatchesFilter(key, refreshTokenFilter)) {
+                const refreshToken = this.getRefreshTokenCredential(key);
                 // Validate value
-                if (refreshToken && _this.credentialMatchesFilter(refreshToken, refreshTokenFilter)) {
+                if (refreshToken &&
+                    this.credentialMatchesFilter(refreshToken, refreshTokenFilter)) {
                     refreshTokens.push(refreshToken);
                 }
             }
         });
-        var numRefreshTokens = refreshTokens.length;
+        const numRefreshTokens = refreshTokens.length;
         if (numRefreshTokens < 1) {
             this.commonLogger.info("CacheManager:getRefreshToken - No refresh token found.");
             return null;
@@ -749,37 +713,41 @@ var CacheManager = /** @class */ (function () {
         // address the else case after remove functions address environment aliases
         this.commonLogger.info("CacheManager:getRefreshToken - returning refresh token");
         return refreshTokens[0];
-    };
+    }
     /**
      * Validate the cache key against filter before retrieving and parsing cache value
      * @param key
      * @param filter
      */
-    CacheManager.prototype.refreshTokenKeyMatchesFilter = function (inputKey, filter) {
-        var key = inputKey.toLowerCase();
-        if (filter.familyId && key.indexOf(filter.familyId.toLowerCase()) === -1) {
+    refreshTokenKeyMatchesFilter(inputKey, filter) {
+        const key = inputKey.toLowerCase();
+        if (filter.familyId &&
+            key.indexOf(filter.familyId.toLowerCase()) === -1) {
             return false;
         }
         // If familyId is used, clientId is not in the key
-        if (!filter.familyId && filter.clientId && key.indexOf(filter.clientId.toLowerCase()) === -1) {
+        if (!filter.familyId &&
+            filter.clientId &&
+            key.indexOf(filter.clientId.toLowerCase()) === -1) {
             return false;
         }
-        if (filter.homeAccountId && key.indexOf(filter.homeAccountId.toLowerCase()) === -1) {
+        if (filter.homeAccountId &&
+            key.indexOf(filter.homeAccountId.toLowerCase()) === -1) {
             return false;
         }
         return true;
-    };
+    }
     /**
      * Retrieve AppMetadataEntity from cache
      */
-    CacheManager.prototype.readAppMetadataFromCache = function (environment) {
-        var appMetadataFilter = {
-            environment: environment,
+    readAppMetadataFromCache(environment) {
+        const appMetadataFilter = {
+            environment,
             clientId: this.clientId,
         };
-        var appMetadata = this.getAppMetadataFilteredBy(appMetadataFilter);
-        var appMetadataEntries = Object.keys(appMetadata).map(function (key) { return appMetadata[key]; });
-        var numAppMetadata = appMetadataEntries.length;
+        const appMetadata = this.getAppMetadataFilteredBy(appMetadataFilter);
+        const appMetadataEntries = Object.keys(appMetadata).map((key) => appMetadata[key]);
+        const numAppMetadata = appMetadataEntries.length;
         if (numAppMetadata < 1) {
             return null;
         }
@@ -787,273 +755,270 @@ var CacheManager = /** @class */ (function () {
             throw ClientAuthError.createMultipleMatchingAppMetadataInCacheError();
         }
         return appMetadataEntries[0];
-    };
+    }
     /**
      * Return the family_id value associated  with FOCI
      * @param environment
      * @param clientId
      */
-    CacheManager.prototype.isAppMetadataFOCI = function (environment) {
-        var appMetadata = this.readAppMetadataFromCache(environment);
+    isAppMetadataFOCI(environment) {
+        const appMetadata = this.readAppMetadataFromCache(environment);
         return !!(appMetadata && appMetadata.familyId === THE_FAMILY_ID);
-    };
+    }
     /**
      * helper to match account ids
      * @param value
      * @param homeAccountId
      */
-    CacheManager.prototype.matchHomeAccountId = function (entity, homeAccountId) {
-        return !!((typeof entity.homeAccountId === "string") && (homeAccountId === entity.homeAccountId));
-    };
+    matchHomeAccountId(entity, homeAccountId) {
+        return !!(typeof entity.homeAccountId === "string" &&
+            homeAccountId === entity.homeAccountId);
+    }
     /**
      * helper to match account ids
      * @param entity
      * @param localAccountId
      * @returns
      */
-    CacheManager.prototype.matchLocalAccountId = function (entity, localAccountId) {
-        return !!((typeof entity.localAccountId === "string") && (localAccountId === entity.localAccountId));
-    };
+    matchLocalAccountId(entity, localAccountId) {
+        return !!(typeof entity.localAccountId === "string" &&
+            localAccountId === entity.localAccountId);
+    }
     /**
      * helper to match usernames
      * @param entity
      * @param username
      * @returns
      */
-    CacheManager.prototype.matchUsername = function (entity, username) {
-        return !!((typeof entity.username === "string") && (username.toLowerCase() === entity.username.toLowerCase()));
-    };
+    matchUsername(entity, username) {
+        return !!(typeof entity.username === "string" &&
+            username.toLowerCase() === entity.username.toLowerCase());
+    }
     /**
      * helper to match assertion
      * @param value
      * @param oboAssertion
      */
-    CacheManager.prototype.matchUserAssertionHash = function (entity, userAssertionHash) {
-        return !!(entity.userAssertionHash && userAssertionHash === entity.userAssertionHash);
-    };
+    matchUserAssertionHash(entity, userAssertionHash) {
+        return !!(entity.userAssertionHash &&
+            userAssertionHash === entity.userAssertionHash);
+    }
     /**
      * helper to match environment
      * @param value
      * @param environment
      */
-    CacheManager.prototype.matchEnvironment = function (entity, environment) {
-        var cloudMetadata = this.getAuthorityMetadataByAlias(environment);
-        if (cloudMetadata && cloudMetadata.aliases.indexOf(entity.environment) > -1) {
+    matchEnvironment(entity, environment) {
+        const cloudMetadata = this.getAuthorityMetadataByAlias(environment);
+        if (cloudMetadata &&
+            cloudMetadata.aliases.indexOf(entity.environment) > -1) {
             return true;
         }
         return false;
-    };
+    }
     /**
      * helper to match credential type
      * @param entity
      * @param credentialType
      */
-    CacheManager.prototype.matchCredentialType = function (entity, credentialType) {
-        return (entity.credentialType && credentialType.toLowerCase() === entity.credentialType.toLowerCase());
-    };
+    matchCredentialType(entity, credentialType) {
+        return (entity.credentialType &&
+            credentialType.toLowerCase() === entity.credentialType.toLowerCase());
+    }
     /**
      * helper to match client ids
      * @param entity
      * @param clientId
      */
-    CacheManager.prototype.matchClientId = function (entity, clientId) {
+    matchClientId(entity, clientId) {
         return !!(entity.clientId && clientId === entity.clientId);
-    };
+    }
     /**
      * helper to match family ids
      * @param entity
      * @param familyId
      */
-    CacheManager.prototype.matchFamilyId = function (entity, familyId) {
+    matchFamilyId(entity, familyId) {
         return !!(entity.familyId && familyId === entity.familyId);
-    };
+    }
     /**
      * helper to match realm
      * @param entity
      * @param realm
      */
-    CacheManager.prototype.matchRealm = function (entity, realm) {
+    matchRealm(entity, realm) {
         return !!(entity.realm && realm === entity.realm);
-    };
+    }
     /**
      * helper to match nativeAccountId
      * @param entity
      * @param nativeAccountId
      * @returns boolean indicating the match result
      */
-    CacheManager.prototype.matchNativeAccountId = function (entity, nativeAccountId) {
+    matchNativeAccountId(entity, nativeAccountId) {
         return !!(entity.nativeAccountId && nativeAccountId === entity.nativeAccountId);
-    };
+    }
     /**
      * Returns true if the target scopes are a subset of the current entity's scopes, false otherwise.
      * @param entity
      * @param target
      */
-    CacheManager.prototype.matchTarget = function (entity, target) {
-        var isNotAccessTokenCredential = (entity.credentialType !== CredentialType.ACCESS_TOKEN && entity.credentialType !== CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME);
+    matchTarget(entity, target) {
+        const isNotAccessTokenCredential = entity.credentialType !== CredentialType.ACCESS_TOKEN &&
+            entity.credentialType !==
+                CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME;
         if (isNotAccessTokenCredential || !entity.target) {
             return false;
         }
-        var entityScopeSet = ScopeSet.fromString(entity.target);
+        const entityScopeSet = ScopeSet.fromString(entity.target);
         return entityScopeSet.containsScopeSet(target);
-    };
+    }
     /**
      * Returns true if the credential's tokenType or Authentication Scheme matches the one in the request, false otherwise
      * @param entity
      * @param tokenType
      */
-    CacheManager.prototype.matchTokenType = function (entity, tokenType) {
+    matchTokenType(entity, tokenType) {
         return !!(entity.tokenType && entity.tokenType === tokenType);
-    };
+    }
     /**
      * Returns true if the credential's keyId matches the one in the request, false otherwise
      * @param entity
      * @param tokenType
      */
-    CacheManager.prototype.matchKeyId = function (entity, keyId) {
+    matchKeyId(entity, keyId) {
         return !!(entity.keyId && entity.keyId === keyId);
-    };
+    }
     /**
      * returns if a given cache entity is of the type appmetadata
      * @param key
      */
-    CacheManager.prototype.isAppMetadata = function (key) {
+    isAppMetadata(key) {
         return key.indexOf(APP_METADATA) !== -1;
-    };
+    }
     /**
      * returns if a given cache entity is of the type authoritymetadata
      * @param key
      */
-    CacheManager.prototype.isAuthorityMetadata = function (key) {
+    isAuthorityMetadata(key) {
         return key.indexOf(AUTHORITY_METADATA_CONSTANTS.CACHE_KEY) !== -1;
-    };
+    }
     /**
      * returns cache key used for cloud instance metadata
      */
-    CacheManager.prototype.generateAuthorityMetadataCacheKey = function (authority) {
-        return AUTHORITY_METADATA_CONSTANTS.CACHE_KEY + "-" + this.clientId + "-" + authority;
-    };
+    generateAuthorityMetadataCacheKey(authority) {
+        return `${AUTHORITY_METADATA_CONSTANTS.CACHE_KEY}-${this.clientId}-${authority}`;
+    }
     /**
      * Helper to convert serialized data to object
      * @param obj
      * @param json
      */
-    CacheManager.toObject = function (obj, json) {
-        for (var propertyName in json) {
+    static toObject(obj, json) {
+        for (const propertyName in json) {
             obj[propertyName] = json[propertyName];
         }
         return obj;
-    };
-    return CacheManager;
-}());
-var DefaultStorageClass = /** @class */ (function (_super) {
-    __extends(DefaultStorageClass, _super);
-    function DefaultStorageClass() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    DefaultStorageClass.prototype.setAccount = function () {
-        var notImplErr = "Storage interface - setAccount() has not been implemented for the cacheStorage interface.";
+    }
+}
+class DefaultStorageClass extends CacheManager {
+    setAccount() {
+        const notImplErr = "Storage interface - setAccount() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getAccount = function () {
-        var notImplErr = "Storage interface - getAccount() has not been implemented for the cacheStorage interface.";
+    }
+    getAccount() {
+        const notImplErr = "Storage interface - getAccount() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.setIdTokenCredential = function () {
-        var notImplErr = "Storage interface - setIdTokenCredential() has not been implemented for the cacheStorage interface.";
+    }
+    setIdTokenCredential() {
+        const notImplErr = "Storage interface - setIdTokenCredential() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getIdTokenCredential = function () {
-        var notImplErr = "Storage interface - getIdTokenCredential() has not been implemented for the cacheStorage interface.";
+    }
+    getIdTokenCredential() {
+        const notImplErr = "Storage interface - getIdTokenCredential() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.setAccessTokenCredential = function () {
-        var notImplErr = "Storage interface - setAccessTokenCredential() has not been implemented for the cacheStorage interface.";
+    }
+    setAccessTokenCredential() {
+        const notImplErr = "Storage interface - setAccessTokenCredential() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getAccessTokenCredential = function () {
-        var notImplErr = "Storage interface - getAccessTokenCredential() has not been implemented for the cacheStorage interface.";
+    }
+    getAccessTokenCredential() {
+        const notImplErr = "Storage interface - getAccessTokenCredential() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.setRefreshTokenCredential = function () {
-        var notImplErr = "Storage interface - setRefreshTokenCredential() has not been implemented for the cacheStorage interface.";
+    }
+    setRefreshTokenCredential() {
+        const notImplErr = "Storage interface - setRefreshTokenCredential() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getRefreshTokenCredential = function () {
-        var notImplErr = "Storage interface - getRefreshTokenCredential() has not been implemented for the cacheStorage interface.";
+    }
+    getRefreshTokenCredential() {
+        const notImplErr = "Storage interface - getRefreshTokenCredential() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.setAppMetadata = function () {
-        var notImplErr = "Storage interface - setAppMetadata() has not been implemented for the cacheStorage interface.";
+    }
+    setAppMetadata() {
+        const notImplErr = "Storage interface - setAppMetadata() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getAppMetadata = function () {
-        var notImplErr = "Storage interface - getAppMetadata() has not been implemented for the cacheStorage interface.";
+    }
+    getAppMetadata() {
+        const notImplErr = "Storage interface - getAppMetadata() has not been implemented for the cacheStorage interface.";
+        throw AuthError.createUnexpectedError(notImplErr);
+    }
+    setServerTelemetry() {
+        const notImplErr = "Storage interface - setServerTelemetry() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.setServerTelemetry = function () {
-        var notImplErr = "Storage interface - setServerTelemetry() has not been implemented for the cacheStorage interface.";
+    }
+    getServerTelemetry() {
+        const notImplErr = "Storage interface - getServerTelemetry() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getServerTelemetry = function () {
-        var notImplErr = "Storage interface - getServerTelemetry() has not been implemented for the cacheStorage interface.";
+    }
+    setAuthorityMetadata() {
+        const notImplErr = "Storage interface - setAuthorityMetadata() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.setAuthorityMetadata = function () {
-        var notImplErr = "Storage interface - setAuthorityMetadata() has not been implemented for the cacheStorage interface.";
+    }
+    getAuthorityMetadata() {
+        const notImplErr = "Storage interface - getAuthorityMetadata() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getAuthorityMetadata = function () {
-        var notImplErr = "Storage interface - getAuthorityMetadata() has not been implemented for the cacheStorage interface.";
+    }
+    getAuthorityMetadataKeys() {
+        const notImplErr = "Storage interface - getAuthorityMetadataKeys() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getAuthorityMetadataKeys = function () {
-        var notImplErr = "Storage interface - getAuthorityMetadataKeys() has not been implemented for the cacheStorage interface.";
+    }
+    setThrottlingCache() {
+        const notImplErr = "Storage interface - setThrottlingCache() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.setThrottlingCache = function () {
-        var notImplErr = "Storage interface - setThrottlingCache() has not been implemented for the cacheStorage interface.";
+    }
+    getThrottlingCache() {
+        const notImplErr = "Storage interface - getThrottlingCache() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getThrottlingCache = function () {
-        var notImplErr = "Storage interface - getThrottlingCache() has not been implemented for the cacheStorage interface.";
+    }
+    removeItem() {
+        const notImplErr = "Storage interface - removeItem() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.removeItem = function () {
-        var notImplErr = "Storage interface - removeItem() has not been implemented for the cacheStorage interface.";
+    }
+    containsKey() {
+        const notImplErr = "Storage interface - containsKey() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.containsKey = function () {
-        var notImplErr = "Storage interface - containsKey() has not been implemented for the cacheStorage interface.";
+    }
+    getKeys() {
+        const notImplErr = "Storage interface - getKeys() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getKeys = function () {
-        var notImplErr = "Storage interface - getKeys() has not been implemented for the cacheStorage interface.";
+    }
+    getAccountKeys() {
+        const notImplErr = "Storage interface - getAccountKeys() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getAccountKeys = function () {
-        var notImplErr = "Storage interface - getAccountKeys() has not been implemented for the cacheStorage interface.";
+    }
+    getTokenKeys() {
+        const notImplErr = "Storage interface - getTokenKeys() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getTokenKeys = function () {
-        var notImplErr = "Storage interface - getTokenKeys() has not been implemented for the cacheStorage interface.";
+    }
+    async clear() {
+        const notImplErr = "Storage interface - clear() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.clear = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var notImplErr;
-            return __generator(this, function (_a) {
-                notImplErr = "Storage interface - clear() has not been implemented for the cacheStorage interface.";
-                throw AuthError.createUnexpectedError(notImplErr);
-            });
-        });
-    };
-    DefaultStorageClass.prototype.updateCredentialCacheKey = function () {
-        var notImplErr = "Storage interface - updateCredentialCacheKey() has not been implemented for the cacheStorage interface.";
+    }
+    updateCredentialCacheKey() {
+        const notImplErr = "Storage interface - updateCredentialCacheKey() has not been implemented for the cacheStorage interface.";
         throw AuthError.createUnexpectedError(notImplErr);
-    };
-    return DefaultStorageClass;
-}(CacheManager));
+    }
+}
 
 export { CacheManager, DefaultStorageClass };
 //# sourceMappingURL=CacheManager.js.map