@azure/msal-browser 3.0.0-alpha.1 → 3.0.0-alpha.2

package/dist/interaction_handler/InteractionHandler.js

@@ -1,135 +1,135 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-alpha.2 2023-05-17 */
 'use strict';
 import { PerformanceEvents, StringUtils, ClientAuthError, ServerError, AuthorityFactory } from '@azure/msal-common';
 import { BrowserAuthError, BrowserAuthErrorMessage } from '../error/BrowserAuthError.js';
 import { TemporaryCacheKeys } from '../utils/BrowserConstants.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Abstract class which defines operations for a browser interaction handling class.
- */
-class InteractionHandler {
-    constructor(authCodeModule, storageImpl, authCodeRequest, logger, performanceClient) {
-        this.authModule = authCodeModule;
-        this.browserStorage = storageImpl;
-        this.authCodeRequest = authCodeRequest;
-        this.logger = logger;
-        this.performanceClient = performanceClient;
-    }
-    /**
-     * Function to handle response parameters from hash.
-     * @param locationHash
-     */
-    async handleCodeResponseFromHash(locationHash, state, authority, networkModule) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.HandleCodeResponseFromHash, this.authCodeRequest.correlationId);
-        this.logger.verbose("InteractionHandler.handleCodeResponse called");
-        // Check that location hash isn't empty.
-        if (StringUtils.isEmpty(locationHash)) {
-            throw BrowserAuthError.createEmptyHashError();
-        }
-        // Handle code response.
-        const stateKey = this.browserStorage.generateStateKey(state);
-        const requestState = this.browserStorage.getTemporaryCache(stateKey);
-        if (!requestState) {
-            throw ClientAuthError.createStateNotFoundError("Cached State");
-        }
-        let authCodeResponse;
-        try {
-            authCodeResponse = this.authModule.handleFragmentResponse(locationHash, requestState);
-        }
-        catch (e) {
-            if (e instanceof ServerError &&
-                e.subError === BrowserAuthErrorMessage.userCancelledError.code) {
-                // Translate server error caused by user closing native prompt to corresponding first class MSAL error
-                throw BrowserAuthError.createUserCancelledError();
-            }
-            else {
-                throw e;
-            }
-        }
-        this.performanceClient.setPreQueueTime(PerformanceEvents.HandleCodeResponseFromServer, this.authCodeRequest.correlationId);
-        return this.handleCodeResponseFromServer(authCodeResponse, state, authority, networkModule);
-    }
-    /**
-     * Process auth code response from AAD
-     * @param authCodeResponse
-     * @param state
-     * @param authority
-     * @param networkModule
-     * @returns
-     */
-    async handleCodeResponseFromServer(authCodeResponse, state, authority, networkModule, validateNonce = true) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.HandleCodeResponseFromServer, this.authCodeRequest.correlationId);
-        this.logger.trace("InteractionHandler.handleCodeResponseFromServer called");
-        // Handle code response.
-        const stateKey = this.browserStorage.generateStateKey(state);
-        const requestState = this.browserStorage.getTemporaryCache(stateKey);
-        if (!requestState) {
-            throw ClientAuthError.createStateNotFoundError("Cached State");
-        }
-        // Get cached items
-        const nonceKey = this.browserStorage.generateNonceKey(requestState);
-        const cachedNonce = this.browserStorage.getTemporaryCache(nonceKey);
-        // Assign code to request
-        this.authCodeRequest.code = authCodeResponse.code;
-        // Check for new cloud instance
-        if (authCodeResponse.cloud_instance_host_name) {
-            this.performanceClient.setPreQueueTime(PerformanceEvents.UpdateTokenEndpointAuthority, this.authCodeRequest.correlationId);
-            await this.updateTokenEndpointAuthority(authCodeResponse.cloud_instance_host_name, authority, networkModule);
-        }
-        // Nonce validation not needed when redirect not involved (e.g. hybrid spa, renewing token via rt)
-        if (validateNonce) {
-            authCodeResponse.nonce = cachedNonce || undefined;
-        }
-        authCodeResponse.state = requestState;
-        // Add CCS parameters if available
-        if (authCodeResponse.client_info) {
-            this.authCodeRequest.clientInfo = authCodeResponse.client_info;
-        }
-        else {
-            const cachedCcsCred = this.checkCcsCredentials();
-            if (cachedCcsCred) {
-                this.authCodeRequest.ccsCredential = cachedCcsCred;
-            }
-        }
-        // Acquire token with retrieved code.
-        this.performanceClient.setPreQueueTime(PerformanceEvents.AuthClientAcquireToken, this.authCodeRequest.correlationId);
-        const tokenResponse = await this.authModule.acquireToken(this.authCodeRequest, authCodeResponse);
-        this.browserStorage.cleanRequestByState(state);
-        return tokenResponse;
-    }
-    /**
-     * Updates authority based on cloudInstanceHostname
-     * @param cloudInstanceHostname
-     * @param authority
-     * @param networkModule
-     */
-    async updateTokenEndpointAuthority(cloudInstanceHostname, authority, networkModule) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.UpdateTokenEndpointAuthority, this.authCodeRequest.correlationId);
-        const cloudInstanceAuthorityUri = `https://${cloudInstanceHostname}/${authority.tenant}/`;
-        const cloudInstanceAuthority = await AuthorityFactory.createDiscoveredInstance(cloudInstanceAuthorityUri, networkModule, this.browserStorage, authority.options, this.logger, this.performanceClient, this.authCodeRequest.correlationId);
-        this.authModule.updateAuthority(cloudInstanceAuthority);
-    }
-    /**
-     * Looks up ccs creds in the cache
-     */
-    checkCcsCredentials() {
-        // Look up ccs credential in temp cache
-        const cachedCcsCred = this.browserStorage.getTemporaryCache(TemporaryCacheKeys.CCS_CREDENTIAL, true);
-        if (cachedCcsCred) {
-            try {
-                return JSON.parse(cachedCcsCred);
-            }
-            catch (e) {
-                this.authModule.logger.error("Cache credential could not be parsed");
-                this.authModule.logger.errorPii(`Cache credential could not be parsed: ${cachedCcsCred}`);
-            }
-        }
-        return null;
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Abstract class which defines operations for a browser interaction handling class.
+ */
+class InteractionHandler {
+    constructor(authCodeModule, storageImpl, authCodeRequest, logger, performanceClient) {
+        this.authModule = authCodeModule;
+        this.browserStorage = storageImpl;
+        this.authCodeRequest = authCodeRequest;
+        this.logger = logger;
+        this.performanceClient = performanceClient;
+    }
+    /**
+     * Function to handle response parameters from hash.
+     * @param locationHash
+     */
+    async handleCodeResponseFromHash(locationHash, state, authority, networkModule) {
+        this.performanceClient.addQueueMeasurement(PerformanceEvents.HandleCodeResponseFromHash, this.authCodeRequest.correlationId);
+        this.logger.verbose("InteractionHandler.handleCodeResponse called");
+        // Check that location hash isn't empty.
+        if (StringUtils.isEmpty(locationHash)) {
+            throw BrowserAuthError.createEmptyHashError();
+        }
+        // Handle code response.
+        const stateKey = this.browserStorage.generateStateKey(state);
+        const requestState = this.browserStorage.getTemporaryCache(stateKey);
+        if (!requestState) {
+            throw ClientAuthError.createStateNotFoundError("Cached State");
+        }
+        let authCodeResponse;
+        try {
+            authCodeResponse = this.authModule.handleFragmentResponse(locationHash, requestState);
+        }
+        catch (e) {
+            if (e instanceof ServerError &&
+                e.subError === BrowserAuthErrorMessage.userCancelledError.code) {
+                // Translate server error caused by user closing native prompt to corresponding first class MSAL error
+                throw BrowserAuthError.createUserCancelledError();
+            }
+            else {
+                throw e;
+            }
+        }
+        this.performanceClient.setPreQueueTime(PerformanceEvents.HandleCodeResponseFromServer, this.authCodeRequest.correlationId);
+        return this.handleCodeResponseFromServer(authCodeResponse, state, authority, networkModule);
+    }
+    /**
+     * Process auth code response from AAD
+     * @param authCodeResponse
+     * @param state
+     * @param authority
+     * @param networkModule
+     * @returns
+     */
+    async handleCodeResponseFromServer(authCodeResponse, state, authority, networkModule, validateNonce = true) {
+        this.performanceClient.addQueueMeasurement(PerformanceEvents.HandleCodeResponseFromServer, this.authCodeRequest.correlationId);
+        this.logger.trace("InteractionHandler.handleCodeResponseFromServer called");
+        // Handle code response.
+        const stateKey = this.browserStorage.generateStateKey(state);
+        const requestState = this.browserStorage.getTemporaryCache(stateKey);
+        if (!requestState) {
+            throw ClientAuthError.createStateNotFoundError("Cached State");
+        }
+        // Get cached items
+        const nonceKey = this.browserStorage.generateNonceKey(requestState);
+        const cachedNonce = this.browserStorage.getTemporaryCache(nonceKey);
+        // Assign code to request
+        this.authCodeRequest.code = authCodeResponse.code;
+        // Check for new cloud instance
+        if (authCodeResponse.cloud_instance_host_name) {
+            this.performanceClient.setPreQueueTime(PerformanceEvents.UpdateTokenEndpointAuthority, this.authCodeRequest.correlationId);
+            await this.updateTokenEndpointAuthority(authCodeResponse.cloud_instance_host_name, authority, networkModule);
+        }
+        // Nonce validation not needed when redirect not involved (e.g. hybrid spa, renewing token via rt)
+        if (validateNonce) {
+            authCodeResponse.nonce = cachedNonce || undefined;
+        }
+        authCodeResponse.state = requestState;
+        // Add CCS parameters if available
+        if (authCodeResponse.client_info) {
+            this.authCodeRequest.clientInfo = authCodeResponse.client_info;
+        }
+        else {
+            const cachedCcsCred = this.checkCcsCredentials();
+            if (cachedCcsCred) {
+                this.authCodeRequest.ccsCredential = cachedCcsCred;
+            }
+        }
+        // Acquire token with retrieved code.
+        this.performanceClient.setPreQueueTime(PerformanceEvents.AuthClientAcquireToken, this.authCodeRequest.correlationId);
+        const tokenResponse = await this.authModule.acquireToken(this.authCodeRequest, authCodeResponse);
+        this.browserStorage.cleanRequestByState(state);
+        return tokenResponse;
+    }
+    /**
+     * Updates authority based on cloudInstanceHostname
+     * @param cloudInstanceHostname
+     * @param authority
+     * @param networkModule
+     */
+    async updateTokenEndpointAuthority(cloudInstanceHostname, authority, networkModule) {
+        this.performanceClient.addQueueMeasurement(PerformanceEvents.UpdateTokenEndpointAuthority, this.authCodeRequest.correlationId);
+        const cloudInstanceAuthorityUri = `https://${cloudInstanceHostname}/${authority.tenant}/`;
+        const cloudInstanceAuthority = await AuthorityFactory.createDiscoveredInstance(cloudInstanceAuthorityUri, networkModule, this.browserStorage, authority.options, this.logger, this.performanceClient, this.authCodeRequest.correlationId);
+        this.authModule.updateAuthority(cloudInstanceAuthority);
+    }
+    /**
+     * Looks up ccs creds in the cache
+     */
+    checkCcsCredentials() {
+        // Look up ccs credential in temp cache
+        const cachedCcsCred = this.browserStorage.getTemporaryCache(TemporaryCacheKeys.CCS_CREDENTIAL, true);
+        if (cachedCcsCred) {
+            try {
+                return JSON.parse(cachedCcsCred);
+            }
+            catch (e) {
+                this.authModule.logger.error("Cache credential could not be parsed");
+                this.authModule.logger.errorPii(`Cache credential could not be parsed: ${cachedCcsCred}`);
+            }
+        }
+        return null;
+    }
 }
 
 export { InteractionHandler };

package/dist/interaction_handler/RedirectHandler.d.ts

@@ -1,25 +1,25 @@
-import { AuthorizationCodeClient, CommonAuthorizationCodeRequest, ICrypto, AuthenticationResult, Authority, INetworkModule, Logger, IPerformanceClient } from "@azure/msal-common";
-import { BrowserCacheManager } from "../cache/BrowserCacheManager";
-import { InteractionHandler, InteractionParams } from "./InteractionHandler";
-import { INavigationClient } from "../navigation/INavigationClient";
-export type RedirectParams = InteractionParams & {
-    navigationClient: INavigationClient;
-    redirectTimeout: number;
-    redirectStartPage: string;
-    onRedirectNavigate?: (url: string) => void | boolean;
-};
-export declare class RedirectHandler extends InteractionHandler {
-    private browserCrypto;
-    constructor(authCodeModule: AuthorizationCodeClient, storageImpl: BrowserCacheManager, authCodeRequest: CommonAuthorizationCodeRequest, logger: Logger, browserCrypto: ICrypto, performanceClient: IPerformanceClient);
-    /**
-     * Redirects window to given URL.
-     * @param urlNavigate
-     */
-    initiateAuthRequest(requestUrl: string, params: RedirectParams): Promise<void>;
-    /**
-     * Handle authorization code response in the window.
-     * @param hash
-     */
-    handleCodeResponseFromHash(locationHash: string, state: string, authority: Authority, networkModule: INetworkModule): Promise<AuthenticationResult>;
-}
+import { AuthorizationCodeClient, CommonAuthorizationCodeRequest, ICrypto, AuthenticationResult, Authority, INetworkModule, Logger, IPerformanceClient } from "@azure/msal-common";
+import { BrowserCacheManager } from "../cache/BrowserCacheManager";
+import { InteractionHandler, InteractionParams } from "./InteractionHandler";
+import { INavigationClient } from "../navigation/INavigationClient";
+export type RedirectParams = InteractionParams & {
+    navigationClient: INavigationClient;
+    redirectTimeout: number;
+    redirectStartPage: string;
+    onRedirectNavigate?: (url: string) => void | boolean;
+};
+export declare class RedirectHandler extends InteractionHandler {
+    private browserCrypto;
+    constructor(authCodeModule: AuthorizationCodeClient, storageImpl: BrowserCacheManager, authCodeRequest: CommonAuthorizationCodeRequest, logger: Logger, browserCrypto: ICrypto, performanceClient: IPerformanceClient);
+    /**
+     * Redirects window to given URL.
+     * @param urlNavigate
+     */
+    initiateAuthRequest(requestUrl: string, params: RedirectParams): Promise<void>;
+    /**
+     * Handle authorization code response in the window.
+     * @param hash
+     */
+    handleCodeResponseFromHash(locationHash: string, state: string, authority: Authority, networkModule: INetworkModule): Promise<AuthenticationResult>;
+}
 //# sourceMappingURL=RedirectHandler.d.ts.map

package/dist/interaction_handler/RedirectHandler.js

@@ -1,127 +1,127 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-alpha.2 2023-05-17 */
 'use strict';
 import { StringUtils, ClientAuthError, ServerError } from '@azure/msal-common';
 import { BrowserAuthError, BrowserAuthErrorMessage } from '../error/BrowserAuthError.js';
 import { TemporaryCacheKeys, ApiId } from '../utils/BrowserConstants.js';
 import { InteractionHandler } from './InteractionHandler.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class RedirectHandler extends InteractionHandler {
-    constructor(authCodeModule, storageImpl, authCodeRequest, logger, browserCrypto, performanceClient) {
-        super(authCodeModule, storageImpl, authCodeRequest, logger, performanceClient);
-        this.browserCrypto = browserCrypto;
-    }
-    /**
-     * Redirects window to given URL.
-     * @param urlNavigate
-     */
-    async initiateAuthRequest(requestUrl, params) {
-        this.logger.verbose("RedirectHandler.initiateAuthRequest called");
-        // Navigate if valid URL
-        if (!StringUtils.isEmpty(requestUrl)) {
-            // Cache start page, returns to this page after redirectUri if navigateToLoginRequestUrl is true
-            if (params.redirectStartPage) {
-                this.logger.verbose("RedirectHandler.initiateAuthRequest: redirectStartPage set, caching start page");
-                this.browserStorage.setTemporaryCache(TemporaryCacheKeys.ORIGIN_URI, params.redirectStartPage, true);
-            }
-            // Set interaction status in the library.
-            this.browserStorage.setTemporaryCache(TemporaryCacheKeys.CORRELATION_ID, this.authCodeRequest.correlationId, true);
-            this.browserStorage.cacheCodeRequest(this.authCodeRequest, this.browserCrypto);
-            this.logger.infoPii(`RedirectHandler.initiateAuthRequest: Navigate to: ${requestUrl}`);
-            const navigationOptions = {
-                apiId: ApiId.acquireTokenRedirect,
-                timeout: params.redirectTimeout,
-                noHistory: false,
-            };
-            // If onRedirectNavigate is implemented, invoke it and provide requestUrl
-            if (typeof params.onRedirectNavigate === "function") {
-                this.logger.verbose("RedirectHandler.initiateAuthRequest: Invoking onRedirectNavigate callback");
-                const navigate = params.onRedirectNavigate(requestUrl);
-                // Returning false from onRedirectNavigate will stop navigation
-                if (navigate !== false) {
-                    this.logger.verbose("RedirectHandler.initiateAuthRequest: onRedirectNavigate did not return false, navigating");
-                    await params.navigationClient.navigateExternal(requestUrl, navigationOptions);
-                    return;
-                }
-                else {
-                    this.logger.verbose("RedirectHandler.initiateAuthRequest: onRedirectNavigate returned false, stopping navigation");
-                    return;
-                }
-            }
-            else {
-                // Navigate window to request URL
-                this.logger.verbose("RedirectHandler.initiateAuthRequest: Navigating window to navigate url");
-                await params.navigationClient.navigateExternal(requestUrl, navigationOptions);
-                return;
-            }
-        }
-        else {
-            // Throw error if request URL is empty.
-            this.logger.info("RedirectHandler.initiateAuthRequest: Navigate url is empty");
-            throw BrowserAuthError.createEmptyNavigationUriError();
-        }
-    }
-    /**
-     * Handle authorization code response in the window.
-     * @param hash
-     */
-    async handleCodeResponseFromHash(locationHash, state, authority, networkModule) {
-        this.logger.verbose("RedirectHandler.handleCodeResponse called");
-        // Check that location hash isn't empty.
-        if (StringUtils.isEmpty(locationHash)) {
-            throw BrowserAuthError.createEmptyHashError();
-        }
-        // Interaction is completed - remove interaction status.
-        this.browserStorage.setInteractionInProgress(false);
-        // Handle code response.
-        const stateKey = this.browserStorage.generateStateKey(state);
-        const requestState = this.browserStorage.getTemporaryCache(stateKey);
-        if (!requestState) {
-            throw ClientAuthError.createStateNotFoundError("Cached State");
-        }
-        let authCodeResponse;
-        try {
-            authCodeResponse = this.authModule.handleFragmentResponse(locationHash, requestState);
-        }
-        catch (e) {
-            if (e instanceof ServerError &&
-                e.subError === BrowserAuthErrorMessage.userCancelledError.code) {
-                // Translate server error caused by user closing native prompt to corresponding first class MSAL error
-                throw BrowserAuthError.createUserCancelledError();
-            }
-            else {
-                throw e;
-            }
-        }
-        // Get cached items
-        const nonceKey = this.browserStorage.generateNonceKey(requestState);
-        const cachedNonce = this.browserStorage.getTemporaryCache(nonceKey);
-        // Assign code to request
-        this.authCodeRequest.code = authCodeResponse.code;
-        // Check for new cloud instance
-        if (authCodeResponse.cloud_instance_host_name) {
-            await this.updateTokenEndpointAuthority(authCodeResponse.cloud_instance_host_name, authority, networkModule);
-        }
-        authCodeResponse.nonce = cachedNonce || undefined;
-        authCodeResponse.state = requestState;
-        // Add CCS parameters if available
-        if (authCodeResponse.client_info) {
-            this.authCodeRequest.clientInfo = authCodeResponse.client_info;
-        }
-        else {
-            const cachedCcsCred = this.checkCcsCredentials();
-            if (cachedCcsCred) {
-                this.authCodeRequest.ccsCredential = cachedCcsCred;
-            }
-        }
-        // Acquire token with retrieved code.
-        const tokenResponse = await this.authModule.acquireToken(this.authCodeRequest, authCodeResponse);
-        this.browserStorage.cleanRequestByState(state);
-        return tokenResponse;
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class RedirectHandler extends InteractionHandler {
+    constructor(authCodeModule, storageImpl, authCodeRequest, logger, browserCrypto, performanceClient) {
+        super(authCodeModule, storageImpl, authCodeRequest, logger, performanceClient);
+        this.browserCrypto = browserCrypto;
+    }
+    /**
+     * Redirects window to given URL.
+     * @param urlNavigate
+     */
+    async initiateAuthRequest(requestUrl, params) {
+        this.logger.verbose("RedirectHandler.initiateAuthRequest called");
+        // Navigate if valid URL
+        if (!StringUtils.isEmpty(requestUrl)) {
+            // Cache start page, returns to this page after redirectUri if navigateToLoginRequestUrl is true
+            if (params.redirectStartPage) {
+                this.logger.verbose("RedirectHandler.initiateAuthRequest: redirectStartPage set, caching start page");
+                this.browserStorage.setTemporaryCache(TemporaryCacheKeys.ORIGIN_URI, params.redirectStartPage, true);
+            }
+            // Set interaction status in the library.
+            this.browserStorage.setTemporaryCache(TemporaryCacheKeys.CORRELATION_ID, this.authCodeRequest.correlationId, true);
+            this.browserStorage.cacheCodeRequest(this.authCodeRequest, this.browserCrypto);
+            this.logger.infoPii(`RedirectHandler.initiateAuthRequest: Navigate to: ${requestUrl}`);
+            const navigationOptions = {
+                apiId: ApiId.acquireTokenRedirect,
+                timeout: params.redirectTimeout,
+                noHistory: false,
+            };
+            // If onRedirectNavigate is implemented, invoke it and provide requestUrl
+            if (typeof params.onRedirectNavigate === "function") {
+                this.logger.verbose("RedirectHandler.initiateAuthRequest: Invoking onRedirectNavigate callback");
+                const navigate = params.onRedirectNavigate(requestUrl);
+                // Returning false from onRedirectNavigate will stop navigation
+                if (navigate !== false) {
+                    this.logger.verbose("RedirectHandler.initiateAuthRequest: onRedirectNavigate did not return false, navigating");
+                    await params.navigationClient.navigateExternal(requestUrl, navigationOptions);
+                    return;
+                }
+                else {
+                    this.logger.verbose("RedirectHandler.initiateAuthRequest: onRedirectNavigate returned false, stopping navigation");
+                    return;
+                }
+            }
+            else {
+                // Navigate window to request URL
+                this.logger.verbose("RedirectHandler.initiateAuthRequest: Navigating window to navigate url");
+                await params.navigationClient.navigateExternal(requestUrl, navigationOptions);
+                return;
+            }
+        }
+        else {
+            // Throw error if request URL is empty.
+            this.logger.info("RedirectHandler.initiateAuthRequest: Navigate url is empty");
+            throw BrowserAuthError.createEmptyNavigationUriError();
+        }
+    }
+    /**
+     * Handle authorization code response in the window.
+     * @param hash
+     */
+    async handleCodeResponseFromHash(locationHash, state, authority, networkModule) {
+        this.logger.verbose("RedirectHandler.handleCodeResponse called");
+        // Check that location hash isn't empty.
+        if (StringUtils.isEmpty(locationHash)) {
+            throw BrowserAuthError.createEmptyHashError();
+        }
+        // Interaction is completed - remove interaction status.
+        this.browserStorage.setInteractionInProgress(false);
+        // Handle code response.
+        const stateKey = this.browserStorage.generateStateKey(state);
+        const requestState = this.browserStorage.getTemporaryCache(stateKey);
+        if (!requestState) {
+            throw ClientAuthError.createStateNotFoundError("Cached State");
+        }
+        let authCodeResponse;
+        try {
+            authCodeResponse = this.authModule.handleFragmentResponse(locationHash, requestState);
+        }
+        catch (e) {
+            if (e instanceof ServerError &&
+                e.subError === BrowserAuthErrorMessage.userCancelledError.code) {
+                // Translate server error caused by user closing native prompt to corresponding first class MSAL error
+                throw BrowserAuthError.createUserCancelledError();
+            }
+            else {
+                throw e;
+            }
+        }
+        // Get cached items
+        const nonceKey = this.browserStorage.generateNonceKey(requestState);
+        const cachedNonce = this.browserStorage.getTemporaryCache(nonceKey);
+        // Assign code to request
+        this.authCodeRequest.code = authCodeResponse.code;
+        // Check for new cloud instance
+        if (authCodeResponse.cloud_instance_host_name) {
+            await this.updateTokenEndpointAuthority(authCodeResponse.cloud_instance_host_name, authority, networkModule);
+        }
+        authCodeResponse.nonce = cachedNonce || undefined;
+        authCodeResponse.state = requestState;
+        // Add CCS parameters if available
+        if (authCodeResponse.client_info) {
+            this.authCodeRequest.clientInfo = authCodeResponse.client_info;
+        }
+        else {
+            const cachedCcsCred = this.checkCcsCredentials();
+            if (cachedCcsCred) {
+                this.authCodeRequest.ccsCredential = cachedCcsCred;
+            }
+        }
+        // Acquire token with retrieved code.
+        const tokenResponse = await this.authModule.acquireToken(this.authCodeRequest, authCodeResponse);
+        this.browserStorage.cleanRequestByState(state);
+        return tokenResponse;
+    }
 }
 
 export { RedirectHandler };