tntd 1.4.31 → 1.4.32

package/common/temp/rush-recycler/install-run-1678274025679/@azure/msal-common/dist/cache/CacheManager.js

@@ -1,890 +0,0 @@
-/*! @azure/msal-common v7.6.0 2022-10-10 */
-'use strict';
-import { __awaiter, __generator, __extends } from '../_virtual/_tslib.js';
-import { Constants, CredentialType, AuthenticationScheme, CacheSchemaType, THE_FAMILY_ID, APP_METADATA, AUTHORITY_METADATA_CONSTANTS } from '../utils/Constants.js';
-import { CredentialEntity } from './entities/CredentialEntity.js';
-import { ScopeSet } from '../request/ScopeSet.js';
-import { AccountEntity } from './entities/AccountEntity.js';
-import { AuthError } from '../error/AuthError.js';
-import { ClientAuthError } from '../error/ClientAuthError.js';
-import { AuthToken } from '../account/AuthToken.js';
-
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * 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) {
-        this.clientId = clientId;
-        this.cryptoImpl = cryptoImpl;
-    }
-    /**
-     * Returns all accounts in cache
-     */
-    CacheManager.prototype.getAllAccounts = function () {
-        var _this = this;
-        var currentAccounts = this.getAccountsFilteredBy();
-        var accountValues = Object.keys(currentAccounts).map(function (accountKey) { return currentAccounts[accountKey]; });
-        var numAccounts = accountValues.length;
-        if (numAccounts < 1) {
-            return [];
-        }
-        else {
-            var allAccounts = accountValues.map(function (value) {
-                var accountEntity = CacheManager.toObject(new AccountEntity(), value);
-                var accountInfo = accountEntity.getAccountInfo();
-                var idToken = _this.readIdTokenFromCache(_this.clientId, accountInfo);
-                if (idToken && !accountInfo.idTokenClaims) {
-                    accountInfo.idToken = idToken.secret;
-                    accountInfo.idTokenClaims = new AuthToken(idToken.secret, _this.cryptoImpl).claims;
-                }
-                return accountInfo;
-            });
-            return allAccounts;
-        }
-    };
-    /**
-     * 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*/];
-                }
-            });
-        });
-    };
-    /**
-     * saves access token credential
-     * @param credential
-     */
-    CacheManager.prototype.saveAccessToken = function (credential) {
-        return __awaiter(this, void 0, void 0, function () {
-            var currentTokenCache, currentScopes, currentAccessTokens, removedAccessTokens_1;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        currentTokenCache = this.getCredentialsFilteredBy({
-                            clientId: credential.clientId,
-                            credentialType: credential.credentialType,
-                            environment: credential.environment,
-                            homeAccountId: credential.homeAccountId,
-                            realm: credential.realm,
-                            tokenType: credential.tokenType,
-                            requestedClaimsHash: credential.requestedClaimsHash
-                        });
-                        currentScopes = ScopeSet.fromString(credential.target);
-                        currentAccessTokens = Object.keys(currentTokenCache.accessTokens).map(function (key) { return currentTokenCache.accessTokens[key]; });
-                        if (!currentAccessTokens) return [3 /*break*/, 2];
-                        removedAccessTokens_1 = [];
-                        currentAccessTokens.forEach(function (tokenEntity) {
-                            var tokenScopeSet = ScopeSet.fromString(tokenEntity.target);
-                            if (tokenScopeSet.intersectingScopeSets(currentScopes)) {
-                                removedAccessTokens_1.push(_this.removeCredential(tokenEntity));
-                            }
-                        });
-                        return [4 /*yield*/, Promise.all(removedAccessTokens_1)];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        this.setAccessTokenCredential(credential);
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * 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
-     * @param homeAccountId
-     * @param environment
-     * @param realm
-     */
-    CacheManager.prototype.getAccountsFilteredBy = function (accountFilter) {
-        return this.getAccountsFilteredByInternal(accountFilter ? accountFilter.homeAccountId : Constants.EMPTY_STRING, accountFilter ? accountFilter.environment : Constants.EMPTY_STRING, accountFilter ? accountFilter.realm : Constants.EMPTY_STRING, accountFilter ? accountFilter.nativeAccountId : Constants.EMPTY_STRING);
-    };
-    /**
-     * 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
-     * @param homeAccountId
-     * @param environment
-     * @param realm
-     */
-    CacheManager.prototype.getAccountsFilteredByInternal = function (homeAccountId, environment, realm, nativeAccountId) {
-        var _this = this;
-        var allCacheKeys = this.getKeys();
-        var matchingAccounts = {};
-        allCacheKeys.forEach(function (cacheKey) {
-            var entity = _this.getAccount(cacheKey);
-            if (!entity) {
-                return;
-            }
-            if (!!homeAccountId && !_this.matchHomeAccountId(entity, homeAccountId)) {
-                return;
-            }
-            if (!!environment && !_this.matchEnvironment(entity, environment)) {
-                return;
-            }
-            if (!!realm && !_this.matchRealm(entity, realm)) {
-                return;
-            }
-            if (!!nativeAccountId && !_this.matchNativeAccountId(entity, nativeAccountId)) {
-                return;
-            }
-            matchingAccounts[cacheKey] = entity;
-        });
-        return matchingAccounts;
-    };
-    /**
-     * retrieve credentails matching all provided filters; if no filter is set, get all credentials
-     * @param homeAccountId
-     * @param environment
-     * @param credentialType
-     * @param clientId
-     * @param realm
-     * @param target
-     */
-    CacheManager.prototype.getCredentialsFilteredBy = function (filter) {
-        return this.getCredentialsFilteredByInternal(filter.homeAccountId, filter.environment, filter.credentialType, filter.clientId, filter.familyId, filter.realm, filter.target, filter.userAssertionHash, filter.tokenType, filter.keyId, filter.requestedClaimsHash);
-    };
-    /**
-     * Support function to help match credentials
-     * @param homeAccountId
-     * @param environment
-     * @param credentialType
-     * @param clientId
-     * @param realm
-     * @param target
-     * @param userAssertionHash
-     * @param tokenType
-     */
-    CacheManager.prototype.getCredentialsFilteredByInternal = function (homeAccountId, environment, credentialType, clientId, familyId, realm, target, userAssertionHash, tokenType, keyId, requestedClaimsHash) {
-        var _this = this;
-        var allCacheKeys = this.getKeys();
-        var matchingCredentials = {
-            idTokens: {},
-            accessTokens: {},
-            refreshTokens: {},
-        };
-        allCacheKeys.forEach(function (cacheKey) {
-            // don't parse any non-credential type cache entities
-            var credType = CredentialEntity.getCredentialType(cacheKey);
-            if (credType === Constants.NOT_DEFINED) {
-                return;
-            }
-            // Attempt retrieval
-            var entity = _this.getSpecificCredential(cacheKey, credType);
-            if (!entity) {
-                return;
-            }
-            if (!!userAssertionHash && !_this.matchUserAssertionHash(entity, userAssertionHash)) {
-                return;
-            }
-            /*
-             * homeAccountId can 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 homeAccountId === "string") && !_this.matchHomeAccountId(entity, homeAccountId)) {
-                return;
-            }
-            if (!!environment && !_this.matchEnvironment(entity, environment)) {
-                return;
-            }
-            if (!!realm && !_this.matchRealm(entity, realm)) {
-                return;
-            }
-            if (!!credentialType && !_this.matchCredentialType(entity, credentialType)) {
-                return;
-            }
-            if (!!clientId && !_this.matchClientId(entity, clientId)) {
-                return;
-            }
-            if (!!familyId && !_this.matchFamilyId(entity, familyId)) {
-                return;
-            }
-            /*
-             * idTokens do not have "target", target specific refreshTokens do exist for some types of authentication
-             * Resource specific refresh tokens case will be added when the support is deemed necessary
-             */
-            if (!!target && !_this.matchTarget(entity, target)) {
-                return;
-            }
-            // If request OR cached entity has requested Claims Hash, check if they match
-            if (requestedClaimsHash || entity.requestedClaimsHash) {
-                // Don't match if either is undefined or they are different
-                if (entity.requestedClaimsHash !== requestedClaimsHash) {
-                    return;
-                }
-            }
-            // Access Token with Auth Scheme specific matching
-            if (credentialType === CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME) {
-                if (!!tokenType && !_this.matchTokenType(entity, tokenType)) {
-                    return;
-                }
-                // KeyId (sshKid) in request must match cached SSH certificate keyId because SSH cert is bound to a specific key
-                if (tokenType === AuthenticationScheme.SSH) {
-                    if (keyId && !_this.matchKeyId(entity, keyId)) {
-                        return;
-                    }
-                }
-            }
-            // At this point, the entity matches the request, update cache key if key schema has changed
-            var updatedCacheKey = _this.updateCredentialCacheKey(cacheKey, entity);
-            switch (credType) {
-                case CredentialType.ID_TOKEN:
-                    matchingCredentials.idTokens[updatedCacheKey] = entity;
-                    break;
-                case CredentialType.ACCESS_TOKEN:
-                case CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME:
-                    matchingCredentials.accessTokens[updatedCacheKey] = entity;
-                    break;
-                case CredentialType.REFRESH_TOKEN:
-                    matchingCredentials.refreshTokens[updatedCacheKey] = entity;
-                    break;
-            }
-        });
-        return matchingCredentials;
-    };
-    /**
-     * retrieve appMetadata matching all provided filters; if no filter is set, get all appMetadata
-     * @param filter
-     */
-    CacheManager.prototype.getAppMetadataFilteredBy = function (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) {
-            // don't parse any non-appMetadata type cache entities
-            if (!_this.isAppMetadata(cacheKey)) {
-                return;
-            }
-            // Attempt retrieval
-            var entity = _this.getAppMetadata(cacheKey);
-            if (!entity) {
-                return;
-            }
-            if (!!environment && !_this.matchEnvironment(entity, environment)) {
-                return;
-            }
-            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) {
-            // don't parse any non-authorityMetadata type cache entities
-            if (!_this.isAuthorityMetadata(cacheKey) || cacheKey.indexOf(_this.clientId) === -1) {
-                return;
-            }
-            // Attempt retrieval
-            var entity = _this.getAuthorityMetadata(cacheKey);
-            if (!entity) {
-                return;
-            }
-            if (entity.aliases.indexOf(host) === -1) {
-                return;
-            }
-            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 allCacheKeys, removedAccounts;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        allCacheKeys = this.getKeys();
-                        removedAccounts = [];
-                        allCacheKeys.forEach(function (cacheKey) {
-                            var entity = _this.getAccount(cacheKey);
-                            if (!entity) {
-                                return;
-                            }
-                            removedAccounts.push(_this.removeAccount(cacheKey));
-                        });
-                        return [4 /*yield*/, Promise.all(removedAccounts)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, true];
-                }
-            });
-        });
-    };
-    /**
-     * returns a boolean if the given account is removed
-     * @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: return [2 /*return*/, ((_a.sent()) && this.removeItem(accountKey, CacheSchemaType.ACCOUNT))];
-                }
-            });
-        });
-    };
-    /**
-     * Removes credentials associated with the provided account
-     * @param account
-     */
-    CacheManager.prototype.removeAccountContext = function (account) {
-        return __awaiter(this, void 0, void 0, function () {
-            var allCacheKeys, accountId, removedCredentials;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        allCacheKeys = this.getKeys();
-                        accountId = account.generateAccountId();
-                        removedCredentials = [];
-                        allCacheKeys.forEach(function (cacheKey) {
-                            // don't parse any non-credential type cache entities
-                            var credType = CredentialEntity.getCredentialType(cacheKey);
-                            if (credType === Constants.NOT_DEFINED) {
-                                return;
-                            }
-                            var cacheEntity = _this.getSpecificCredential(cacheKey, credType);
-                            if (!!cacheEntity && accountId === cacheEntity.generateAccountId()) {
-                                removedCredentials.push(_this.removeCredential(cacheEntity));
-                            }
-                        });
-                        return [4 /*yield*/, Promise.all(removedCredentials)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, true];
-                }
-            });
-        });
-    };
-    /**
-     * returns a boolean if the given credential is removed
-     * @param credential
-     */
-    CacheManager.prototype.removeCredential = function (credential) {
-        return __awaiter(this, void 0, void 0, function () {
-            var key, accessTokenWithAuthSchemeEntity, kid;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        key = credential.generateCredentialKey();
-                        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();
-                        throw ClientAuthError.createBindingKeyNotRemovedError();
-                    case 4: return [2 /*return*/, this.removeItem(key, CacheSchemaType.CREDENTIAL)];
-                }
-            });
-        });
-    };
-    /**
-     * 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, CacheSchemaType.APP_METADATA);
-            }
-        });
-        return true;
-    };
-    /**
-     * Retrieve the cached credentials into a cacherecord
-     * @param account
-     * @param clientId
-     * @param scopes
-     * @param environment
-     * @param authScheme
-     */
-    CacheManager.prototype.readCacheRecord = function (account, clientId, request, environment) {
-        var cachedAccount = this.readAccountFromCache(account);
-        var cachedIdToken = this.readIdTokenFromCache(clientId, account);
-        var cachedAccessToken = this.readAccessTokenFromCache(clientId, account, request);
-        var cachedRefreshToken = this.readRefreshTokenFromCache(clientId, account, false);
-        var cachedAppMetadata = this.readAppMetadataFromCache(environment, clientId);
-        if (cachedAccount && cachedIdToken) {
-            cachedAccount.idTokenClaims = new AuthToken(cachedIdToken.secret, this.cryptoImpl).claims;
-        }
-        return {
-            account: cachedAccount,
-            idToken: cachedIdToken,
-            accessToken: cachedAccessToken,
-            refreshToken: cachedRefreshToken,
-            appMetadata: cachedAppMetadata,
-        };
-    };
-    /**
-     * Retrieve AccountEntity from cache
-     * @param account
-     */
-    CacheManager.prototype.readAccountFromCache = function (account) {
-        var accountKey = AccountEntity.generateAccountCacheKey(account);
-        return this.getAccount(accountKey);
-    };
-    /**
-     * Retrieve AccountEntity from cache
-     * @param nativeAccountId
-     * @returns AccountEntity or Null
-     */
-    CacheManager.prototype.readAccountFromCacheWithNativeAccountId = function (nativeAccountId) {
-        // fetch account from memory
-        var accountFilter = {
-            nativeAccountId: nativeAccountId
-        };
-        var accountCache = this.getAccountsFilteredBy(accountFilter);
-        var accounts = Object.keys(accountCache).map(function (key) { return accountCache[key]; });
-        if (accounts.length < 1) {
-            return null;
-        }
-        else if (accounts.length > 1) {
-            throw ClientAuthError.createMultipleMatchingAccountsInCacheError();
-        }
-        return accountCache[0];
-    };
-    /**
-     * Retrieve IdTokenEntity from cache
-     * @param clientId
-     * @param account
-     * @param inputRealm
-     */
-    CacheManager.prototype.readIdTokenFromCache = function (clientId, account) {
-        var idTokenFilter = {
-            homeAccountId: account.homeAccountId,
-            environment: account.environment,
-            credentialType: CredentialType.ID_TOKEN,
-            clientId: clientId,
-            realm: account.tenantId,
-        };
-        var credentialCache = this.getCredentialsFilteredBy(idTokenFilter);
-        var idTokens = Object.keys(credentialCache.idTokens).map(function (key) { return credentialCache.idTokens[key]; });
-        var numIdTokens = idTokens.length;
-        if (numIdTokens < 1) {
-            return null;
-        }
-        else if (numIdTokens > 1) {
-            throw ClientAuthError.createMultipleMatchingTokensInCacheError();
-        }
-        return idTokens[0];
-    };
-    /**
-     * Retrieve AccessTokenEntity from cache
-     * @param clientId
-     * @param account
-     * @param scopes
-     * @param authScheme
-     */
-    CacheManager.prototype.readAccessTokenFromCache = function (clientId, account, request) {
-        var scopes = new ScopeSet(request.scopes || []);
-        var 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 = {
-            homeAccountId: account.homeAccountId,
-            environment: account.environment,
-            credentialType: credentialType,
-            clientId: clientId,
-            realm: account.tenantId,
-            target: scopes.printScopesLowerCase(),
-            tokenType: authScheme,
-            keyId: request.sshKid,
-            requestedClaimsHash: request.requestedClaimsHash,
-        };
-        var credentialCache = this.getCredentialsFilteredBy(accessTokenFilter);
-        var accessTokens = Object.keys(credentialCache.accessTokens).map(function (key) { return credentialCache.accessTokens[key]; });
-        var numAccessTokens = accessTokens.length;
-        if (numAccessTokens < 1) {
-            return null;
-        }
-        else if (numAccessTokens > 1) {
-            throw ClientAuthError.createMultipleMatchingTokensInCacheError();
-        }
-        return accessTokens[0];
-    };
-    /**
-     * Helper to retrieve the appropriate refresh token from cache
-     * @param clientId
-     * @param account
-     * @param familyRT
-     */
-    CacheManager.prototype.readRefreshTokenFromCache = function (clientId, account, familyRT) {
-        var id = familyRT ? THE_FAMILY_ID : undefined;
-        var refreshTokenFilter = {
-            homeAccountId: account.homeAccountId,
-            environment: account.environment,
-            credentialType: CredentialType.REFRESH_TOKEN,
-            clientId: clientId,
-            familyId: id,
-        };
-        var credentialCache = this.getCredentialsFilteredBy(refreshTokenFilter);
-        var refreshTokens = Object.keys(credentialCache.refreshTokens).map(function (key) { return credentialCache.refreshTokens[key]; });
-        var numRefreshTokens = refreshTokens.length;
-        if (numRefreshTokens < 1) {
-            return null;
-        }
-        // address the else case after remove functions address environment aliases
-        return refreshTokens[0];
-    };
-    /**
-     * Retrieve AppMetadataEntity from cache
-     */
-    CacheManager.prototype.readAppMetadataFromCache = function (environment, clientId) {
-        var appMetadataFilter = {
-            environment: environment,
-            clientId: clientId,
-        };
-        var appMetadata = this.getAppMetadataFilteredBy(appMetadataFilter);
-        var appMetadataEntries = Object.keys(appMetadata).map(function (key) { return appMetadata[key]; });
-        var numAppMetadata = appMetadataEntries.length;
-        if (numAppMetadata < 1) {
-            return null;
-        }
-        else if (numAppMetadata > 1) {
-            throw ClientAuthError.createMultipleMatchingAppMetadataInCacheError();
-        }
-        return appMetadataEntries[0];
-    };
-    /**
-     * Return the family_id value associated  with FOCI
-     * @param environment
-     * @param clientId
-     */
-    CacheManager.prototype.isAppMetadataFOCI = function (environment, clientId) {
-        var appMetadata = this.readAppMetadataFromCache(environment, clientId);
-        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));
-    };
-    /**
-     * helper to match assertion
-     * @param value
-     * @param oboAssertion
-     */
-    CacheManager.prototype.matchUserAssertionHash = function (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) {
-            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());
-    };
-    /**
-     * helper to match client ids
-     * @param entity
-     * @param clientId
-     */
-    CacheManager.prototype.matchClientId = function (entity, clientId) {
-        return !!(entity.clientId && clientId === entity.clientId);
-    };
-    /**
-     * helper to match family ids
-     * @param entity
-     * @param familyId
-     */
-    CacheManager.prototype.matchFamilyId = function (entity, familyId) {
-        return !!(entity.familyId && familyId === entity.familyId);
-    };
-    /**
-     * helper to match realm
-     * @param entity
-     * @param realm
-     */
-    CacheManager.prototype.matchRealm = function (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) {
-        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);
-        if (isNotAccessTokenCredential || !entity.target) {
-            return false;
-        }
-        var entityScopeSet = ScopeSet.fromString(entity.target);
-        var requestTargetScopeSet = ScopeSet.fromString(target);
-        if (!requestTargetScopeSet.containsOnlyOIDCScopes()) {
-            requestTargetScopeSet.removeOIDCScopes(); // ignore OIDC scopes
-        }
-        else {
-            requestTargetScopeSet.removeScope(Constants.OFFLINE_ACCESS_SCOPE);
-        }
-        return entityScopeSet.containsScopeSet(requestTargetScopeSet);
-    };
-    /**
-     * 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) {
-        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) {
-        return !!(entity.keyId && entity.keyId === keyId);
-    };
-    /**
-     * returns if a given cache entity is of the type appmetadata
-     * @param key
-     */
-    CacheManager.prototype.isAppMetadata = function (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) {
-        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;
-    };
-    /**
-     * Returns the specific credential (IdToken/AccessToken/RefreshToken) from the cache
-     * @param key
-     * @param credType
-     */
-    CacheManager.prototype.getSpecificCredential = function (key, credType) {
-        switch (credType) {
-            case CredentialType.ID_TOKEN: {
-                return this.getIdTokenCredential(key);
-            }
-            case CredentialType.ACCESS_TOKEN:
-            case CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME: {
-                return this.getAccessTokenCredential(key);
-            }
-            case CredentialType.REFRESH_TOKEN: {
-                return this.getRefreshTokenCredential(key);
-            }
-            default:
-                return null;
-        }
-    };
-    /**
-     * Helper to convert serialized data to object
-     * @param obj
-     * @param json
-     */
-    CacheManager.toObject = function (obj, json) {
-        for (var 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.";
-        throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getAccount = function () {
-        var 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.";
-        throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getIdTokenCredential = function () {
-        var 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.";
-        throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getAccessTokenCredential = function () {
-        var 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.";
-        throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getRefreshTokenCredential = function () {
-        var 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.";
-        throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getAppMetadata = function () {
-        var notImplErr = "Storage interface - getAppMetadata() 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.";
-        throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getServerTelemetry = function () {
-        var notImplErr = "Storage interface - getServerTelemetry() 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.";
-        throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getAuthorityMetadata = function () {
-        var notImplErr = "Storage interface - getAuthorityMetadata() 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.";
-        throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.setThrottlingCache = function () {
-        var notImplErr = "Storage interface - setThrottlingCache() 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.";
-        throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.removeItem = function () {
-        var notImplErr = "Storage interface - removeItem() 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.";
-        throw AuthError.createUnexpectedError(notImplErr);
-    };
-    DefaultStorageClass.prototype.getKeys = function () {
-        var notImplErr = "Storage interface - getKeys() 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.";
-        throw AuthError.createUnexpectedError(notImplErr);
-    };
-    return DefaultStorageClass;
-}(CacheManager));
-
-export { CacheManager, DefaultStorageClass };
-//# sourceMappingURL=CacheManager.js.map