@azure/msal-common 4.5.0 → 5.1.0

package/dist/cache/CacheManager.js

@@ -1,13 +1,13 @@
-/*! @azure/msal-common v4.5.0 2021-07-22 */
+/*! @azure/msal-common v5.1.0 2021-11-02 */
 'use strict';
-import { __extends } from '../_virtual/_tslib.js';
-import { Constants as Constants$1, CredentialType, CacheSchemaType, THE_FAMILY_ID, APP_METADATA, AUTHORITY_METADATA_CONSTANTS, AuthenticationScheme } from '../utils/Constants.js';
-import { AuthError as AuthError$1 } from '../error/AuthError.js';
-import { ClientAuthError as ClientAuthError$1 } from '../error/ClientAuthError.js';
-import { CredentialEntity as CredentialEntity$1 } from './entities/CredentialEntity.js';
-import { ScopeSet as ScopeSet$1 } from '../request/ScopeSet.js';
-import { AccountEntity as AccountEntity$1 } from './entities/AccountEntity.js';
-import { AuthToken as AuthToken$1 } from '../account/AuthToken.js';
+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.
@@ -34,11 +34,11 @@ var CacheManager = /** @class */ (function () {
         }
         else {
             var allAccounts = accountValues.map(function (value) {
-                var accountEntity = CacheManager.toObject(new AccountEntity$1(), value);
+                var accountEntity = CacheManager.toObject(new AccountEntity(), value);
                 var accountInfo = accountEntity.getAccountInfo();
                 var idToken = _this.readIdTokenFromCache(_this.clientId, accountInfo);
                 if (idToken && !accountInfo.idTokenClaims) {
-                    accountInfo.idTokenClaims = new AuthToken$1(idToken.secret, _this.cryptoImpl).claims;
+                    accountInfo.idTokenClaims = new AuthToken(idToken.secret, _this.cryptoImpl).claims;
                 }
                 return accountInfo;
             });
@@ -50,49 +50,75 @@ var CacheManager = /** @class */ (function () {
      * @param cacheRecord
      */
     CacheManager.prototype.saveCacheRecord = function (cacheRecord) {
-        if (!cacheRecord) {
-            throw ClientAuthError$1.createNullOrUndefinedCacheRecord();
-        }
-        if (!!cacheRecord.account) {
-            this.setAccount(cacheRecord.account);
-        }
-        if (!!cacheRecord.idToken) {
-            this.setIdTokenCredential(cacheRecord.idToken);
-        }
-        if (!!cacheRecord.accessToken) {
-            this.saveAccessToken(cacheRecord.accessToken);
-        }
-        if (!!cacheRecord.refreshToken) {
-            this.setRefreshTokenCredential(cacheRecord.refreshToken);
-        }
-        if (!!cacheRecord.appMetadata) {
-            this.setAppMetadata(cacheRecord.appMetadata);
-        }
+        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) {
-        var _this = this;
-        var currentTokenCache = this.getCredentialsFilteredBy({
-            clientId: credential.clientId,
-            credentialType: credential.credentialType,
-            environment: credential.environment,
-            homeAccountId: credential.homeAccountId,
-            realm: credential.realm,
-        });
-        var currentScopes = ScopeSet$1.fromString(credential.target);
-        var currentAccessTokens = Object.keys(currentTokenCache.accessTokens).map(function (key) { return currentTokenCache.accessTokens[key]; });
-        if (currentAccessTokens) {
-            currentAccessTokens.forEach(function (tokenEntity) {
-                var tokenScopeSet = ScopeSet$1.fromString(tokenEntity.target);
-                if (tokenScopeSet.intersectingScopeSets(currentScopes)) {
-                    _this.removeCredential(tokenEntity);
+        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
+                        });
+                        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*/];
                 }
             });
-        }
-        this.setAccessTokenCredential(credential);
+        });
     };
     /**
      * retrieve accounts matching all provided filters; if no filter is set, get all accounts
@@ -143,7 +169,7 @@ var CacheManager = /** @class */ (function () {
      * @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.oboAssertion);
+        return this.getCredentialsFilteredByInternal(filter.homeAccountId, filter.environment, filter.credentialType, filter.clientId, filter.familyId, filter.realm, filter.target, filter.oboAssertion, filter.tokenType, filter.keyId);
     };
     /**
      * Support function to help match credentials
@@ -153,8 +179,10 @@ var CacheManager = /** @class */ (function () {
      * @param clientId
      * @param realm
      * @param target
+     * @param oboAssertion
+     * @param tokenType
      */
-    CacheManager.prototype.getCredentialsFilteredByInternal = function (homeAccountId, environment, credentialType, clientId, familyId, realm, target, oboAssertion) {
+    CacheManager.prototype.getCredentialsFilteredByInternal = function (homeAccountId, environment, credentialType, clientId, familyId, realm, target, oboAssertion, tokenType, keyId) {
         var _this = this;
         var allCacheKeys = this.getKeys();
         var matchingCredentials = {
@@ -164,8 +192,8 @@ var CacheManager = /** @class */ (function () {
         };
         allCacheKeys.forEach(function (cacheKey) {
             // don't parse any non-credential type cache entities
-            var credType = CredentialEntity$1.getCredentialType(cacheKey);
-            if (credType === Constants$1.NOT_DEFINED) {
+            var credType = CredentialEntity.getCredentialType(cacheKey);
+            if (credType === Constants.NOT_DEFINED) {
                 return;
             }
             // Attempt retrieval
@@ -201,6 +229,28 @@ var CacheManager = /** @class */ (function () {
             if (!!target && !_this.matchTarget(entity, target)) {
                 return;
             }
+            // Access Token with Auth Scheme specific matching
+            if (credentialType === CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME) {
+                if (!!tokenType && !_this.matchTokenType(entity, tokenType)) {
+                    return;
+                }
+                switch (tokenType) {
+                    case AuthenticationScheme.POP:
+                        // This check avoids matching outdated POP tokens that don't have the <-scheme> in the cache key
+                        if (cacheKey.indexOf(AuthenticationScheme.POP) === -1) {
+                            // AccessToken_With_AuthScheme that doesn't have "-pop" in the key is outdated and needs to be removed
+                            _this.removeItem(cacheKey, CacheSchemaType.CREDENTIAL);
+                            return;
+                        }
+                        break;
+                    case AuthenticationScheme.SSH:
+                        // KeyId (sshKid) in request must match cached SSH certificate keyId because SSH cert is bound to a specific key
+                        if (keyId && !_this.matchKeyId(entity, keyId)) {
+                            return;
+                        }
+                        break;
+                }
+            }
             switch (credType) {
                 case CredentialType.ID_TOKEN:
                     matchingCredentials.idTokens[cacheKey] = entity;
@@ -281,56 +331,112 @@ var CacheManager = /** @class */ (function () {
      * Removes all accounts and related tokens from cache.
      */
     CacheManager.prototype.removeAllAccounts = function () {
-        var _this = this;
-        var allCacheKeys = this.getKeys();
-        allCacheKeys.forEach(function (cacheKey) {
-            var entity = _this.getAccount(cacheKey);
-            if (!entity) {
-                return;
-            }
-            _this.removeAccount(cacheKey);
+        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];
+                }
+            });
         });
-        return true;
     };
     /**
      * returns a boolean if the given account is removed
      * @param account
      */
     CacheManager.prototype.removeAccount = function (accountKey) {
-        var account = this.getAccount(accountKey);
-        if (!account) {
-            throw ClientAuthError$1.createNoAccountFoundError();
-        }
-        return (this.removeAccountContext(account) && this.removeItem(accountKey, CacheSchemaType.ACCOUNT));
+        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))];
+                }
+            });
+        });
     };
     /**
      * returns a boolean if the given account is removed
      * @param account
      */
     CacheManager.prototype.removeAccountContext = function (account) {
-        var _this = this;
-        var allCacheKeys = this.getKeys();
-        var accountId = account.generateAccountId();
-        allCacheKeys.forEach(function (cacheKey) {
-            // don't parse any non-credential type cache entities
-            var credType = CredentialEntity$1.getCredentialType(cacheKey);
-            if (credType === Constants$1.NOT_DEFINED) {
-                return;
-            }
-            var cacheEntity = _this.getSpecificCredential(cacheKey, credType);
-            if (!!cacheEntity && accountId === cacheEntity.generateAccountId()) {
-                _this.removeCredential(cacheEntity);
-            }
+        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];
+                }
+            });
         });
