@azure/msal-browser 3.0.0-alpha.1 → 3.0.0-beta.0

package/dist/crypto/GuidGenerator.js

@@ -1,103 +1,103 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-beta.0 2023-06-19 */
 'use strict';
 import { Constants } from '@azure/msal-common';
 import { MathUtils } from '../utils/MathUtils.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class GuidGenerator {
-    constructor(cryptoObj) {
-        this.cryptoObj = cryptoObj;
-    }
-    /*
-     * RFC4122: The version 4 UUID is meant for generating UUIDs from truly-random or
-     * pseudo-random numbers.
-     * The algorithm is as follows:
-     *     Set the two most significant bits (bits 6 and 7) of the
-     *        clock_seq_hi_and_reserved to zero and one, respectively.
-     *     Set the four most significant bits (bits 12 through 15) of the
-     *        time_hi_and_version field to the 4-bit version number from
-     *        Section 4.1.3. Version4
-     *     Set all the other bits to randomly (or pseudo-randomly) chosen
-     *     values.
-     * UUID                   = time-low "-" time-mid "-"time-high-and-version "-"clock-seq-reserved and low(2hexOctet)"-" node
-     * time-low               = 4hexOctet
-     * time-mid               = 2hexOctet
-     * time-high-and-version  = 2hexOctet
-     * clock-seq-and-reserved = hexOctet:
-     * clock-seq-low          = hexOctet
-     * node                   = 6hexOctet
-     * Format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
-     * y could be 1000, 1001, 1010, 1011 since most significant two bits needs to be 10
-     * y values are 8, 9, A, B
-     */
-    generateGuid() {
-        try {
-            const buffer = new Uint8Array(16);
-            this.cryptoObj.getRandomValues(buffer);
-            // buffer[6] and buffer[7] represents the time_hi_and_version field. We will set the four most significant bits (4 through 7) of buffer[6] to represent decimal number 4 (UUID version number).
-            buffer[6] |= 0x40; // buffer[6] | 01000000 will set the 6 bit to 1.
-            buffer[6] &= 0x4f; // buffer[6] & 01001111 will set the 4, 5, and 7 bit to 0 such that bits 4-7 == 0100 = "4".
-            // buffer[8] represents the clock_seq_hi_and_reserved field. We will set the two most significant bits (6 and 7) of the clock_seq_hi_and_reserved to zero and one, respectively.
-            buffer[8] |= 0x80; // buffer[8] | 10000000 will set the 7 bit to 1.
-            buffer[8] &= 0xbf; // buffer[8] & 10111111 will set the 6 bit to 0.
-            return (MathUtils.decimalToHex(buffer[0]) +
-                MathUtils.decimalToHex(buffer[1]) +
-                MathUtils.decimalToHex(buffer[2]) +
-                MathUtils.decimalToHex(buffer[3]) +
-                "-" +
-                MathUtils.decimalToHex(buffer[4]) +
-                MathUtils.decimalToHex(buffer[5]) +
-                "-" +
-                MathUtils.decimalToHex(buffer[6]) +
-                MathUtils.decimalToHex(buffer[7]) +
-                "-" +
-                MathUtils.decimalToHex(buffer[8]) +
-                MathUtils.decimalToHex(buffer[9]) +
-                "-" +
-                MathUtils.decimalToHex(buffer[10]) +
-                MathUtils.decimalToHex(buffer[11]) +
-                MathUtils.decimalToHex(buffer[12]) +
-                MathUtils.decimalToHex(buffer[13]) +
-                MathUtils.decimalToHex(buffer[14]) +
-                MathUtils.decimalToHex(buffer[15]));
-        }
-        catch (err) {
-            const guidHolder = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
-            const hex = "0123456789abcdef";
-            let r = 0;
-            let guidResponse = Constants.EMPTY_STRING;
-            for (let i = 0; i < 36; i++) {
-                if (guidHolder[i] !== "-" && guidHolder[i] !== "4") {
-                    // each x and y needs to be random
-                    r = (Math.random() * 16) | 0;
-                }
-                if (guidHolder[i] === "x") {
-                    guidResponse += hex[r];
-                }
-                else if (guidHolder[i] === "y") {
-                    // clock-seq-and-reserved first hex is filtered and remaining hex values are random
-                    r &= 0x3; // bit and with 0011 to set pos 2 to zero ?0??
-                    r |= 0x8; // set pos 3 to 1 as 1???
-                    guidResponse += hex[r];
-                }
-                else {
-                    guidResponse += guidHolder[i];
-                }
-            }
-            return guidResponse;
-        }
-    }
-    /**
-     * verifies if a string is  GUID
-     * @param guid
-     */
-    isGuid(guid) {
-        const regexGuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-        return regexGuid.test(guid);
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class GuidGenerator {
+    constructor(cryptoObj) {
+        this.cryptoObj = cryptoObj;
+    }
+    /*
+     * RFC4122: The version 4 UUID is meant for generating UUIDs from truly-random or
+     * pseudo-random numbers.
+     * The algorithm is as follows:
+     *     Set the two most significant bits (bits 6 and 7) of the
+     *        clock_seq_hi_and_reserved to zero and one, respectively.
+     *     Set the four most significant bits (bits 12 through 15) of the
+     *        time_hi_and_version field to the 4-bit version number from
+     *        Section 4.1.3. Version4
+     *     Set all the other bits to randomly (or pseudo-randomly) chosen
+     *     values.
+     * UUID                   = time-low "-" time-mid "-"time-high-and-version "-"clock-seq-reserved and low(2hexOctet)"-" node
+     * time-low               = 4hexOctet
+     * time-mid               = 2hexOctet
+     * time-high-and-version  = 2hexOctet
+     * clock-seq-and-reserved = hexOctet:
+     * clock-seq-low          = hexOctet
+     * node                   = 6hexOctet
+     * Format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
+     * y could be 1000, 1001, 1010, 1011 since most significant two bits needs to be 10
+     * y values are 8, 9, A, B
+     */
+    generateGuid() {
+        try {
+            const buffer = new Uint8Array(16);
+            this.cryptoObj.getRandomValues(buffer);
+            // buffer[6] and buffer[7] represents the time_hi_and_version field. We will set the four most significant bits (4 through 7) of buffer[6] to represent decimal number 4 (UUID version number).
+            buffer[6] |= 0x40; // buffer[6] | 01000000 will set the 6 bit to 1.
+            buffer[6] &= 0x4f; // buffer[6] & 01001111 will set the 4, 5, and 7 bit to 0 such that bits 4-7 == 0100 = "4".
+            // buffer[8] represents the clock_seq_hi_and_reserved field. We will set the two most significant bits (6 and 7) of the clock_seq_hi_and_reserved to zero and one, respectively.
+            buffer[8] |= 0x80; // buffer[8] | 10000000 will set the 7 bit to 1.
+            buffer[8] &= 0xbf; // buffer[8] & 10111111 will set the 6 bit to 0.
+            return (MathUtils.decimalToHex(buffer[0]) +
+                MathUtils.decimalToHex(buffer[1]) +
+                MathUtils.decimalToHex(buffer[2]) +
+                MathUtils.decimalToHex(buffer[3]) +
+                "-" +
+                MathUtils.decimalToHex(buffer[4]) +
+                MathUtils.decimalToHex(buffer[5]) +
+                "-" +
+                MathUtils.decimalToHex(buffer[6]) +
+                MathUtils.decimalToHex(buffer[7]) +
+                "-" +
+                MathUtils.decimalToHex(buffer[8]) +
+                MathUtils.decimalToHex(buffer[9]) +
+                "-" +
+                MathUtils.decimalToHex(buffer[10]) +
+                MathUtils.decimalToHex(buffer[11]) +
+                MathUtils.decimalToHex(buffer[12]) +
+                MathUtils.decimalToHex(buffer[13]) +
+                MathUtils.decimalToHex(buffer[14]) +
+                MathUtils.decimalToHex(buffer[15]));
+        }
+        catch (err) {
+            const guidHolder = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+            const hex = "0123456789abcdef";
+            let r = 0;
+            let guidResponse = Constants.EMPTY_STRING;
+            for (let i = 0; i < 36; i++) {
+                if (guidHolder[i] !== "-" && guidHolder[i] !== "4") {
+                    // each x and y needs to be random
+                    r = (Math.random() * 16) | 0;
+                }
+                if (guidHolder[i] === "x") {
+                    guidResponse += hex[r];
+                }
+                else if (guidHolder[i] === "y") {
+                    // clock-seq-and-reserved first hex is filtered and remaining hex values are random
+                    r &= 0x3; // bit and with 0011 to set pos 2 to zero ?0??
+                    r |= 0x8; // set pos 3 to 1 as 1???
+                    guidResponse += hex[r];
+                }
+                else {
+                    guidResponse += guidHolder[i];
+                }
+            }
+            return guidResponse;
+        }
+    }
+    /**
+     * verifies if a string is  GUID
+     * @param guid
+     */
+    isGuid(guid) {
+        const regexGuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+        return regexGuid.test(guid);
+    }
 }
 
 export { GuidGenerator };

package/dist/crypto/ISubtleCrypto.d.ts

@@ -1,10 +1,10 @@
-export interface ISubtleCrypto {
-    initPrng?(entropy: Uint8Array): void;
-    getRandomValues(dataBuffer: Uint8Array): Uint8Array;
-    generateKey(algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
-    exportKey(key: CryptoKey): Promise<JsonWebKey>;
-    importKey(keyData: JsonWebKey, algorithm: RsaHashedImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
-    sign(algorithm: AlgorithmIdentifier, key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
-    digest(algorithm: AlgorithmIdentifier, data: Uint8Array): Promise<ArrayBuffer>;
-}
+export interface ISubtleCrypto {
+    initPrng?(entropy: Uint8Array): void;
+    getRandomValues(dataBuffer: Uint8Array): Uint8Array;
+    generateKey(algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
+    exportKey(key: CryptoKey): Promise<JsonWebKey>;
+    importKey(keyData: JsonWebKey, algorithm: RsaHashedImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+    sign(algorithm: AlgorithmIdentifier, key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
+    digest(algorithm: AlgorithmIdentifier, data: Uint8Array): Promise<ArrayBuffer>;
+}
 //# sourceMappingURL=ISubtleCrypto.d.ts.map

package/dist/crypto/ModernBrowserCrypto.d.ts

@@ -1,10 +1,10 @@
-import { ISubtleCrypto } from "./ISubtleCrypto";
-export declare class ModernBrowserCrypto implements ISubtleCrypto {
-    getRandomValues(dataBuffer: Uint8Array): Uint8Array;
-    generateKey(algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
-    exportKey(key: CryptoKey): Promise<JsonWebKey>;
-    importKey(keyData: JsonWebKey, algorithm: RsaHashedImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
-    sign(algorithm: AlgorithmIdentifier, key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
-    digest(algorithm: AlgorithmIdentifier, data: Uint8Array): Promise<ArrayBuffer>;
-}
+import { ISubtleCrypto } from "./ISubtleCrypto";
+export declare class ModernBrowserCrypto implements ISubtleCrypto {
+    getRandomValues(dataBuffer: Uint8Array): Uint8Array;
+    generateKey(algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
+    exportKey(key: CryptoKey): Promise<JsonWebKey>;
+    importKey(keyData: JsonWebKey, algorithm: RsaHashedImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+    sign(algorithm: AlgorithmIdentifier, key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
+    digest(algorithm: AlgorithmIdentifier, data: Uint8Array): Promise<ArrayBuffer>;
+}
 //# sourceMappingURL=ModernBrowserCrypto.d.ts.map

package/dist/crypto/ModernBrowserCrypto.js

@@ -1,30 +1,30 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-beta.0 2023-06-19 */
 'use strict';
 import { KEY_FORMAT_JWK } from '../utils/BrowserConstants.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class ModernBrowserCrypto {
-    getRandomValues(dataBuffer) {
-        return window.crypto.getRandomValues(dataBuffer);
-    }
-    async generateKey(algorithm, extractable, keyUsages) {
-        return window.crypto.subtle.generateKey(algorithm, extractable, keyUsages);
-    }
-    async exportKey(key) {
-        return window.crypto.subtle.exportKey(KEY_FORMAT_JWK, key);
-    }
-    async importKey(keyData, algorithm, extractable, keyUsages) {
-        return window.crypto.subtle.importKey(KEY_FORMAT_JWK, keyData, algorithm, extractable, keyUsages);
-    }
-    async sign(algorithm, key, data) {
-        return window.crypto.subtle.sign(algorithm, key, data);
-    }
-    async digest(algorithm, data) {
-        return window.crypto.subtle.digest(algorithm, data);
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class ModernBrowserCrypto {
+    getRandomValues(dataBuffer) {
+        return window.crypto.getRandomValues(dataBuffer);
+    }
+    async generateKey(algorithm, extractable, keyUsages) {
+        return window.crypto.subtle.generateKey(algorithm, extractable, keyUsages);
+    }
+    async exportKey(key) {
+        return window.crypto.subtle.exportKey(KEY_FORMAT_JWK, key);
+    }
+    async importKey(keyData, algorithm, extractable, keyUsages) {
+        return window.crypto.subtle.importKey(KEY_FORMAT_JWK, keyData, algorithm, extractable, keyUsages);
+    }
+    async sign(algorithm, key, data) {
+        return window.crypto.subtle.sign(algorithm, key, data);
+    }
+    async digest(algorithm, data) {
+        return window.crypto.subtle.digest(algorithm, data);
+    }
 }
 
 export { ModernBrowserCrypto };

package/dist/crypto/PkceGenerator.d.ts

@@ -1,25 +1,25 @@
-import { PkceCodes } from "@azure/msal-common";
-import { BrowserCrypto } from "./BrowserCrypto";
-/**
- * Class which exposes APIs to generate PKCE codes and code verifiers.
- */
-export declare class PkceGenerator {
-    private base64Encode;
-    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;
-}
+import { PkceCodes } from "@azure/msal-common";
+import { BrowserCrypto } from "./BrowserCrypto";
+/**
+ * Class which exposes APIs to generate PKCE codes and code verifiers.
+ */
+export declare class PkceGenerator {
+    private base64Encode;
+    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;
+}
 //# sourceMappingURL=PkceGenerator.d.ts.map

package/dist/crypto/PkceGenerator.js

@@ -1,65 +1,65 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-beta.0 2023-06-19 */
 'use strict';
 import { BrowserAuthError } from '../error/BrowserAuthError.js';
 import { Base64Encode } from '../encode/Base64Encode.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-// Constant byte array length
-const RANDOM_BYTE_ARR_LENGTH = 32;
-/**
- * Class which exposes APIs to generate PKCE codes and code verifiers.
- */
-class PkceGenerator {
-    constructor(cryptoObj) {
-        this.base64Encode = new Base64Encode();
-        this.cryptoObj = cryptoObj;
-    }
-    /**
-     * 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,
-        };
-    }
-    /**
-     * 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 = this.base64Encode.urlEncodeArr(buffer);
-            return pkceCodeVerifierB64;
-        }
-        catch (e) {
-            throw BrowserAuthError.createPkceNotGeneratedError(e);
-        }
-    }
-    /**
-     * 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 this.base64Encode.urlEncodeArr(new Uint8Array(pkceHashedCodeVerifier));
-        }
-        catch (e) {
-            throw BrowserAuthError.createPkceNotGeneratedError(e);
-        }
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+// Constant byte array length
+const RANDOM_BYTE_ARR_LENGTH = 32;
+/**
+ * Class which exposes APIs to generate PKCE codes and code verifiers.
+ */
+class PkceGenerator {
+    constructor(cryptoObj) {
+        this.base64Encode = new Base64Encode();
+        this.cryptoObj = cryptoObj;
+    }
+    /**
+     * 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,
+        };
+    }
+    /**
+     * 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 = this.base64Encode.urlEncodeArr(buffer);
+            return pkceCodeVerifierB64;
+        }
+        catch (e) {
+            throw BrowserAuthError.createPkceNotGeneratedError(e);
+        }
+    }
+    /**
+     * 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 this.base64Encode.urlEncodeArr(new Uint8Array(pkceHashedCodeVerifier));
+        }
+        catch (e) {
+            throw BrowserAuthError.createPkceNotGeneratedError(e);
+        }
+    }
 }
 
 export { PkceGenerator };

package/dist/crypto/SignedHttpRequest.d.ts

@@ -1,31 +1,31 @@
-import { LoggerOptions, SignedHttpRequestParameters } from "@azure/msal-common";
-export type SignedHttpRequestOptions = {
-    loggerOptions: LoggerOptions;
-};
-export declare class SignedHttpRequest {
-    private popTokenGenerator;
-    private cryptoOps;
-    private shrParameters;
-    private logger;
-    constructor(shrParameters: SignedHttpRequestParameters, shrOptions?: SignedHttpRequestOptions);
-    /**
-     * Generates and caches a keypair for the given request options.
-     * @returns Public key digest, which should be sent to the token issuer.
-     */
-    generatePublicKeyThumbprint(): Promise<string>;
-    /**
-     * Generates a signed http request for the given payload with the given key.
-     * @param payload Payload to sign (e.g. access token)
-     * @param publicKeyThumbprint Public key digest (from generatePublicKeyThumbprint API)
-     * @param claims Additional claims to include/override in the signed JWT
-     * @returns Pop token signed with the corresponding private key
-     */
-    signRequest(payload: string, publicKeyThumbprint: string, claims?: object): Promise<string>;
-    /**
-     * Removes cached keys from browser for given public key thumbprint
-     * @param publicKeyThumbprint Public key digest (from generatePublicKeyThumbprint API)
-     * @returns If keys are properly deleted
-     */
-    removeKeys(publicKeyThumbprint: string): Promise<boolean>;
-}
+import { LoggerOptions, SignedHttpRequestParameters } from "@azure/msal-common";
+export type SignedHttpRequestOptions = {
+    loggerOptions: LoggerOptions;
+};
+export declare class SignedHttpRequest {
+    private popTokenGenerator;
+    private cryptoOps;
+    private shrParameters;
+    private logger;
+    constructor(shrParameters: SignedHttpRequestParameters, shrOptions?: SignedHttpRequestOptions);
+    /**
+     * Generates and caches a keypair for the given request options.
+     * @returns Public key digest, which should be sent to the token issuer.
+     */
+    generatePublicKeyThumbprint(): Promise<string>;
+    /**
+     * Generates a signed http request for the given payload with the given key.
+     * @param payload Payload to sign (e.g. access token)
+     * @param publicKeyThumbprint Public key digest (from generatePublicKeyThumbprint API)
+     * @param claims Additional claims to include/override in the signed JWT
+     * @returns Pop token signed with the corresponding private key
+     */
+    signRequest(payload: string, publicKeyThumbprint: string, claims?: object): Promise<string>;
+    /**
+     * Removes cached keys from browser for given public key thumbprint
+     * @param publicKeyThumbprint Public key digest (from generatePublicKeyThumbprint API)
+     * @returns If keys are properly deleted
+     */
+    removeKeys(publicKeyThumbprint: string): Promise<boolean>;
+}
 //# sourceMappingURL=SignedHttpRequest.d.ts.map

package/dist/crypto/SignedHttpRequest.js

@@ -1,47 +1,47 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-beta.0 2023-06-19 */
 'use strict';
 import { CryptoOps } from './CryptoOps.js';
 import { Logger, PopTokenGenerator } from '@azure/msal-common';
 import { name, version } from '../packageMetadata.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class SignedHttpRequest {
-    constructor(shrParameters, shrOptions) {
-        const loggerOptions = (shrOptions && shrOptions.loggerOptions) || {};
-        this.logger = new Logger(loggerOptions, name, version);
-        this.cryptoOps = new CryptoOps(this.logger);
-        this.popTokenGenerator = new PopTokenGenerator(this.cryptoOps);
-        this.shrParameters = shrParameters;
-    }
-    /**
-     * Generates and caches a keypair for the given request options.
-     * @returns Public key digest, which should be sent to the token issuer.
-     */
-    async generatePublicKeyThumbprint() {
-        const { kid } = await this.popTokenGenerator.generateKid(this.shrParameters);
-        return kid;
-    }
-    /**
-     * Generates a signed http request for the given payload with the given key.
-     * @param payload Payload to sign (e.g. access token)
-     * @param publicKeyThumbprint Public key digest (from generatePublicKeyThumbprint API)
-     * @param claims Additional claims to include/override in the signed JWT
-     * @returns Pop token signed with the corresponding private key
-     */
-    async signRequest(payload, publicKeyThumbprint, claims) {
-        return this.popTokenGenerator.signPayload(payload, publicKeyThumbprint, this.shrParameters, claims);
-    }
-    /**
-     * Removes cached keys from browser for given public key thumbprint
-     * @param publicKeyThumbprint Public key digest (from generatePublicKeyThumbprint API)
-     * @returns If keys are properly deleted
-     */
-    async removeKeys(publicKeyThumbprint) {
-        return await this.cryptoOps.removeTokenBindingKey(publicKeyThumbprint);
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class SignedHttpRequest {
+    constructor(shrParameters, shrOptions) {
+        const loggerOptions = (shrOptions && shrOptions.loggerOptions) || {};
+        this.logger = new Logger(loggerOptions, name, version);
+        this.cryptoOps = new CryptoOps(this.logger);
+        this.popTokenGenerator = new PopTokenGenerator(this.cryptoOps);
+        this.shrParameters = shrParameters;
+    }
+    /**
+     * Generates and caches a keypair for the given request options.
+     * @returns Public key digest, which should be sent to the token issuer.
+     */
+    async generatePublicKeyThumbprint() {
+        const { kid } = await this.popTokenGenerator.generateKid(this.shrParameters);
+        return kid;
+    }
+    /**
+     * Generates a signed http request for the given payload with the given key.
+     * @param payload Payload to sign (e.g. access token)
+     * @param publicKeyThumbprint Public key digest (from generatePublicKeyThumbprint API)
+     * @param claims Additional claims to include/override in the signed JWT
+     * @returns Pop token signed with the corresponding private key
+     */
+    async signRequest(payload, publicKeyThumbprint, claims) {
+        return this.popTokenGenerator.signPayload(payload, publicKeyThumbprint, this.shrParameters, claims);
+    }
+    /**
+     * Removes cached keys from browser for given public key thumbprint
+     * @param publicKeyThumbprint Public key digest (from generatePublicKeyThumbprint API)
+     * @returns If keys are properly deleted
+     */
+    async removeKeys(publicKeyThumbprint) {
+        return await this.cryptoOps.removeTokenBindingKey(publicKeyThumbprint);
+    }
 }
 
 export { SignedHttpRequest };