@azure/msal-browser 3.1.0 → 3.3.0

package/dist/crypto/CryptoOps.mjs

@@ -1,11 +1,9 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.3.0 2023-10-20 */
 'use strict';
 import { PerformanceEvents, JoseHeader } from '@azure/msal-common';
 import { base64Encode, urlEncode, urlEncodeArr } from '../encode/Base64Encode.mjs';
 import { base64Decode } from '../encode/Base64Decode.mjs';
-import { PkceGenerator } from './PkceGenerator.mjs';
-import { BrowserCrypto } from './BrowserCrypto.mjs';
-import { BrowserStringUtils } from '../utils/BrowserStringUtils.mjs';
+import { validateCryptoAvailable, createNewGuid, generateKeyPair, exportJwk, importJwk, sign, sha256Digest } from './BrowserCrypto.mjs';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
 import { CryptoKeyStore } from '../cache/CryptoKeyStore.mjs';
 import { cryptoKeyNotFound } from '../error/BrowserAuthErrorCodes.mjs';
@@ -22,8 +20,7 @@ class CryptoOps {
     constructor(logger, performanceClient) {
         this.logger = logger;
         // Browser crypto needs to be validated first before any other classes can be set.
-        this.browserCrypto = new BrowserCrypto(this.logger);
-        this.pkceGenerator = new PkceGenerator(this.browserCrypto);
+        validateCryptoAvailable(logger);
         this.cache = new CryptoKeyStore(this.logger);
         this.performanceClient = performanceClient;
     }
@@ -32,7 +29,7 @@ class CryptoOps {
      * @returns string (GUID)
      */
     createNewGuid() {
-        return window.crypto.randomUUID();
+        return createNewGuid();
     }
     /**
      * Encodes input string to base64.
@@ -48,12 +45,6 @@ class CryptoOps {
     base64Decode(input) {
         return base64Decode(input);
     }
-    /**
-     * Generates PKCE codes used in Authorization Code Flow.
-     */
-    async generatePkceCodes() {
-        return this.pkceGenerator.generateCodes();
-    }
     /**
      * Generates a keypair, stores it and returns a thumbprint
      * @param request
@@ -61,20 +52,20 @@ class CryptoOps {
     async getPublicKeyThumbprint(request) {
         const publicKeyThumbMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.CryptoOptsGetPublicKeyThumbprint, request.correlationId);
         // Generate Keypair
-        const keyPair = await this.browserCrypto.generateKeyPair(CryptoOps.EXTRACTABLE, CryptoOps.POP_KEY_USAGES);
+        const keyPair = await generateKeyPair(CryptoOps.EXTRACTABLE, CryptoOps.POP_KEY_USAGES);
         // Generate Thumbprint for Public Key
-        const publicKeyJwk = await this.browserCrypto.exportJwk(keyPair.publicKey);
+        const publicKeyJwk = await exportJwk(keyPair.publicKey);
         const pubKeyThumprintObj = {
             e: publicKeyJwk.e,
             kty: publicKeyJwk.kty,
             n: publicKeyJwk.n,
         };
-        const publicJwkString = BrowserStringUtils.getSortedObjectString(pubKeyThumprintObj);
+        const publicJwkString = getSortedObjectString(pubKeyThumprintObj);
         const publicJwkHash = await this.hashString(publicJwkString);
         // Generate Thumbprint for Private Key
-        const privateKeyJwk = await this.browserCrypto.exportJwk(keyPair.privateKey);
+        const privateKeyJwk = await exportJwk(keyPair.privateKey);
         // Re-import private key to make it unextractable
-        const unextractablePrivateKey = await this.browserCrypto.importJwk(privateKeyJwk, false, ["sign"]);
+        const unextractablePrivateKey = await importJwk(privateKeyJwk, false, ["sign"]);
         // Store Keypair data in keystore
         await this.cache.asymmetricKeys.setItem(publicJwkHash, {
             privateKey: unextractablePrivateKey,
@@ -116,8 +107,8 @@ class CryptoOps {
             throw createBrowserAuthError(cryptoKeyNotFound);
         }
         // Get public key as JWK
-        const publicKeyJwk = await this.browserCrypto.exportJwk(cachedKeyPair.publicKey);
-        const publicKeyJwkString = BrowserStringUtils.getSortedObjectString(publicKeyJwk);
+        const publicKeyJwk = await exportJwk(cachedKeyPair.publicKey);
+        const publicKeyJwkString = getSortedObjectString(publicKeyJwk);
         // Base64URL encode public key thumbprint with keyId only: BASE64URL({ kid: "FULL_PUBLIC_KEY_HASH" })
         const encodedKeyIdThumbprint = urlEncode(JSON.stringify({ kid: kid }));
         // Generate header
@@ -134,8 +125,9 @@ class CryptoOps {
         // Form token string
         const tokenString = `${encodedShrHeader}.${encodedPayload}`;
         // Sign token
-        const tokenBuffer = BrowserStringUtils.stringToUtf8Arr(tokenString);
-        const signatureBuffer = await this.browserCrypto.sign(cachedKeyPair.privateKey, tokenBuffer);
+        const encoder = new TextEncoder();
+        const tokenBuffer = encoder.encode(tokenString);
+        const signatureBuffer = await sign(cachedKeyPair.privateKey, tokenBuffer);
         const encodedSignature = urlEncodeArr(new Uint8Array(signatureBuffer));
         const signedJwt = `${tokenString}.${encodedSignature}`;
         if (signJwtMeasurement) {
@@ -150,13 +142,16 @@ class CryptoOps {
      * @param plainText
      */
     async hashString(plainText) {
-        const hashBuffer = await this.browserCrypto.sha256Digest(plainText);
+        const hashBuffer = await sha256Digest(plainText);
         const hashBytes = new Uint8Array(hashBuffer);
         return urlEncodeArr(hashBytes);
     }
 }
 CryptoOps.POP_KEY_USAGES = ["sign", "verify"];
 CryptoOps.EXTRACTABLE = true;
+function getSortedObjectString(obj) {
+    return JSON.stringify(obj, Object.keys(obj).sort());
+}
 
 export { CryptoOps };
 //# sourceMappingURL=CryptoOps.mjs.map

package/dist/crypto/CryptoOps.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"CryptoOps.mjs","sources":["../../src/crypto/CryptoOps.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;AAKA;AAqBA;;;;;;AAgBI;;;AAGG,QAAA,IAAA,CAAA,MAAA,GAAA,MAAA,CAAA;;AAGH,QAAA,IAAQ,CAAA,aAAO,GAAA,IAAc,aAAuC,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;AACpE,QAAA,IAAQ,CAAA,aAAO,GAAA,IAA4B,aAAA,CAAA,IAAA,CAAA,aAAA,CAAA,CAAA;QACpC,IAAC,MAAsB,GAAA,IAAA,cAAA,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;AAElB,QAAA,IAAA,CAAA,iBAAc,GAAmB,iBAAC;AAS9C,KAAA;;;AAGG;AACH;AAIA,IAAA,aAAA,GAAA;;;AAGG;AACH;AAIA;;;AAGG,QAAA,OAAA,YAAA,CAAA,KAAA,CAAA,CAAA;AACH,KAAA;AAIA;;AAEG;AACG;AAIN,IAAA,YAAA,CAAA,KAAA,EAAA;;;AAGG;;AAwDH;;;AAGG,KAAA;;AAOH;;AAEG;AACG,IAAA,MAAA,sBAAyB,CAAA,OAAQ,EAAA;AAIvC,QAAA,MAAA,yBAAA,GAAA,IAAA,CAAA,iBAAA,EAAA,gBAAA,CAAA,iBAAA,CAAA,gCAAA,EAAA,OAAA,CAAA,aAAA,CAAA,CAAA;;;;AAIG,QAAA,MAAA,YAAA,GAAA,MAAA,IAAA,CAAA,aAAA,CAAA,SAAA,CAAA,OAAA,CAAA,SAAA,CAAA,CAAA;AACG,QAAA,MACK,kBAAmB,GAAA;AA6D9B,YAAA,CAAA,EAAA,YAAA,CAAA,CAAA;;;AAGG,SAAA,CAAA;QACa,MAAA,eAAY,GAAM,kBAAkB,CAAA,qBAAA,CAAA,kBAAA,CAAA,CAAA;AAOvD,QAAA,MAAA,aAAA,GAAA,MAAA,IAAA,CAAA,UAAA,CAAA,eAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"CryptoOps.mjs","sources":["../../src/crypto/CryptoOps.ts"],"sourcesContent":[null],"names":["BrowserCrypto.validateCryptoAvailable","BrowserCrypto.createNewGuid","BrowserCrypto.generateKeyPair","BrowserCrypto.exportJwk"],"mappings":";;;;;;;;;;AAKA;AAkBA;;;AAUG;AACH;;AAGI;;;AAGG,QAAA,IAAA,CAAA,MAAA,GAAA,MAAA,CAAA;;AAGH,QAAAA,uBAAoE,CAAA,MAAA,CAAA,CAAA;AACpE,QAAA,IAAQ,CAAA,KAAM,GAAC,IAAA,cAA4B,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;QACpC,IAAC,kBAAsB,GAAA,iBAAA,CAAA;AAElB,KAAA;AAQZ;;;AAGG;AACH,IAAA,aAAa;AAIb,QAAA,OAAAC,aAAA,EAAA,CAAA;;;AAGG;AACH;AAIA;;;AAGG,KAAA;AACH;AAIA;;;AAGG,IAAA,YAAA,CAAA,KAAA,EAAA;QACyB,OAAA,YACxB,OAAO,CAAE;AAsDb,KAAA;;;AAGG;;AAOH,IAAA,MAAA,sBAAA,CAAA,OAAA,EAAA;;AAEG;AACG,QAAA,MAAA,OAAiB,GAAA,MAAQC,eAAQ,CAAA,SAAA,CAAA,WAAA,EAAA,SAAA,CAAA,cAAA,CAAA,CAAA;AAIvC;;;;AAIG,YAAA,GAAA,EAAA,YAAA,CAAA,GAAA;AACG,YACF,CAAO,EAAA,YAAmB,CAAA,CAAA;AA6D9B,SAAA,CAAA;;;AAGG;QACa,MAAA,aAAY,GAAA,MAAgBC,SAAQ,CAAA,OAAA,CAAA,UAAA,CAAA,CAAA;AAOvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/crypto/PkceGenerator.d.ts

@@ -1,24 +1,9 @@
-import { PkceCodes } from "@azure/msal-common";
-import { BrowserCrypto } from "./BrowserCrypto";
+import { IPerformanceClient, Logger, PkceCodes } from "@azure/msal-common";
 /**
- * Class which exposes APIs to generate PKCE codes and code verifiers.
+ * This file defines APIs to generate PKCE codes and code verifiers.
  */
-export declare class PkceGenerator {
-    private cryptoObj;
-    constructor(cryptoObj: BrowserCrypto);
-    /**
-     * Generates PKCE Codes. See the RFC for more information: https://tools.ietf.org/html/rfc7636
-     */
-    generateCodes(): Promise<PkceCodes>;
-    /**
-     * Generates a random 32 byte buffer and returns the base64
-     * encoded string to be used as a PKCE Code Verifier
-     */
-    private generateCodeVerifier;
-    /**
-     * Creates a base64 encoded PKCE Code Challenge string from the
-     * hash created from the PKCE Code Verifier supplied
-     */
-    private generateCodeChallengeFromVerifier;
-}
+/**
+ * Generates PKCE Codes. See the RFC for more information: https://tools.ietf.org/html/rfc7636
+ */
+export declare function generatePkceCodes(performanceClient: IPerformanceClient, logger: Logger, correlationId: string): Promise<PkceCodes>;
 //# sourceMappingURL=PkceGenerator.d.ts.map

package/dist/crypto/PkceGenerator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PkceGenerator.d.ts","sourceRoot":"","sources":["../../src/crypto/PkceGenerator.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAM/C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKhD;;GAEG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,SAAS,CAAgB;gBAErB,SAAS,EAAE,aAAa;IAIpC;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,SAAS,CAAC;IAWzC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAa5B;;;OAGG;YACW,iCAAiC;CAclD"}
+{"version":3,"file":"PkceGenerator.d.ts","sourceRoot":"","sources":["../../src/crypto/PkceGenerator.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,kBAAkB,EAClB,MAAM,EAEN,SAAS,EAGZ,MAAM,oBAAoB,CAAC;AAW5B;;GAEG;AAEH;;GAEG;AACH,wBAAsB,iBAAiB,CACnC,iBAAiB,EAAE,kBAAkB,EACrC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,GACtB,OAAO,CAAC,SAAS,CAAC,CAuBpB"}

package/dist/crypto/PkceGenerator.mjs

@@ -1,7 +1,9 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.3.0 2023-10-20 */
 'use strict';
+import { PerformanceEvents, invoke, invokeAsync } from '@azure/msal-common';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
 import { urlEncodeArr } from '../encode/Base64Encode.mjs';
+import { getRandomValues, sha256Digest } from './BrowserCrypto.mjs';
 import { pkceNotCreated } from '../error/BrowserAuthErrorCodes.mjs';
 
 /*
@@ -11,56 +13,53 @@ import { pkceNotCreated } from '../error/BrowserAuthErrorCodes.mjs';
 // Constant byte array length
 const RANDOM_BYTE_ARR_LENGTH = 32;
 /**
- * Class which exposes APIs to generate PKCE codes and code verifiers.
+ * This file defines APIs to generate PKCE codes and code verifiers.
  */
-class PkceGenerator {
-    constructor(cryptoObj) {
-        this.cryptoObj = cryptoObj;
+/**
+ * Generates PKCE Codes. See the RFC for more information: https://tools.ietf.org/html/rfc7636
+ */
+async function generatePkceCodes(performanceClient, logger, correlationId) {
+    performanceClient.addQueueMeasurement(PerformanceEvents.GeneratePkceCodes, correlationId);
+    const codeVerifier = invoke(generateCodeVerifier, PerformanceEvents.GenerateCodeVerifier, logger, performanceClient, correlationId)(performanceClient, logger, correlationId);
+    const codeChallenge = await invokeAsync(generateCodeChallengeFromVerifier, PerformanceEvents.GenerateCodeChallengeFromVerifier, logger, performanceClient, correlationId)(codeVerifier, performanceClient, logger, correlationId);
+    return {
+        verifier: codeVerifier,
+        challenge: codeChallenge,
+    };
+}
+/**
+ * Generates a random 32 byte buffer and returns the base64
+ * encoded string to be used as a PKCE Code Verifier
+ */
+function generateCodeVerifier(performanceClient, logger, correlationId) {
+    try {
+        // Generate random values as utf-8
+        const buffer = new Uint8Array(RANDOM_BYTE_ARR_LENGTH);
+        invoke(getRandomValues, PerformanceEvents.GetRandomValues, logger, performanceClient, correlationId)(buffer);
+        // encode verifier as base64
+        const pkceCodeVerifierB64 = urlEncodeArr(buffer);
+        return pkceCodeVerifierB64;
     }
-    /**
-     * Generates PKCE Codes. See the RFC for more information: https://tools.ietf.org/html/rfc7636
-     */
-    async generateCodes() {
-        const codeVerifier = this.generateCodeVerifier();
-        const codeChallenge = await this.generateCodeChallengeFromVerifier(codeVerifier);
-        return {
-            verifier: codeVerifier,
-            challenge: codeChallenge,
-        };
+    catch (e) {
+        throw createBrowserAuthError(pkceNotCreated);
     }
-    /**
-     * Generates a random 32 byte buffer and returns the base64
-     * encoded string to be used as a PKCE Code Verifier
-     */
-    generateCodeVerifier() {
-        try {
-            // Generate random values as utf-8
-            const buffer = new Uint8Array(RANDOM_BYTE_ARR_LENGTH);
-            this.cryptoObj.getRandomValues(buffer);
-            // encode verifier as base64
-            const pkceCodeVerifierB64 = urlEncodeArr(buffer);
-            return pkceCodeVerifierB64;
-        }
-        catch (e) {
-            throw createBrowserAuthError(pkceNotCreated);
-        }
+}
+/**
+ * Creates a base64 encoded PKCE Code Challenge string from the
+ * hash created from the PKCE Code Verifier supplied
+ */
+async function generateCodeChallengeFromVerifier(pkceCodeVerifier, performanceClient, logger, correlationId) {
+    performanceClient.addQueueMeasurement(PerformanceEvents.GenerateCodeChallengeFromVerifier, correlationId);
+    try {
+        // hashed verifier
+        const pkceHashedCodeVerifier = await invokeAsync(sha256Digest, PerformanceEvents.Sha256Digest, logger, performanceClient, correlationId)(pkceCodeVerifier, performanceClient, correlationId);
+        // encode hash as base64
+        return urlEncodeArr(new Uint8Array(pkceHashedCodeVerifier));
     }
-    /**
-     * Creates a base64 encoded PKCE Code Challenge string from the
-     * hash created from the PKCE Code Verifier supplied
-     */
-    async generateCodeChallengeFromVerifier(pkceCodeVerifier) {
-        try {
-            // hashed verifier
-            const pkceHashedCodeVerifier = await this.cryptoObj.sha256Digest(pkceCodeVerifier);
-            // encode hash as base64
-            return urlEncodeArr(new Uint8Array(pkceHashedCodeVerifier));
-        }
-        catch (e) {
-            throw createBrowserAuthError(pkceNotCreated);
-        }
+    catch (e) {
+        throw createBrowserAuthError(pkceNotCreated);
     }
 }
 
-export { PkceGenerator };
+export { generatePkceCodes };
 //# sourceMappingURL=PkceGenerator.mjs.map

package/dist/crypto/PkceGenerator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"PkceGenerator.mjs","sources":["../../src/crypto/PkceGenerator.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAKA;AAMA;AAKA;;;AAMgB,MAAA,sBAAwB,GAAA,EAAA,CAAA;AAIpC;;AAEG;AACG,MAAA,aAAiB,CAAA;AAWvB,IAAA,WAAA,CAAA,SAAA,EAAA;;;AAGG;AACH;AAaA;;;AAGG,QAAA,MAAA,aAAA,GAAA,MAAA,IAAA,CAAA,iCAAA,CAAA,YAAA,CAAA,CAAA;eAC4C;AAclD,YAAA,QAAA,EAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"PkceGenerator.mjs","sources":["../../src/crypto/PkceGenerator.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;AAKA;AAkBA;;AAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/crypto/SignedHttpRequest.mjs

@@ -1,4 +1,4 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.3.0 2023-10-20 */
 'use strict';
 import { CryptoOps } from './CryptoOps.mjs';
 import { Logger, PopTokenGenerator } from '@azure/msal-common';

package/dist/encode/Base64Decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Base64Decode.d.ts","sourceRoot":"","sources":["../../src/encode/Base64Decode.ts"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD"}
+{"version":3,"file":"Base64Decode.d.ts","sourceRoot":"","sources":["../../src/encode/Base64Decode.ts"],"names":[],"mappings":"AAUA;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD"}

package/dist/encode/Base64Decode.mjs

@@ -1,5 +1,8 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.3.0 2023-10-20 */
 'use strict';
+import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
+import { invalidBase64String } from '../error/BrowserAuthErrorCodes.mjs';
+
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
@@ -20,7 +23,20 @@ function base64Decode(input) {
  * @param base64String
  */
 function base64DecToArr(base64String) {
-    const binString = atob(base64String);
+    let encodedString = base64String.replace(/-/g, "+").replace(/_/g, "/");
+    switch (encodedString.length % 4) {
+        case 0:
+            break;
+        case 2:
+            encodedString += "==";
+            break;
+        case 3:
+            encodedString += "=";
+            break;
+        default:
+            throw createBrowserAuthError(invalidBase64String);
+    }
+    const binString = atob(encodedString);
     return Uint8Array.from(binString, (m) => m.codePointAt(0) || 0);
 }
 

package/dist/encode/Base64Decode.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Base64Decode.mjs","sources":["../../src/encode/Base64Decode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;AAGG;AAEH;;;AAGG;AACH;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"Base64Decode.mjs","sources":["../../src/encode/Base64Decode.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;AAGG;;;AAKA;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/encode/Base64Encode.mjs

@@ -1,4 +1,4 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.3.0 2023-10-20 */
 'use strict';
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.

package/dist/error/BrowserAuthError.d.ts

@@ -49,10 +49,15 @@ export declare const BrowserAuthErrorMessages: {
     native_connection_not_established: string;
     uninitialized_public_client_application: string;
     native_prompt_not_supported: string;
+    invalid_base64_string: string;
 };
 /**
  * BrowserAuthErrorMessage class containing string constants used by error codes and messages.
- * @deprecated Use BrowserAuthBrowserAuthErrorCodes instead
+ * @deprecated Use exported BrowserAuthErrorCodes instead.
+ * In your app you can do :
+ * ```
+ * import { BrowserAuthErrorCodes } from "@azure/msal-browser";
+ * ```
  */
 export declare const BrowserAuthErrorMessage: {
     pkceNotGenerated: {
@@ -231,6 +236,10 @@ export declare const BrowserAuthErrorMessage: {
         code: string;
         desc: string;
     };
+    invalidBase64StringError: {
+        code: string;
+        desc: string;
+    };
 };
 /**
  * Browser library error class thrown by the MSAL.js library for SPAs

package/dist/error/BrowserAuthError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BrowserAuthError.d.ts","sourceRoot":"","sources":["../../src/error/BrowserAuthError.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,KAAK,qBAAqB,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,CAAC;AAIjC;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4EpC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmOnC,CAAC;AAEF;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;gBAC/B,SAAS,EAAE,MAAM;CAMhC;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAE1E"}
+{"version":3,"file":"BrowserAuthError.d.ts","sourceRoot":"","sources":["../../src/error/BrowserAuthError.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,KAAK,qBAAqB,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,CAAC;AAIjC;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EpC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyOnC,CAAC;AAEF;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;gBAC/B,SAAS,EAAE,MAAM;CAMhC;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAE1E"}

package/dist/error/BrowserAuthError.mjs

@@ -1,7 +1,7 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.3.0 2023-10-20 */
 'use strict';
 import { AuthError } from '@azure/msal-common';
-import { pkceNotCreated, cryptoNonExistent, emptyNavigateUri, hashEmptyError, noStateInHash, hashDoesNotContainKnownProperties, unableToParseState, stateInteractionTypeMismatch, interactionInProgress, popupWindowError, emptyWindowError, userCancelled, monitorPopupTimeout, monitorWindowTimeout, redirectInIframe, blockIframeReload, blockNestedPopups, iframeClosedPrematurely, silentLogoutUnsupported, noAccountError, silentPromptValueError, noTokenRequestCacheError, unableToParseTokenRequestCacheError, noCachedAuthorityError, authRequestNotSetError, invalidCacheType, nonBrowserEnvironment, databaseNotOpen, noNetworkConnectivity, postRequestFailed, getRequestFailed, failedToParseResponse, unableToLoadToken, cryptoKeyNotFound, authCodeRequired, authCodeOrNativeAccountIdRequired, spaCodeAndNativeAccountIdPresent, databaseUnavailable, unableToAcquireTokenFromNativePlatform, nativeHandshakeTimeout, nativeExtensionNotInstalled, nativeConnectionNotEstablished, uninitializedPublicClientApplication, nativePromptNotSupported } from './BrowserAuthErrorCodes.mjs';
+import { pkceNotCreated, cryptoNonExistent, emptyNavigateUri, hashEmptyError, noStateInHash, hashDoesNotContainKnownProperties, unableToParseState, stateInteractionTypeMismatch, interactionInProgress, popupWindowError, emptyWindowError, userCancelled, monitorPopupTimeout, monitorWindowTimeout, redirectInIframe, blockIframeReload, blockNestedPopups, iframeClosedPrematurely, silentLogoutUnsupported, noAccountError, silentPromptValueError, noTokenRequestCacheError, unableToParseTokenRequestCacheError, noCachedAuthorityError, authRequestNotSetError, invalidCacheType, nonBrowserEnvironment, databaseNotOpen, noNetworkConnectivity, postRequestFailed, getRequestFailed, failedToParseResponse, unableToLoadToken, cryptoKeyNotFound, authCodeRequired, authCodeOrNativeAccountIdRequired, spaCodeAndNativeAccountIdPresent, databaseUnavailable, unableToAcquireTokenFromNativePlatform, nativeHandshakeTimeout, nativeExtensionNotInstalled, nativeConnectionNotEstablished, uninitializedPublicClientApplication, nativePromptNotSupported, invalidBase64String } from './BrowserAuthErrorCodes.mjs';
 import * as BrowserAuthErrorCodes from './BrowserAuthErrorCodes.mjs';
 export { BrowserAuthErrorCodes };
 
@@ -58,10 +58,15 @@ const BrowserAuthErrorMessages = {
     [nativeConnectionNotEstablished]: `Connection to native platform has not been established. Please install a compatible browser extension and run initialize().  ${ErrorLink}`,
     [uninitializedPublicClientApplication]: `You must call and await the initialize function before attempting to call any other MSAL API.  ${ErrorLink}`,
     [nativePromptNotSupported]: "The provided prompt is not supported by the native platform. This request should be routed to the web based flow.",
+    [invalidBase64String]: "Invalid base64 encoded string.",
 };
 /**
  * BrowserAuthErrorMessage class containing string constants used by error codes and messages.
- * @deprecated Use BrowserAuthBrowserAuthErrorCodes instead
+ * @deprecated Use exported BrowserAuthErrorCodes instead.
+ * In your app you can do :
+ * ```
+ * import { BrowserAuthErrorCodes } from "@azure/msal-browser";
+ * ```
  */
 const BrowserAuthErrorMessage = {
     pkceNotGenerated: {
@@ -240,6 +245,10 @@ const BrowserAuthErrorMessage = {
         code: nativePromptNotSupported,
         desc: BrowserAuthErrorMessages[nativePromptNotSupported],
     },
+    invalidBase64StringError: {
+        code: invalidBase64String,
+        desc: BrowserAuthErrorMessages[invalidBase64String],
+    },
 };
 /**
  * Browser library error class thrown by the MSAL.js library for SPAs

package/dist/error/BrowserAuthError.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"BrowserAuthError.mjs","sources":["../../src/error/BrowserAuthError.ts"],"sourcesContent":[null],"names":["BrowserAuthErrorCodes.nativeHandshakeTimeout","BrowserAuthErrorCodes.nativeExtensionNotInstalled","BrowserAuthErrorCodes.nativePromptNotSupported"],"mappings":";;;;;;;AAKA;AACA;AACA;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+EE,CAAAA,sBAAA,GAAA,yEAAA;AAEF,IAAA,CAAAC,2BAAA,GAAA,iGAAA;;;AAGG,IAAA,CAAAC,wBAAA,GAAA,mHAAA;AACH,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmOE;AAEF,IAAA,wBAAA,EAAA;;AAEG,QAAA,IAAA,EAAA,wBAAA,CAAAA,wBAAA,CAAA;AACH,KAAa;AACG,EAAA;AAMf;AAED;;;;;;;;;;;;;;;"}
+{"version":3,"file":"BrowserAuthError.mjs","sources":["../../src/error/BrowserAuthError.ts"],"sourcesContent":[null],"names":["BrowserAuthErrorCodes.nativeExtensionNotInstalled","BrowserAuthErrorCodes.nativeConnectionNotEstablished","BrowserAuthErrorCodes.invalidBase64String"],"mappings":";;;;;;;AAKA;AACA;AACA;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiFE,CAAAA,2BAAA,GAAA,iGAAA;AAEF,IAAA,CAAAC,8BAAA,GAAA,CAAA,6HAAA,EAAA,SAAA,CAAA,CAAA;;;;;;;AAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAyOE;AAEF,IAAA,wBAAA,EAAA;;AAEG,QAAA,IAAA,EAAA,wBAAA,CAAAC,mBAAA,CAAA;AACH,KAAa;AACG,EAAA;AAMf;AAED;;;;;;;;;;;;;;;"}

package/dist/error/BrowserAuthErrorCodes.d.ts

@@ -42,4 +42,5 @@ export declare const nativeExtensionNotInstalled = "native_extension_not_install
 export declare const nativeConnectionNotEstablished = "native_connection_not_established";
 export declare const uninitializedPublicClientApplication = "uninitialized_public_client_application";
 export declare const nativePromptNotSupported = "native_prompt_not_supported";
+export declare const invalidBase64String = "invalid_base64_string";
 //# sourceMappingURL=BrowserAuthErrorCodes.d.ts.map

package/dist/error/BrowserAuthErrorCodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BrowserAuthErrorCodes.d.ts","sourceRoot":"","sources":["../../src/error/BrowserAuthErrorCodes.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,cAAc,qBAAqB,CAAC;AACjD,eAAO,MAAM,iBAAiB,uBAAuB,CAAC;AACtD,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,cAAc,qBAAqB,CAAC;AACjD,eAAO,MAAM,aAAa,qBAAqB,CAAC;AAChD,eAAO,MAAM,iCAAiC,2CACF,CAAC;AAC7C,eAAO,MAAM,kBAAkB,0BAA0B,CAAC;AAC1D,eAAO,MAAM,4BAA4B,oCAAoC,CAAC;AAC9E,eAAO,MAAM,qBAAqB,4BAA4B,CAAC;AAC/D,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,aAAa,mBAAmB,CAAC;AAC9C,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAC3D,eAAO,MAAM,oBAAoB,2BAA2B,CAAC;AAC7D,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,iBAAiB,wBAAwB,CAAC;AACvD,eAAO,MAAM,iBAAiB,wBAAwB,CAAC;AACvD,eAAO,MAAM,uBAAuB,8BAA8B,CAAC;AACnE,eAAO,MAAM,uBAAuB,8BAA8B,CAAC;AACnE,eAAO,MAAM,cAAc,qBAAqB,CAAC;AACjD,eAAO,MAAM,sBAAsB,8BAA8B,CAAC;AAClE,eAAO,MAAM,wBAAwB,iCAAiC,CAAC;AACvE,eAAO,MAAM,mCAAmC,8CACD,CAAC;AAChD,eAAO,MAAM,sBAAsB,8BAA8B,CAAC;AAClE,eAAO,MAAM,sBAAsB,+BAA+B,CAAC;AACnE,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,qBAAqB,4BAA4B,CAAC;AAC/D,eAAO,MAAM,eAAe,sBAAsB,CAAC;AACnD,eAAO,MAAM,qBAAqB,4BAA4B,CAAC;AAC/D,eAAO,MAAM,iBAAiB,wBAAwB,CAAC;AACvD,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,qBAAqB,6BAA6B,CAAC;AAChE,eAAO,MAAM,iBAAiB,yBAAyB,CAAC;AACxD,eAAO,MAAM,iBAAiB,yBAAyB,CAAC;AACxD,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,iCAAiC,0CACH,CAAC;AAC5C,eAAO,MAAM,gCAAgC,yCACH,CAAC;AAC3C,eAAO,MAAM,mBAAmB,yBAAyB,CAAC;AAC1D,eAAO,MAAM,sCAAsC,iDACD,CAAC;AACnD,eAAO,MAAM,sBAAsB,6BAA6B,CAAC;AACjE,eAAO,MAAM,2BAA2B,mCAAmC,CAAC;AAC5E,eAAO,MAAM,8BAA8B,sCACJ,CAAC;AACxC,eAAO,MAAM,oCAAoC,4CACJ,CAAC;AAC9C,eAAO,MAAM,wBAAwB,gCAAgC,CAAC"}
+{"version":3,"file":"BrowserAuthErrorCodes.d.ts","sourceRoot":"","sources":["../../src/error/BrowserAuthErrorCodes.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,cAAc,qBAAqB,CAAC;AACjD,eAAO,MAAM,iBAAiB,uBAAuB,CAAC;AACtD,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,cAAc,qBAAqB,CAAC;AACjD,eAAO,MAAM,aAAa,qBAAqB,CAAC;AAChD,eAAO,MAAM,iCAAiC,2CACF,CAAC;AAC7C,eAAO,MAAM,kBAAkB,0BAA0B,CAAC;AAC1D,eAAO,MAAM,4BAA4B,oCAAoC,CAAC;AAC9E,eAAO,MAAM,qBAAqB,4BAA4B,CAAC;AAC/D,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,aAAa,mBAAmB,CAAC;AAC9C,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAC3D,eAAO,MAAM,oBAAoB,2BAA2B,CAAC;AAC7D,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,iBAAiB,wBAAwB,CAAC;AACvD,eAAO,MAAM,iBAAiB,wBAAwB,CAAC;AACvD,eAAO,MAAM,uBAAuB,8BAA8B,CAAC;AACnE,eAAO,MAAM,uBAAuB,8BAA8B,CAAC;AACnE,eAAO,MAAM,cAAc,qBAAqB,CAAC;AACjD,eAAO,MAAM,sBAAsB,8BAA8B,CAAC;AAClE,eAAO,MAAM,wBAAwB,iCAAiC,CAAC;AACvE,eAAO,MAAM,mCAAmC,8CACD,CAAC;AAChD,eAAO,MAAM,sBAAsB,8BAA8B,CAAC;AAClE,eAAO,MAAM,sBAAsB,+BAA+B,CAAC;AACnE,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,qBAAqB,4BAA4B,CAAC;AAC/D,eAAO,MAAM,eAAe,sBAAsB,CAAC;AACnD,eAAO,MAAM,qBAAqB,4BAA4B,CAAC;AAC/D,eAAO,MAAM,iBAAiB,wBAAwB,CAAC;AACvD,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,qBAAqB,6BAA6B,CAAC;AAChE,eAAO,MAAM,iBAAiB,yBAAyB,CAAC;AACxD,eAAO,MAAM,iBAAiB,yBAAyB,CAAC;AACxD,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AACrD,eAAO,MAAM,iCAAiC,0CACH,CAAC;AAC5C,eAAO,MAAM,gCAAgC,yCACH,CAAC;AAC3C,eAAO,MAAM,mBAAmB,yBAAyB,CAAC;AAC1D,eAAO,MAAM,sCAAsC,iDACD,CAAC;AACnD,eAAO,MAAM,sBAAsB,6BAA6B,CAAC;AACjE,eAAO,MAAM,2BAA2B,mCAAmC,CAAC;AAC5E,eAAO,MAAM,8BAA8B,sCACJ,CAAC;AACxC,eAAO,MAAM,oCAAoC,4CACJ,CAAC;AAC9C,eAAO,MAAM,wBAAwB,gCAAgC,CAAC;AACtE,eAAO,MAAM,mBAAmB,0BAA0B,CAAC"}

package/dist/error/BrowserAuthErrorCodes.mjs

@@ -1,4 +1,4 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.3.0 2023-10-20 */
 'use strict';
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -48,6 +48,7 @@ const nativeExtensionNotInstalled = "native_extension_not_installed";
 const nativeConnectionNotEstablished = "native_connection_not_established";
 const uninitializedPublicClientApplication = "uninitialized_public_client_application";
 const nativePromptNotSupported = "native_prompt_not_supported";
+const invalidBase64String = "invalid_base64_string";
 
-export { authCodeOrNativeAccountIdRequired, authCodeRequired, authRequestNotSetError, blockIframeReload, blockNestedPopups, cryptoKeyNotFound, cryptoNonExistent, databaseNotOpen, databaseUnavailable, emptyNavigateUri, emptyWindowError, failedToParseResponse, getRequestFailed, hashDoesNotContainKnownProperties, hashEmptyError, iframeClosedPrematurely, interactionInProgress, invalidCacheType, monitorPopupTimeout, monitorWindowTimeout, nativeConnectionNotEstablished, nativeExtensionNotInstalled, nativeHandshakeTimeout, nativePromptNotSupported, noAccountError, noCachedAuthorityError, noNetworkConnectivity, noStateInHash, noTokenRequestCacheError, nonBrowserEnvironment, pkceNotCreated, popupWindowError, postRequestFailed, redirectInIframe, silentLogoutUnsupported, silentPromptValueError, spaCodeAndNativeAccountIdPresent, stateInteractionTypeMismatch, unableToAcquireTokenFromNativePlatform, unableToLoadToken, unableToParseState, unableToParseTokenRequestCacheError, uninitializedPublicClientApplication, userCancelled };
+export { authCodeOrNativeAccountIdRequired, authCodeRequired, authRequestNotSetError, blockIframeReload, blockNestedPopups, cryptoKeyNotFound, cryptoNonExistent, databaseNotOpen, databaseUnavailable, emptyNavigateUri, emptyWindowError, failedToParseResponse, getRequestFailed, hashDoesNotContainKnownProperties, hashEmptyError, iframeClosedPrematurely, interactionInProgress, invalidBase64String, invalidCacheType, monitorPopupTimeout, monitorWindowTimeout, nativeConnectionNotEstablished, nativeExtensionNotInstalled, nativeHandshakeTimeout, nativePromptNotSupported, noAccountError, noCachedAuthorityError, noNetworkConnectivity, noStateInHash, noTokenRequestCacheError, nonBrowserEnvironment, pkceNotCreated, popupWindowError, postRequestFailed, redirectInIframe, silentLogoutUnsupported, silentPromptValueError, spaCodeAndNativeAccountIdPresent, stateInteractionTypeMismatch, unableToAcquireTokenFromNativePlatform, unableToLoadToken, unableToParseState, unableToParseTokenRequestCacheError, uninitializedPublicClientApplication, userCancelled };
 //# sourceMappingURL=BrowserAuthErrorCodes.mjs.map

package/dist/error/BrowserAuthErrorCodes.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"BrowserAuthErrorCodes.mjs","sources":["../../src/error/BrowserAuthErrorCodes.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;AACA;AACA;AACA;AACO,MAAA,cAAmB,GAAA,mBAAA;AACnB,MAAA,iBAAuC,GAAA,qBAAA;AAEvC,MAAA,gBAAwB,GAAA,qBAAA;AACxB,MAAA,cAAkC,GAAA,mBAAA;AAClC,MAAA,aAA2B,GAAA,mBAAA;AAC3B,MAAA,iCAAsB,GAAA,yCAAwB;AAC9C,MAAA,kBAAsB,GAAA,wBAAA;AACtB,MAAA,4BAAmB,GAAA,kCAAoB;AACvC,MAAA,qBAAyB,GAAA,0BAAA;AACzB,MAAA,gBAA0B,GAAA,qBAAA;AAC1B,MAAA,gBAAsB,GAAA,qBAAA;AACtB,MAAA,aAAuB,GAAA,iBAAA;AACvB,MAAA,mBAAuB,GAAA,wBAAA;AACvB,MAAA,oBAA6B,GAAA,yBAAA;AAC7B,MAAA,gBAA6B,GAAA,qBAAA;AAC7B,MAAA,iBAAoB,GAAA,sBAAA;AACpB,MAAA,iBAA4B,GAAA,sBAAA;AAC5B,MAAA,uBAA8B,GAAA,4BAAA;AAC9B,MAAA,uBAAyC,GAAA,4BAAA;AAEzC,MAAA,cAA4B,GAAA,mBAAA;AAC5B,MAAA,sBAA4B,GAAA,4BAAA;AAC5B,MAAA,wBAAsB,GAAA,+BAAwB;AAC9C,MAAA,mCAA2B,GAAA,4CAA6B;AACxD,MAAA,sBAAqB,GAAA,4BAAuB;AAC5C,MAAA,sBAA2B,GAAA,6BAAA;AAC3B,MAAA,gBAAuB,GAAA,qBAAA;AACvB,MAAA,qBAAsB,GAAA,0BAAwB;AAC9C,MAAA,eAA2B,GAAA,oBAAA;AAC3B,MAAA,qBAAuB,GAAA,0BAAyB;AAChD,MAAA,iBAAuB,GAAA,sBAAA;AACvB,MAAA,gBAAsB,GAAA,qBAAA;AACtB,MAAA,qBAAuC,GAAA,2BAAA;AAEvC,MAAA,iBAAsC,GAAA,uBAAA;AAEtC,MAAA,iBAAyB,GAAA,uBAAA;AACzB,MAAA,gBAA4C,GAAA,qBAAA;AAE5C,MAAA,iCAA4B,GAAA,wCAA8B;AAC1D,MAAA,gCAAiC,GAAA,uCAAoC;AACrE,MAAA,mBAAoC,GAAA,uBAAA;AAEpC,MAAA,sCAA0C,GAAA,+CACJ;AACtC,MAAA,sBAA8B,GAAA,2BAAA;;;;;;;;"}
+{"version":3,"file":"BrowserAuthErrorCodes.mjs","sources":["../../src/error/BrowserAuthErrorCodes.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;AACA;AACA;AACA;AACO,MAAA,cAAmB,GAAA,mBAAA;AACnB,MAAA,iBAAuC,GAAA,qBAAA;AAEvC,MAAA,gBAAwB,GAAA,qBAAA;AACxB,MAAA,cAAkC,GAAA,mBAAA;AAClC,MAAA,aAA2B,GAAA,mBAAA;AAC3B,MAAA,iCAAsB,GAAA,yCAAwB;AAC9C,MAAA,kBAAsB,GAAA,wBAAA;AACtB,MAAA,4BAAmB,GAAA,kCAAoB;AACvC,MAAA,qBAAyB,GAAA,0BAAA;AACzB,MAAA,gBAA0B,GAAA,qBAAA;AAC1B,MAAA,gBAAsB,GAAA,qBAAA;AACtB,MAAA,aAAuB,GAAA,iBAAA;AACvB,MAAA,mBAAuB,GAAA,wBAAA;AACvB,MAAA,oBAA6B,GAAA,yBAAA;AAC7B,MAAA,gBAA6B,GAAA,qBAAA;AAC7B,MAAA,iBAAoB,GAAA,sBAAA;AACpB,MAAA,iBAA4B,GAAA,sBAAA;AAC5B,MAAA,uBAA8B,GAAA,4BAAA;AAC9B,MAAA,uBAAyC,GAAA,4BAAA;AAEzC,MAAA,cAA4B,GAAA,mBAAA;AAC5B,MAAA,sBAA4B,GAAA,4BAAA;AAC5B,MAAA,wBAAsB,GAAA,+BAAwB;AAC9C,MAAA,mCAA2B,GAAA,4CAA6B;AACxD,MAAA,sBAAqB,GAAA,4BAAuB;AAC5C,MAAA,sBAA2B,GAAA,6BAAA;AAC3B,MAAA,gBAAuB,GAAA,qBAAA;AACvB,MAAA,qBAAsB,GAAA,0BAAwB;AAC9C,MAAA,eAA2B,GAAA,oBAAA;AAC3B,MAAA,qBAAuB,GAAA,0BAAyB;AAChD,MAAA,iBAAuB,GAAA,sBAAA;AACvB,MAAA,gBAAsB,GAAA,qBAAA;AACtB,MAAA,qBAAuC,GAAA,2BAAA;AAEvC,MAAA,iBAAsC,GAAA,uBAAA;AAEtC,MAAA,iBAAyB,GAAA,uBAAA;AACzB,MAAA,gBAA4C,GAAA,qBAAA;AAE5C,MAAA,iCAA4B,GAAA,wCAA8B;AAC1D,MAAA,gCAAiC,GAAA,uCAAoC;AACrE,MAAA,mBAAoC,GAAA,uBAAA;AAEpC,MAAA,sCAA0C,GAAA,+CACJ;AACtC,MAAA,sBAA8B,GAAA,2BAAA;AAC9B,MAAA,2BAAyB,GAAA,iCAA2B;;;;;;;;"}

package/dist/error/BrowserConfigurationAuthError.d.ts

@@ -1,28 +1,20 @@
 import { AuthError } from "@azure/msal-common";
+import * as BrowserConfigurationAuthErrorCodes from "./BrowserConfigurationAuthErrorCodes";
+export { BrowserConfigurationAuthErrorCodes };
+export declare const BrowserConfigurationAuthErrorMessages: {
+    storage_not_supported: string;
+    stubbed_public_client_application_called: string;
+    in_mem_redirect_unavailable: string;
+};
 /**
  * BrowserAuthErrorMessage class containing string constants used by error codes and messages.
+ * @deprecated Use BrowserAuthErrorCodes instead
  */
 export declare const BrowserConfigurationAuthErrorMessage: {
-    redirectUriNotSet: {
-        code: string;
-        desc: string;
-    };
-    postLogoutUriNotSet: {
-        code: string;
-        desc: string;
-    };
     storageNotSupportedError: {
         code: string;
         desc: string;
     };
-    noRedirectCallbacksSet: {
-        code: string;
-        desc: string;
-    };
-    invalidCallbackObject: {
-        code: string;
-        desc: string;
-    };
     stubPcaInstanceCalled: {
         code: string;
         desc: string;
@@ -31,41 +23,12 @@ export declare const BrowserConfigurationAuthErrorMessage: {
         code: string;
         desc: string;
     };
-    entropyNotProvided: {
-        code: string;
-        desc: string;
-    };
 };
 /**
  * Browser library error class thrown by the MSAL.js library for SPAs
  */
 export declare class BrowserConfigurationAuthError extends AuthError {
     constructor(errorCode: string, errorMessage?: string);
-    /**
-     * Creates an error thrown when the redirect uri is empty (not set by caller)
-     */
-    static createRedirectUriEmptyError(): BrowserConfigurationAuthError;
-    /**
-     * Creates an error thrown when the post-logout redirect uri is empty (not set by caller)
-     */
-    static createPostLogoutRedirectUriEmptyError(): BrowserConfigurationAuthError;
-    /**
-     * Creates error thrown when given storage location is not supported.
-     * @param givenStorageLocation
-     */
-    static createStorageNotSupportedError(givenStorageLocation: string): BrowserConfigurationAuthError;
-    /**
-     * Creates error thrown when redirect callbacks are not set before calling loginRedirect() or acquireTokenRedirect().
-     */
-    static createRedirectCallbacksNotSetError(): BrowserConfigurationAuthError;
-    /**
-     * Creates error thrown when the stub instance of PublicClientApplication is called.
-     */
-    static createStubPcaInstanceCalledError(): BrowserConfigurationAuthError;
-    static createInMemoryRedirectUnavailableError(): BrowserConfigurationAuthError;
-    /**
-     * Creates an error thrown when a crypto interface that requires entropy is initialized without entropy
-     */
-    static createEntropyNotProvided(): BrowserConfigurationAuthError;
 }
+export declare function createBrowserConfigurationAuthError(errorCode: string): BrowserConfigurationAuthError;
 //# sourceMappingURL=BrowserConfigurationAuthError.d.ts.map

package/dist/error/BrowserConfigurationAuthError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BrowserConfigurationAuthError.d.ts","sourceRoot":"","sources":["../../src/error/BrowserConfigurationAuthError.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqChD,CAAC;AAEF;;GAEG;AACH,qBAAa,6BAA8B,SAAQ,SAAS;gBAC5C,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM;IAOpD;;OAEG;IACH,MAAM,CAAC,2BAA2B,IAAI,6BAA6B;IAOnE;;OAEG;IACH,MAAM,CAAC,qCAAqC,IAAI,6BAA6B;IAO7E;;;OAGG;IACH,MAAM,CAAC,8BAA8B,CACjC,oBAAoB,EAAE,MAAM,GAC7B,6BAA6B;IAOhC;;OAEG;IACH,MAAM,CAAC,kCAAkC,IAAI,6BAA6B;IAO1E;;OAEG;IACH,MAAM,CAAC,gCAAgC,IAAI,6BAA6B;IAUxE,MAAM,CAAC,sCAAsC,IAAI,6BAA6B;IAO9E;;OAEG;IACH,MAAM,CAAC,wBAAwB,IAAI,6BAA6B;CAMnE"}
+{"version":3,"file":"BrowserConfigurationAuthError.d.ts","sourceRoot":"","sources":["../../src/error/BrowserConfigurationAuthError.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,KAAK,kCAAkC,MAAM,sCAAsC,CAAC;AAC3F,OAAO,EAAE,kCAAkC,EAAE,CAAC;AAE9C,eAAO,MAAM,qCAAqC;;;;CAOjD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;CAoBhD,CAAC;AAEF;;GAEG;AACH,qBAAa,6BAA8B,SAAQ,SAAS;gBAC5C,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM;CAMvD;AAED,wBAAgB,mCAAmC,CAC/C,SAAS,EAAE,MAAM,GAClB,6BAA6B,CAK/B"}