-        return true;
     };
     /**
      * returns a boolean if the given credential is removed
      * @param credential
      */
     CacheManager.prototype.removeCredential = function (credential) {
-        var key = credential.generateCredentialKey();
-        return this.removeItem(key, CacheSchemaType.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.
@@ -353,14 +459,14 @@ var CacheManager = /** @class */ (function () {
      * @param environment
      * @param authScheme
      */
-    CacheManager.prototype.readCacheRecord = function (account, clientId, scopes, environment, authScheme) {
+    CacheManager.prototype.readCacheRecord = function (account, clientId, scopes, environment, authScheme, keyId) {
         var cachedAccount = this.readAccountFromCache(account);
         var cachedIdToken = this.readIdTokenFromCache(clientId, account);
-        var cachedAccessToken = this.readAccessTokenFromCache(clientId, account, scopes, authScheme);
+        var cachedAccessToken = this.readAccessTokenFromCache(clientId, account, scopes, authScheme, keyId);
         var cachedRefreshToken = this.readRefreshTokenFromCache(clientId, account, false);
         var cachedAppMetadata = this.readAppMetadataFromCache(environment, clientId);
         if (cachedAccount && cachedIdToken) {
-            cachedAccount.idTokenClaims = new AuthToken$1(cachedIdToken.secret, this.cryptoImpl).claims;
+            cachedAccount.idTokenClaims = new AuthToken(cachedIdToken.secret, this.cryptoImpl).claims;
         }
         return {
             account: cachedAccount,
@@ -375,7 +481,7 @@ var CacheManager = /** @class */ (function () {
      * @param account
      */
     CacheManager.prototype.readAccountFromCache = function (account) {
-        var accountKey = AccountEntity$1.generateAccountCacheKey(account);
+        var accountKey = AccountEntity.generateAccountCacheKey(account);
         return this.getAccount(accountKey);
     };
     /**
@@ -399,7 +505,7 @@ var CacheManager = /** @class */ (function () {
             return null;
         }
         else if (numIdTokens > 1) {
-            throw ClientAuthError$1.createMultipleMatchingTokensInCacheError();
+            throw ClientAuthError.createMultipleMatchingTokensInCacheError();
         }
         return idTokens[0];
     };
@@ -410,8 +516,9 @@ var CacheManager = /** @class */ (function () {
      * @param scopes
      * @param authScheme
      */
-    CacheManager.prototype.readAccessTokenFromCache = function (clientId, account, scopes, authScheme) {
-        var credentialType = (authScheme === AuthenticationScheme.POP) ? CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME : CredentialType.ACCESS_TOKEN;
+    CacheManager.prototype.readAccessTokenFromCache = function (clientId, account, scopes, authScheme, keyId) {
+        // Distinguish between Bearer and PoP/SSH token cache types
+        var credentialType = (authScheme && authScheme !== AuthenticationScheme.BEARER) ? CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME : CredentialType.ACCESS_TOKEN;
         var accessTokenFilter = {
             homeAccountId: account.homeAccountId,
             environment: account.environment,
@@ -419,6 +526,8 @@ var CacheManager = /** @class */ (function () {
             clientId: clientId,
             realm: account.tenantId,
             target: scopes.printScopesLowerCase(),
+            tokenType: authScheme,
+            keyId: keyId
         };
         var credentialCache = this.getCredentialsFilteredBy(accessTokenFilter);
         var accessTokens = Object.keys(credentialCache.accessTokens).map(function (key) { return credentialCache.accessTokens[key]; });
@@ -427,7 +536,7 @@ var CacheManager = /** @class */ (function () {
             return null;
         }
         else if (numAccessTokens > 1) {
-            throw ClientAuthError$1.createMultipleMatchingTokensInCacheError();
+            throw ClientAuthError.createMultipleMatchingTokensInCacheError();
         }
         return accessTokens[0];
     };
@@ -470,7 +579,7 @@ var CacheManager = /** @class */ (function () {
             return null;
         }
         else if (numAppMetadata > 1) {
-            throw ClientAuthError$1.createMultipleMatchingAppMetadataInCacheError();
+            throw ClientAuthError.createMultipleMatchingAppMetadataInCacheError();
         }
         return appMetadataEntries[0];
     };
@@ -553,16 +662,32 @@ var CacheManager = /** @class */ (function () {
         if (isNotAccessTokenCredential || !entity.target) {
             return false;
         }
-        var entityScopeSet = ScopeSet$1.fromString(entity.target);
-        var requestTargetScopeSet = ScopeSet$1.fromString(target);
+        var entityScopeSet = ScopeSet.fromString(entity.target);
+        var requestTargetScopeSet = ScopeSet.fromString(target);
         if (!requestTargetScopeSet.containsOnlyOIDCScopes()) {
             requestTargetScopeSet.removeOIDCScopes(); // ignore OIDC scopes
         }
         else {
-            requestTargetScopeSet.removeScope(Constants$1.OFFLINE_ACCESS_SCOPE);
+            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
@@ -624,87 +749,92 @@ var DefaultStorageClass = /** @class */ (function (_super) {
     }
     DefaultStorageClass.prototype.setAccount = function () {
         var notImplErr = "Storage interface - setAccount() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.getAccount = function () {
         var notImplErr = "Storage interface - getAccount() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.setIdTokenCredential = function () {
         var notImplErr = "Storage interface - setIdTokenCredential() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.getIdTokenCredential = function () {
         var notImplErr = "Storage interface - getIdTokenCredential() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.setAccessTokenCredential = function () {
         var notImplErr = "Storage interface - setAccessTokenCredential() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.getAccessTokenCredential = function () {
         var notImplErr = "Storage interface - getAccessTokenCredential() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.setRefreshTokenCredential = function () {
         var notImplErr = "Storage interface - setRefreshTokenCredential() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.getRefreshTokenCredential = function () {
         var notImplErr = "Storage interface - getRefreshTokenCredential() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.setAppMetadata = function () {
         var notImplErr = "Storage interface - setAppMetadata() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.getAppMetadata = function () {
         var notImplErr = "Storage interface - getAppMetadata() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.setServerTelemetry = function () {
         var notImplErr = "Storage interface - setServerTelemetry() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.getServerTelemetry = function () {
         var notImplErr = "Storage interface - getServerTelemetry() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.setAuthorityMetadata = function () {
         var notImplErr = "Storage interface - setAuthorityMetadata() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.getAuthorityMetadata = function () {
         var notImplErr = "Storage interface - getAuthorityMetadata() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.getAuthorityMetadataKeys = function () {
         var notImplErr = "Storage interface - getAuthorityMetadataKeys() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.setThrottlingCache = function () {
         var notImplErr = "Storage interface - setThrottlingCache() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.getThrottlingCache = function () {
         var notImplErr = "Storage interface - getThrottlingCache() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.removeItem = function () {
         var notImplErr = "Storage interface - removeItem() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.containsKey = function () {
         var notImplErr = "Storage interface - containsKey() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.getKeys = function () {
         var notImplErr = "Storage interface - getKeys() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        throw AuthError.createUnexpectedError(notImplErr);
     };
     DefaultStorageClass.prototype.clear = function () {
-        var notImplErr = "Storage interface - clear() has not been implemented for the cacheStorage interface.";
-        throw AuthError$1.createUnexpectedError(notImplErr);
+        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);
+            });
+        });
     };
     return DefaultStorageClass;
 }(CacheManager));