@azure/msal-browser 3.0.2 → 3.1.0

package/src/encode/Base64Encode.ts

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Class which exposes APIs to encode plaintext to base64 encoded string. See here for implementation details:
+ * https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#Solution_2_%E2%80%93_JavaScript's_UTF-16_%3E_UTF-8_%3E_base64
+ */
+
+/**
+ * Returns URL Safe b64 encoded string from a plaintext string.
+ * @param input
+ */
+export function urlEncode(input: string): string {
+    return encodeURIComponent(
+        base64Encode(input)
+            .replace(/=/g, "")
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+    );
+}
+
+/**
+ * Returns URL Safe b64 encoded string from an int8Array.
+ * @param inputArr
+ */
+export function urlEncodeArr(inputArr: Uint8Array): string {
+    return base64EncArr(inputArr)
+        .replace(/=/g, "")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_");
+}
+
+/**
+ * Returns b64 encoded string from plaintext string.
+ * @param input
+ */
+export function base64Encode(input: string): string {
+    return base64EncArr(new TextEncoder().encode(input));
+}
+
+/**
+ * Base64 encode byte array
+ * @param aBytes
+ */
+function base64EncArr(aBytes: Uint8Array): string {
+    const binString = Array.from(aBytes, (x) => String.fromCodePoint(x)).join(
+        ""
+    );
+    return btoa(binString);
+}

package/src/error/BrowserAuthError.ts

