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

package/dist/crypto/MsBrowserCrypto.d.ts

@@ -1,10 +1,10 @@
-import { ISubtleCrypto } from "./ISubtleCrypto";
-export declare class MsBrowserCrypto 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 MsBrowserCrypto 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=MsBrowserCrypto.d.ts.map

package/dist/crypto/MsBrowserCrypto.js

@@ -1,87 +1,87 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-alpha.2 2023-05-17 */
 'use strict';
 import { Constants } from '@azure/msal-common';
 import { KEY_FORMAT_JWK } from '../utils/BrowserConstants.js';
 import { BrowserStringUtils } from '../utils/BrowserStringUtils.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class MsBrowserCrypto {
-    getRandomValues(dataBuffer) {
-        return window["msCrypto"].getRandomValues(dataBuffer);
-    }
-    async generateKey(algorithm, extractable, keyUsages) {
-        return new Promise((resolve, reject) => {
-            const msGenerateKey = window["msCrypto"].subtle.generateKey(algorithm, extractable, keyUsages);
-            msGenerateKey.addEventListener("complete", (e) => {
-                resolve(e.target.result);
-            });
-            msGenerateKey.addEventListener("error", (error) => {
-                reject(error);
-            });
-        });
-    }
-    async exportKey(key) {
-        return new Promise((resolve, reject) => {
-            const msExportKey = window["msCrypto"].subtle.exportKey(KEY_FORMAT_JWK, key);
-            msExportKey.addEventListener("complete", (e) => {
-                const resultBuffer = e.target.result;
-                const resultString = BrowserStringUtils.utf8ArrToString(new Uint8Array(resultBuffer))
-                    .replace(/\r/g, Constants.EMPTY_STRING)
-                    .replace(/\n/g, Constants.EMPTY_STRING)
-                    .replace(/\t/g, Constants.EMPTY_STRING)
-                    .split(" ")
-                    .join(Constants.EMPTY_STRING)
-                    .replace("\u0000", Constants.EMPTY_STRING);
-                try {
-                    resolve(JSON.parse(resultString));
-                }
-                catch (e) {
-                    reject(e);
-                }
-            });
-            msExportKey.addEventListener("error", (error) => {
-                reject(error);
-            });
-        });
-    }
-    async importKey(keyData, algorithm, extractable, keyUsages) {
-        const keyString = BrowserStringUtils.getSortedObjectString(keyData);
-        const keyBuffer = BrowserStringUtils.stringToArrayBuffer(keyString);
-        return new Promise((resolve, reject) => {
-            const msImportKey = window["msCrypto"].subtle.importKey(KEY_FORMAT_JWK, keyBuffer, algorithm, extractable, keyUsages);
-            msImportKey.addEventListener("complete", (e) => {
-                resolve(e.target.result);
-            });
-            msImportKey.addEventListener("error", (error) => {
-                reject(error);
-            });
-        });
-    }
-    async sign(algorithm, key, data) {
-        return new Promise((resolve, reject) => {
-            const msSign = window["msCrypto"].subtle.sign(algorithm, key, data);
-            msSign.addEventListener("complete", (e) => {
-                resolve(e.target.result);
-            });
-            msSign.addEventListener("error", (error) => {
-                reject(error);
-            });
-        });
-    }
-    async digest(algorithm, data) {
-        return new Promise((resolve, reject) => {
-            const digestOperation = window["msCrypto"].subtle.digest(algorithm, data.buffer);
-            digestOperation.addEventListener("complete", (e) => {
-                resolve(e.target.result);
-            });
-            digestOperation.addEventListener("error", (error) => {
-                reject(error);
-            });
-        });
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class MsBrowserCrypto {
+    getRandomValues(dataBuffer) {
+        return window["msCrypto"].getRandomValues(dataBuffer);
+    }
+    async generateKey(algorithm, extractable, keyUsages) {
+        return new Promise((resolve, reject) => {
+            const msGenerateKey = window["msCrypto"].subtle.generateKey(algorithm, extractable, keyUsages);
+            msGenerateKey.addEventListener("complete", (e) => {
+                resolve(e.target.result);
+            });
+            msGenerateKey.addEventListener("error", (error) => {
+                reject(error);
+            });
+        });
+    }
+    async exportKey(key) {
+        return new Promise((resolve, reject) => {
+            const msExportKey = window["msCrypto"].subtle.exportKey(KEY_FORMAT_JWK, key);
+            msExportKey.addEventListener("complete", (e) => {
+                const resultBuffer = e.target.result;
+                const resultString = BrowserStringUtils.utf8ArrToString(new Uint8Array(resultBuffer))
+                    .replace(/\r/g, Constants.EMPTY_STRING)
+                    .replace(/\n/g, Constants.EMPTY_STRING)
+                    .replace(/\t/g, Constants.EMPTY_STRING)
+                    .split(" ")
+                    .join(Constants.EMPTY_STRING)
+                    .replace("\u0000", Constants.EMPTY_STRING);
+                try {
+                    resolve(JSON.parse(resultString));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+            msExportKey.addEventListener("error", (error) => {
+                reject(error);
+            });
+        });
+    }
+    async importKey(keyData, algorithm, extractable, keyUsages) {
+        const keyString = BrowserStringUtils.getSortedObjectString(keyData);
+        const keyBuffer = BrowserStringUtils.stringToArrayBuffer(keyString);
+        return new Promise((resolve, reject) => {
+            const msImportKey = window["msCrypto"].subtle.importKey(KEY_FORMAT_JWK, keyBuffer, algorithm, extractable, keyUsages);
+            msImportKey.addEventListener("complete", (e) => {
+                resolve(e.target.result);
+            });
+            msImportKey.addEventListener("error", (error) => {
+                reject(error);
+            });
+        });
+    }
+    async sign(algorithm, key, data) {
+        return new Promise((resolve, reject) => {
+            const msSign = window["msCrypto"].subtle.sign(algorithm, key, data);
+            msSign.addEventListener("complete", (e) => {
+                resolve(e.target.result);
+            });
+            msSign.addEventListener("error", (error) => {
+                reject(error);
+            });
+        });
+    }
+    async digest(algorithm, data) {
+        return new Promise((resolve, reject) => {
+            const digestOperation = window["msCrypto"].subtle.digest(algorithm, data.buffer);
+            digestOperation.addEventListener("complete", (e) => {
+                resolve(e.target.result);
+            });
+            digestOperation.addEventListener("error", (error) => {
+                reject(error);
+            });
+        });
+    }
 }
 
 export { MsBrowserCrypto };

package/dist/crypto/MsrBrowserCrypto.d.ts

@@ -1,18 +1,18 @@
-import { ISubtleCrypto } from "./ISubtleCrypto";
-declare global {
-    interface Window {
-        msrCrypto: Crypto & {
-            initPrng: (entropy: Uint8Array | number[]) => void;
-        };
-    }
-}
-export declare class MsrBrowserCrypto implements 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>;
-}
+import { ISubtleCrypto } from "./ISubtleCrypto";
+declare global {
+    interface Window {
+        msrCrypto: Crypto & {
+            initPrng: (entropy: Uint8Array | number[]) => void;
+        };
+    }
+}
+export declare class MsrBrowserCrypto implements 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=MsrBrowserCrypto.d.ts.map

package/dist/crypto/MsrBrowserCrypto.js

@@ -1,34 +1,34 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-alpha.2 2023-05-17 */
 'use strict';
 import { KEY_FORMAT_JWK } from '../utils/BrowserConstants.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class MsrBrowserCrypto {
-    initPrng(entropy) {
-        // Turn into array, as initPrng seems to not always like Uint8Array (even though it should support both)
-        return window.msrCrypto.initPrng([...entropy]);
-    }
-    getRandomValues(dataBuffer) {
-        return window.msrCrypto.getRandomValues(dataBuffer);
-    }
-    async generateKey(algorithm, extractable, keyUsages) {
-        return window.msrCrypto.subtle.generateKey(algorithm, extractable, keyUsages);
-    }
-    async exportKey(key) {
-        return window.msrCrypto.subtle.exportKey(KEY_FORMAT_JWK, key);
-    }
-    async importKey(keyData, algorithm, extractable, keyUsages) {
-        return window.msrCrypto.subtle.importKey(KEY_FORMAT_JWK, keyData, algorithm, extractable, keyUsages);
-    }
-    async sign(algorithm, key, data) {
-        return window.msrCrypto.subtle.sign(algorithm, key, data);
-    }
-    async digest(algorithm, data) {
-        return window.msrCrypto.subtle.digest(algorithm, data);
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class MsrBrowserCrypto {
+    initPrng(entropy) {
+        // Turn into array, as initPrng seems to not always like Uint8Array (even though it should support both)
+        return window.msrCrypto.initPrng([...entropy]);
+    }
+    getRandomValues(dataBuffer) {
+        return window.msrCrypto.getRandomValues(dataBuffer);
+    }
+    async generateKey(algorithm, extractable, keyUsages) {
+        return window.msrCrypto.subtle.generateKey(algorithm, extractable, keyUsages);
+    }
+    async exportKey(key) {
+        return window.msrCrypto.subtle.exportKey(KEY_FORMAT_JWK, key);
+    }
+    async importKey(keyData, algorithm, extractable, keyUsages) {
+        return window.msrCrypto.subtle.importKey(KEY_FORMAT_JWK, keyData, algorithm, extractable, keyUsages);
+    }
+    async sign(algorithm, key, data) {
+        return window.msrCrypto.subtle.sign(algorithm, key, data);
+    }
+    async digest(algorithm, data) {
+        return window.msrCrypto.subtle.digest(algorithm, data);
+    }
 }
 
 export { MsrBrowserCrypto };

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-alpha.2 2023-05-17 */
 '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-alpha.2 2023-05-17 */
 '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 };