@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthError } from "@azure/msal-common";
+import * as BrowserAuthErrorCodes from "./BrowserAuthErrorCodes";
+export { BrowserAuthErrorCodes }; // Allow importing as "BrowserAuthErrorCodes"
+
+const ErrorLink = "For more visit: aka.ms/msaljs/browser-errors";
+
+/**
+ * BrowserAuthErrorMessage class containing string constants used by error codes and messages.
+ */
+export const BrowserAuthErrorMessages = {
+    [BrowserAuthErrorCodes.pkceNotCreated]:
+        "The PKCE code challenge and verifier could not be generated.",
+    [BrowserAuthErrorCodes.cryptoNonExistent]:
+        "The crypto object or function is not available.",
+    [BrowserAuthErrorCodes.emptyNavigateUri]:
+        "Navigation URI is empty. Please check stack trace for more info.",
+    [BrowserAuthErrorCodes.hashEmptyError]: `Hash value cannot be processed because it is empty. Please verify that your redirectUri is not clearing the hash. ${ErrorLink}`,
+    [BrowserAuthErrorCodes.noStateInHash]:
+        "Hash does not contain state. Please verify that the request originated from msal.",
+    [BrowserAuthErrorCodes.hashDoesNotContainKnownProperties]: `Hash does not contain known properites. Please verify that your redirectUri is not changing the hash.  ${ErrorLink}`,
+    [BrowserAuthErrorCodes.unableToParseState]:
+        "Unable to parse state. Please verify that the request originated from msal.",
+    [BrowserAuthErrorCodes.stateInteractionTypeMismatch]:
+        "Hash contains state but the interaction type does not match the caller.",
+    [BrowserAuthErrorCodes.interactionInProgress]: `Interaction is currently in progress. Please ensure that this interaction has been completed before calling an interactive API.   ${ErrorLink}`,
+    [BrowserAuthErrorCodes.popupWindowError]:
+        "Error opening popup window. This can happen if you are using IE or if popups are blocked in the browser.",
+    [BrowserAuthErrorCodes.emptyWindowError]:
+        "window.open returned null or undefined window object.",
+    [BrowserAuthErrorCodes.userCancelled]: "User cancelled the flow.",
+    [BrowserAuthErrorCodes.monitorPopupTimeout]: `Token acquisition in popup failed due to timeout.  ${ErrorLink}`,
+    [BrowserAuthErrorCodes.monitorWindowTimeout]: `Token acquisition in iframe failed due to timeout.  ${ErrorLink}`,
+    [BrowserAuthErrorCodes.redirectInIframe]:
+        "Redirects are not supported for iframed or brokered applications. Please ensure you are using MSAL.js in a top frame of the window if using the redirect APIs, or use the popup APIs.",
+    [BrowserAuthErrorCodes.blockIframeReload]: `Request was blocked inside an iframe because MSAL detected an authentication response.  ${ErrorLink}`,
+    [BrowserAuthErrorCodes.blockNestedPopups]:
+        "Request was blocked inside a popup because MSAL detected it was running in a popup.",
+    [BrowserAuthErrorCodes.iframeClosedPrematurely]:
+        "The iframe being monitored was closed prematurely.",
+    [BrowserAuthErrorCodes.silentLogoutUnsupported]:
+        "Silent logout not supported. Please call logoutRedirect or logoutPopup instead.",
+    [BrowserAuthErrorCodes.noAccountError]:
+        "No account object provided to acquireTokenSilent and no active account has been set. Please call setActiveAccount or provide an account on the request.",
+    [BrowserAuthErrorCodes.silentPromptValueError]:
+        "The value given for the prompt value is not valid for silent requests - must be set to 'none' or 'no_session'.",
+    [BrowserAuthErrorCodes.noTokenRequestCacheError]:
+        "No token request found in cache.",
+    [BrowserAuthErrorCodes.unableToParseTokenRequestCacheError]:
+        "The cached token request could not be parsed.",
+    [BrowserAuthErrorCodes.noCachedAuthorityError]:
+        "No cached authority found.",
+    [BrowserAuthErrorCodes.authRequestNotSetError]:
+        "Auth Request not set. Please ensure initiateAuthRequest was called from the InteractionHandler",
+    [BrowserAuthErrorCodes.invalidCacheType]: "Invalid cache type",
+    [BrowserAuthErrorCodes.nonBrowserEnvironment]:
+        "Login and token requests are not supported in non-browser environments.",
+    [BrowserAuthErrorCodes.databaseNotOpen]: "Database is not open!",
+    [BrowserAuthErrorCodes.noNetworkConnectivity]:
+        "No network connectivity. Check your internet connection.",
+    [BrowserAuthErrorCodes.postRequestFailed]:
+        "Network request failed: If the browser threw a CORS error, check that the redirectUri is registered in the Azure App Portal as type 'SPA'",
+    [BrowserAuthErrorCodes.getRequestFailed]:
+        "Network request failed. Please check the network trace to determine root cause.",
+    [BrowserAuthErrorCodes.failedToParseResponse]:
+        "Failed to parse network response. Check network trace.",
+    [BrowserAuthErrorCodes.unableToLoadToken]: "Error loading token to cache.",
+    [BrowserAuthErrorCodes.cryptoKeyNotFound]:
+        "Cryptographic Key or Keypair not found in browser storage.",
+    [BrowserAuthErrorCodes.authCodeRequired]:
+        "An authorization code must be provided (as the `code` property on the request) to this flow.",
+    [BrowserAuthErrorCodes.authCodeOrNativeAccountIdRequired]:
+        "An authorization code or nativeAccountId must be provided to this flow.",
+    [BrowserAuthErrorCodes.spaCodeAndNativeAccountIdPresent]:
+        "Request cannot contain both spa code and native account id.",
+    [BrowserAuthErrorCodes.databaseUnavailable]:
+        "IndexedDB, which is required for persistent cryptographic key storage, is unavailable. This may be caused by browser privacy features which block persistent storage in third-party contexts.",
+    [BrowserAuthErrorCodes.unableToAcquireTokenFromNativePlatform]: `Unable to acquire token from native platform.  ${ErrorLink}`,
+    [BrowserAuthErrorCodes.nativeHandshakeTimeout]:
+        "Timed out while attempting to establish connection to browser extension",
+    [BrowserAuthErrorCodes.nativeExtensionNotInstalled]:
+        "Native extension is not installed. If you think this is a mistake call the initialize function.",
+    [BrowserAuthErrorCodes.nativeConnectionNotEstablished]: `Connection to native platform has not been established. Please install a compatible browser extension and run initialize().  ${ErrorLink}`,
+    [BrowserAuthErrorCodes.uninitializedPublicClientApplication]: `You must call and await the initialize function before attempting to call any other MSAL API.  ${ErrorLink}`,
+    [BrowserAuthErrorCodes.nativePromptNotSupported]:
+        "The provided prompt is not supported by the native platform. This request should be routed to the web based flow.",
+};
+
+/**
+ * BrowserAuthErrorMessage class containing string constants used by error codes and messages.
+ * @deprecated Use BrowserAuthBrowserAuthErrorCodes instead
+ */
+export const BrowserAuthErrorMessage = {
+    pkceNotGenerated: {
+        code: BrowserAuthErrorCodes.pkceNotCreated,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.pkceNotCreated],
+    },
+    cryptoDoesNotExist: {
+        code: BrowserAuthErrorCodes.cryptoNonExistent,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.cryptoNonExistent],
+    },
+    emptyNavigateUriError: {
+        code: BrowserAuthErrorCodes.emptyNavigateUri,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.emptyNavigateUri],
+    },
+    hashEmptyError: {
+        code: BrowserAuthErrorCodes.hashEmptyError,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.hashEmptyError],
+    },
+    hashDoesNotContainStateError: {
+        code: BrowserAuthErrorCodes.noStateInHash,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.noStateInHash],
+    },
+    hashDoesNotContainKnownPropertiesError: {
+        code: BrowserAuthErrorCodes.hashDoesNotContainKnownProperties,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.hashDoesNotContainKnownProperties
+        ],
+    },
+    unableToParseStateError: {
+        code: BrowserAuthErrorCodes.unableToParseState,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.unableToParseState
+        ],
+    },
+    stateInteractionTypeMismatchError: {
+        code: BrowserAuthErrorCodes.stateInteractionTypeMismatch,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.stateInteractionTypeMismatch
+        ],
+    },
+    interactionInProgress: {
+        code: BrowserAuthErrorCodes.interactionInProgress,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.interactionInProgress
+        ],
+    },
+    popupWindowError: {
+        code: BrowserAuthErrorCodes.popupWindowError,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.popupWindowError],
+    },
+    emptyWindowError: {
+        code: BrowserAuthErrorCodes.emptyWindowError,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.emptyWindowError],
+    },
+    userCancelledError: {
+        code: BrowserAuthErrorCodes.userCancelled,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.userCancelled],
+    },
+    monitorPopupTimeoutError: {
+        code: BrowserAuthErrorCodes.monitorPopupTimeout,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.monitorPopupTimeout
+        ],
+    },
+    monitorIframeTimeoutError: {
+        code: BrowserAuthErrorCodes.monitorWindowTimeout,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.monitorWindowTimeout
+        ],
+    },
+    redirectInIframeError: {
+        code: BrowserAuthErrorCodes.redirectInIframe,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.redirectInIframe],
+    },
+    blockTokenRequestsInHiddenIframeError: {
+        code: BrowserAuthErrorCodes.blockIframeReload,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.blockIframeReload],
+    },
+    blockAcquireTokenInPopupsError: {
+        code: BrowserAuthErrorCodes.blockNestedPopups,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.blockNestedPopups],
+    },
+    iframeClosedPrematurelyError: {
+        code: BrowserAuthErrorCodes.iframeClosedPrematurely,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.iframeClosedPrematurely
+        ],
+    },
+    silentLogoutUnsupportedError: {
+        code: BrowserAuthErrorCodes.silentLogoutUnsupported,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.silentLogoutUnsupported
+        ],
+    },
+    noAccountError: {
+        code: BrowserAuthErrorCodes.noAccountError,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.noAccountError],
+    },
+    silentPromptValueError: {
+        code: BrowserAuthErrorCodes.silentPromptValueError,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.silentPromptValueError
+        ],
+    },
+    noTokenRequestCacheError: {
+        code: BrowserAuthErrorCodes.noTokenRequestCacheError,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.noTokenRequestCacheError
+        ],
+    },
+    unableToParseTokenRequestCacheError: {
+        code: BrowserAuthErrorCodes.unableToParseTokenRequestCacheError,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.unableToParseTokenRequestCacheError
+        ],
+    },
+    noCachedAuthorityError: {
+        code: BrowserAuthErrorCodes.noCachedAuthorityError,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.noCachedAuthorityError
+        ],
+    },
+    authRequestNotSet: {
+        code: BrowserAuthErrorCodes.authRequestNotSetError,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.authRequestNotSetError
+        ],
+    },
+    invalidCacheType: {
+        code: BrowserAuthErrorCodes.invalidCacheType,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.invalidCacheType],
+    },
+    notInBrowserEnvironment: {
+        code: BrowserAuthErrorCodes.nonBrowserEnvironment,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.nonBrowserEnvironment
+        ],
+    },
+    databaseNotOpen: {
+        code: BrowserAuthErrorCodes.databaseNotOpen,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.databaseNotOpen],
+    },
+    noNetworkConnectivity: {
+        code: BrowserAuthErrorCodes.noNetworkConnectivity,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.noNetworkConnectivity
+        ],
+    },
+    postRequestFailed: {
+        code: BrowserAuthErrorCodes.postRequestFailed,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.postRequestFailed],
+    },
+    getRequestFailed: {
+        code: BrowserAuthErrorCodes.getRequestFailed,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.getRequestFailed],
+    },
+    failedToParseNetworkResponse: {
+        code: BrowserAuthErrorCodes.failedToParseResponse,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.failedToParseResponse
+        ],
+    },
+    unableToLoadTokenError: {
+        code: BrowserAuthErrorCodes.unableToLoadToken,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.unableToLoadToken],
+    },
+    signingKeyNotFoundInStorage: {
+        code: BrowserAuthErrorCodes.cryptoKeyNotFound,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.cryptoKeyNotFound],
+    },
+    authCodeRequired: {
+        code: BrowserAuthErrorCodes.authCodeRequired,
+        desc: BrowserAuthErrorMessages[BrowserAuthErrorCodes.authCodeRequired],
+    },
+    authCodeOrNativeAccountRequired: {
+        code: BrowserAuthErrorCodes.authCodeOrNativeAccountIdRequired,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.authCodeOrNativeAccountIdRequired
+        ],
+    },
+    spaCodeAndNativeAccountPresent: {
+        code: BrowserAuthErrorCodes.spaCodeAndNativeAccountIdPresent,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.spaCodeAndNativeAccountIdPresent
+        ],
+    },
+    databaseUnavailable: {
+        code: BrowserAuthErrorCodes.databaseUnavailable,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.databaseUnavailable
+        ],
+    },
+    unableToAcquireTokenFromNativePlatform: {
+        code: BrowserAuthErrorCodes.unableToAcquireTokenFromNativePlatform,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.unableToAcquireTokenFromNativePlatform
+        ],
+    },
+    nativeHandshakeTimeout: {
+        code: BrowserAuthErrorCodes.nativeHandshakeTimeout,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.nativeHandshakeTimeout
+        ],
+    },
+    nativeExtensionNotInstalled: {
+        code: BrowserAuthErrorCodes.nativeExtensionNotInstalled,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.nativeExtensionNotInstalled
+        ],
+    },
+    nativeConnectionNotEstablished: {
+        code: BrowserAuthErrorCodes.nativeConnectionNotEstablished,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.nativeConnectionNotEstablished
+        ],
+    },
+    uninitializedPublicClientApplication: {
+        code: BrowserAuthErrorCodes.uninitializedPublicClientApplication,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.uninitializedPublicClientApplication
+        ],
+    },
+    nativePromptNotSupported: {
+        code: BrowserAuthErrorCodes.nativePromptNotSupported,
+        desc: BrowserAuthErrorMessages[
+            BrowserAuthErrorCodes.nativePromptNotSupported
+        ],
+    },
+};
+
+/**
+ * Browser library error class thrown by the MSAL.js library for SPAs
+ */
+export class BrowserAuthError extends AuthError {
+    constructor(errorCode: string) {
+        super(errorCode, BrowserAuthErrorMessages[errorCode]);
+
+        Object.setPrototypeOf(this, BrowserAuthError.prototype);
+        this.name = "BrowserAuthError";
+    }
+}
+
+export function createBrowserAuthError(errorCode: string): BrowserAuthError {
+    return new BrowserAuthError(errorCode);
+}

package/src/error/BrowserAuthErrorCodes.ts

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export const pkceNotCreated = "pkce_not_created";
+export const cryptoNonExistent = "crypto_nonexistent";
+export const emptyNavigateUri = "empty_navigate_uri";
+export const hashEmptyError = "hash_empty_error";
+export const noStateInHash = "no_state_in_hash";
+export const hashDoesNotContainKnownProperties =
+    "hash_does_not_contain_known_properties";
+export const unableToParseState = "unable_to_parse_state";
+export const stateInteractionTypeMismatch = "state_interaction_type_mismatch";
+export const interactionInProgress = "interaction_in_progress";
+export const popupWindowError = "popup_window_error";
+export const emptyWindowError = "empty_window_error";
+export const userCancelled = "user_cancelled";
+export const monitorPopupTimeout = "monitor_popup_timeout";
+export const monitorWindowTimeout = "monitor_window_timeout";
+export const redirectInIframe = "redirect_in_iframe";
+export const blockIframeReload = "block_iframe_reload";
+export const blockNestedPopups = "block_nested_popups";
+export const iframeClosedPrematurely = "iframe_closed_prematurely";
+export const silentLogoutUnsupported = "silent_logout_unsupported";
+export const noAccountError = "no_account_error";
+export const silentPromptValueError = "silent_prompt_value_error";
+export const noTokenRequestCacheError = "no_token_request_cache_error";
+export const unableToParseTokenRequestCacheError =
+    "unable_to_parse_token_request_cache_error";
+export const noCachedAuthorityError = "no_cached_authority_error";
+export const authRequestNotSetError = "auth_request_not_set_error";
+export const invalidCacheType = "invalid_cache_type";
+export const nonBrowserEnvironment = "non_browser_environment";
+export const databaseNotOpen = "database_not_open";
+export const noNetworkConnectivity = "no_network_connectivity";
+export const postRequestFailed = "post_request_failed";
+export const getRequestFailed = "get_request_failed";
+export const failedToParseResponse = "failed_to_parse_response";
+export const unableToLoadToken = "unable_to_load_token";
+export const cryptoKeyNotFound = "crypto_key_not_found";
+export const authCodeRequired = "auth_code_required";
+export const authCodeOrNativeAccountIdRequired =
+    "auth_code_or_nativeAccountId_required";
+export const spaCodeAndNativeAccountIdPresent =
+    "spa_code_and_nativeAccountId_present";
+export const databaseUnavailable = "database_unavailable";
+export const unableToAcquireTokenFromNativePlatform =
+    "unable_to_acquire_token_from_native_platform";
+export const nativeHandshakeTimeout = "native_handshake_timeout";
+export const nativeExtensionNotInstalled = "native_extension_not_installed";
+export const nativeConnectionNotEstablished =
+    "native_connection_not_established";
+export const uninitializedPublicClientApplication =
+    "uninitialized_public_client_application";
+export const nativePromptNotSupported = "native_prompt_not_supported";

package/src/error/BrowserConfigurationAuthError.ts

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthError } from "@azure/msal-common";
+
+/**
+ * BrowserAuthErrorMessage class containing string constants used by error codes and messages.
+ */
+export const BrowserConfigurationAuthErrorMessage = {
+    redirectUriNotSet: {
+        code: "redirect_uri_empty",
+        desc: "A redirect URI is required for all calls, and none has been set.",
+    },
+    postLogoutUriNotSet: {
+        code: "post_logout_uri_empty",
+        desc: "A post logout redirect has not been set.",
+    },
+    storageNotSupportedError: {
+        code: "storage_not_supported",
+        desc: "Given storage configuration option was not supported.",
+    },
+    noRedirectCallbacksSet: {
+        code: "no_redirect_callbacks",
+        desc:
+            "No redirect callbacks have been set. Please call setRedirectCallbacks() with the appropriate function arguments before continuing. " +
+            "More information is available here: https://github.com/AzureAD/microsoft-authentication-library-for-js/wiki/MSAL-basics.",
+    },
+    invalidCallbackObject: {
+        code: "invalid_callback_object",
+        desc:
+            "The object passed for the callback was invalid. " +
+            "More information is available here: https://github.com/AzureAD/microsoft-authentication-library-for-js/wiki/MSAL-basics.",
+    },
+    stubPcaInstanceCalled: {
+        code: "stubbed_public_client_application_called",
+        desc: "Stub instance of Public Client Application was called. If using msal-react, please ensure context is not used without a provider. For more visit: aka.ms/msaljs/browser-errors",
+    },
+    inMemRedirectUnavailable: {
+        code: "in_mem_redirect_unavailable",
+        desc: "Redirect cannot be supported. In-memory storage was selected and storeAuthStateInCookie=false, which would cause the library to be unable to handle the incoming hash. If you would like to use the redirect API, please use session/localStorage or set storeAuthStateInCookie=true.",
+    },
+    entropyNotProvided: {
+        code: "entropy_not_provided",
+        desc: "The available browser crypto interface requires entropy set via system.cryptoOptions.entropy configuration option.",
+    },
+};
+
+/**
+ * Browser library error class thrown by the MSAL.js library for SPAs
+ */
+export class BrowserConfigurationAuthError extends AuthError {
+    constructor(errorCode: string, errorMessage?: string) {
+        super(errorCode, errorMessage);
+        this.name = "BrowserConfigurationAuthError";
+
+        Object.setPrototypeOf(this, BrowserConfigurationAuthError.prototype);
+    }
+
+    /**
+     * Creates an error thrown when the redirect uri is empty (not set by caller)
+     */
+    static createRedirectUriEmptyError(): BrowserConfigurationAuthError {
+        return new BrowserConfigurationAuthError(
+            BrowserConfigurationAuthErrorMessage.redirectUriNotSet.code,
+            BrowserConfigurationAuthErrorMessage.redirectUriNotSet.desc
+        );
+    }
+
+    /**
+     * Creates an error thrown when the post-logout redirect uri is empty (not set by caller)
+     */
+    static createPostLogoutRedirectUriEmptyError(): BrowserConfigurationAuthError {
+        return new BrowserConfigurationAuthError(
+            BrowserConfigurationAuthErrorMessage.postLogoutUriNotSet.code,
+            BrowserConfigurationAuthErrorMessage.postLogoutUriNotSet.desc
+        );
+    }
+
+    /**
+     * Creates error thrown when given storage location is not supported.
+     * @param givenStorageLocation
+     */
+    static createStorageNotSupportedError(
+        givenStorageLocation: string
+    ): BrowserConfigurationAuthError {
+        return new BrowserConfigurationAuthError(
+            BrowserConfigurationAuthErrorMessage.storageNotSupportedError.code,
+            `${BrowserConfigurationAuthErrorMessage.storageNotSupportedError.desc} Given Location: ${givenStorageLocation}`
+        );
+    }
+
+    /**
+     * Creates error thrown when redirect callbacks are not set before calling loginRedirect() or acquireTokenRedirect().
+     */
+    static createRedirectCallbacksNotSetError(): BrowserConfigurationAuthError {
+        return new BrowserConfigurationAuthError(
+            BrowserConfigurationAuthErrorMessage.noRedirectCallbacksSet.code,
+            BrowserConfigurationAuthErrorMessage.noRedirectCallbacksSet.desc
+        );
+    }
+
+    /**
+     * Creates error thrown when the stub instance of PublicClientApplication is called.
+     */
+    static createStubPcaInstanceCalledError(): BrowserConfigurationAuthError {
+        return new BrowserConfigurationAuthError(
+            BrowserConfigurationAuthErrorMessage.stubPcaInstanceCalled.code,
+            BrowserConfigurationAuthErrorMessage.stubPcaInstanceCalled.desc
+        );
+    }
+
+    /*
+     * Create an error thrown when in-memory storage is used and storeAuthStateInCookie=false.
+     */
+    static createInMemoryRedirectUnavailableError(): BrowserConfigurationAuthError {
+        return new BrowserConfigurationAuthError(
+            BrowserConfigurationAuthErrorMessage.inMemRedirectUnavailable.code,
+            BrowserConfigurationAuthErrorMessage.inMemRedirectUnavailable.desc
+        );
+    }
+
+    /**
+     * Creates an error thrown when a crypto interface that requires entropy is initialized without entropy
+     */
+    static createEntropyNotProvided(): BrowserConfigurationAuthError {
+        return new BrowserConfigurationAuthError(
+            BrowserConfigurationAuthErrorMessage.entropyNotProvided.code,
+            BrowserConfigurationAuthErrorMessage.entropyNotProvided.desc
+        );
+    }
+}