@azure/msal-browser 3.20.0 → 3.21.0

package/dist/crypto/CryptoOps.mjs

@@ -1,4 +1,4 @@
-/*! @azure/msal-browser v3.20.0 2024-07-23 */
+/*! @azure/msal-browser v3.21.0 2024-08-13 */
 'use strict';
 import { PerformanceEvents, JoseHeader } from '@azure/msal-common';
 import { base64Encode, urlEncode, urlEncodeArr } from '../encode/Base64Encode.mjs';
@@ -8,181 +8,181 @@ import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
 import { AsyncMemoryStorage } from '../cache/AsyncMemoryStorage.mjs';
 import { cryptoKeyNotFound } from '../error/BrowserAuthErrorCodes.mjs';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * This class implements MSAL's crypto interface, which allows it to perform base64 encoding and decoding, generating cryptographically random GUIDs and
- * implementing Proof Key for Code Exchange specs for the OAuth Authorization Code Flow using PKCE (rfc here: https://tools.ietf.org/html/rfc7636).
- */
-class CryptoOps {
-    constructor(logger, performanceClient) {
-        this.logger = logger;
-        // Browser crypto needs to be validated first before any other classes can be set.
-        validateCryptoAvailable(logger);
-        this.cache = new AsyncMemoryStorage(this.logger);
-        this.performanceClient = performanceClient;
-    }
-    /**
-     * Creates a new random GUID - used to populate state and nonce.
-     * @returns string (GUID)
-     */
-    createNewGuid() {
-        return createNewGuid();
-    }
-    /**
-     * Encodes input string to base64.
-     * @param input
-     */
-    base64Encode(input) {
-        return base64Encode(input);
-    }
-    /**
-     * Decodes input string from base64.
-     * @param input
-     */
-    base64Decode(input) {
-        return base64Decode(input);
-    }
-    /**
-     * Encodes input string to base64 URL safe string.
-     * @param input
-     */
-    base64UrlEncode(input) {
-        return urlEncode(input);
-    }
-    /**
-     * Stringifies and base64Url encodes input public key
-     * @param inputKid
-     * @returns Base64Url encoded public key
-     */
-    encodeKid(inputKid) {
-        return this.base64UrlEncode(JSON.stringify({ kid: inputKid }));
-    }
-    /**
-     * Generates a keypair, stores it and returns a thumbprint
-     * @param request
-     */
-    async getPublicKeyThumbprint(request) {
-        const publicKeyThumbMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.CryptoOptsGetPublicKeyThumbprint, request.correlationId);
-        // Generate Keypair
-        const keyPair = await generateKeyPair(CryptoOps.EXTRACTABLE, CryptoOps.POP_KEY_USAGES);
-        // Generate Thumbprint for Public Key
-        const publicKeyJwk = await exportJwk(keyPair.publicKey);
-        const pubKeyThumprintObj = {
-            e: publicKeyJwk.e,
-            kty: publicKeyJwk.kty,
-            n: publicKeyJwk.n,
-        };
-        const publicJwkString = getSortedObjectString(pubKeyThumprintObj);
-        const publicJwkHash = await this.hashString(publicJwkString);
-        // Generate Thumbprint for Private Key
-        const privateKeyJwk = await exportJwk(keyPair.privateKey);
-        // Re-import private key to make it unextractable
-        const unextractablePrivateKey = await importJwk(privateKeyJwk, false, ["sign"]);
-        // Store Keypair data in keystore
-        await this.cache.setItem(publicJwkHash, {
-            privateKey: unextractablePrivateKey,
-            publicKey: keyPair.publicKey,
-            requestMethod: request.resourceRequestMethod,
-            requestUri: request.resourceRequestUri,
-        });
-        if (publicKeyThumbMeasurement) {
-            publicKeyThumbMeasurement.end({
-                success: true,
-            });
-        }
-        return publicJwkHash;
-    }
-    /**
-     * Removes cryptographic keypair from key store matching the keyId passed in
-     * @param kid
-     */
-    async removeTokenBindingKey(kid) {
-        await this.cache.removeItem(kid);
-        const keyFound = await this.cache.containsKey(kid);
-        return !keyFound;
-    }
-    /**
-     * Removes all cryptographic keys from IndexedDB storage
-     */
-    async clearKeystore() {
-        // Delete in-memory keystores
-        this.cache.clearInMemory();
-        /**
-         * There is only one database, so calling clearPersistent on asymmetric keystore takes care of
-         * every persistent keystore
-         */
-        try {
-            await this.cache.clearPersistent();
-            return true;
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                this.logger.error(`Clearing keystore failed with error: ${e.message}`);
-            }
-            else {
-                this.logger.error("Clearing keystore failed with unknown error");
-            }
-            return false;
-        }
-    }
-    /**
-     * Signs the given object as a jwt payload with private key retrieved by given kid.
-     * @param payload
-     * @param kid
-     */
-    async signJwt(payload, kid, shrOptions, correlationId) {
-        const signJwtMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.CryptoOptsSignJwt, correlationId);
-        const cachedKeyPair = await this.cache.getItem(kid);
-        if (!cachedKeyPair) {
-            throw createBrowserAuthError(cryptoKeyNotFound);
-        }
-        // Get public key as JWK
-        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
-        const shrHeader = JoseHeader.getShrHeaderString({
-            ...shrOptions?.header,
-            alg: publicKeyJwk.alg,
-            kid: encodedKeyIdThumbprint,
-        });
-        const encodedShrHeader = urlEncode(shrHeader);
-        // Generate payload
-        payload.cnf = {
-            jwk: JSON.parse(publicKeyJwkString),
-        };
-        const encodedPayload = urlEncode(JSON.stringify(payload));
-        // Form token string
-        const tokenString = `${encodedShrHeader}.${encodedPayload}`;
-        // Sign token
-        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) {
-            signJwtMeasurement.end({
-                success: true,
-            });
-        }
-        return signedJwt;
-    }
-    /**
-     * Returns the SHA-256 hash of an input string
-     * @param plainText
-     */
-    async hashString(plainText) {
-        return hashString(plainText);
-    }
-}
-CryptoOps.POP_KEY_USAGES = ["sign", "verify"];
-CryptoOps.EXTRACTABLE = true;
-function getSortedObjectString(obj) {
-    return JSON.stringify(obj, Object.keys(obj).sort());
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * This class implements MSAL's crypto interface, which allows it to perform base64 encoding and decoding, generating cryptographically random GUIDs and
+ * implementing Proof Key for Code Exchange specs for the OAuth Authorization Code Flow using PKCE (rfc here: https://tools.ietf.org/html/rfc7636).
+ */
+class CryptoOps {
+    constructor(logger, performanceClient) {
+        this.logger = logger;
+        // Browser crypto needs to be validated first before any other classes can be set.
+        validateCryptoAvailable(logger);
+        this.cache = new AsyncMemoryStorage(this.logger);
+        this.performanceClient = performanceClient;
+    }
+    /**
+     * Creates a new random GUID - used to populate state and nonce.
+     * @returns string (GUID)
+     */
+    createNewGuid() {
+        return createNewGuid();
+    }
+    /**
+     * Encodes input string to base64.
+     * @param input
+     */
+    base64Encode(input) {
+        return base64Encode(input);
+    }
+    /**
+     * Decodes input string from base64.
+     * @param input
+     */
+    base64Decode(input) {
+        return base64Decode(input);
+    }
+    /**
+     * Encodes input string to base64 URL safe string.
+     * @param input
+     */
+    base64UrlEncode(input) {
+        return urlEncode(input);
+    }
+    /**
+     * Stringifies and base64Url encodes input public key
+     * @param inputKid
+     * @returns Base64Url encoded public key
+     */
+    encodeKid(inputKid) {
+        return this.base64UrlEncode(JSON.stringify({ kid: inputKid }));
+    }
+    /**
+     * Generates a keypair, stores it and returns a thumbprint
+     * @param request
+     */
+    async getPublicKeyThumbprint(request) {
+        const publicKeyThumbMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.CryptoOptsGetPublicKeyThumbprint, request.correlationId);
+        // Generate Keypair
+        const keyPair = await generateKeyPair(CryptoOps.EXTRACTABLE, CryptoOps.POP_KEY_USAGES);
+        // Generate Thumbprint for Public Key
+        const publicKeyJwk = await exportJwk(keyPair.publicKey);
+        const pubKeyThumprintObj = {
+            e: publicKeyJwk.e,
+            kty: publicKeyJwk.kty,
+            n: publicKeyJwk.n,
+        };
+        const publicJwkString = getSortedObjectString(pubKeyThumprintObj);
+        const publicJwkHash = await this.hashString(publicJwkString);
+        // Generate Thumbprint for Private Key
+        const privateKeyJwk = await exportJwk(keyPair.privateKey);
+        // Re-import private key to make it unextractable
+        const unextractablePrivateKey = await importJwk(privateKeyJwk, false, ["sign"]);
+        // Store Keypair data in keystore
+        await this.cache.setItem(publicJwkHash, {
+            privateKey: unextractablePrivateKey,
+            publicKey: keyPair.publicKey,
+            requestMethod: request.resourceRequestMethod,
+            requestUri: request.resourceRequestUri,
+        });
+        if (publicKeyThumbMeasurement) {
+            publicKeyThumbMeasurement.end({
+                success: true,
+            });
+        }
+        return publicJwkHash;
+    }
+    /**
+     * Removes cryptographic keypair from key store matching the keyId passed in
+     * @param kid
+     */
+    async removeTokenBindingKey(kid) {
+        await this.cache.removeItem(kid);
+        const keyFound = await this.cache.containsKey(kid);
+        return !keyFound;
+    }
+    /**
+     * Removes all cryptographic keys from IndexedDB storage
+     */
+    async clearKeystore() {
+        // Delete in-memory keystores
+        this.cache.clearInMemory();
+        /**
+         * There is only one database, so calling clearPersistent on asymmetric keystore takes care of
+         * every persistent keystore
+         */
+        try {
+            await this.cache.clearPersistent();
+            return true;
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                this.logger.error(`Clearing keystore failed with error: ${e.message}`);
+            }
+            else {
+                this.logger.error("Clearing keystore failed with unknown error");
+            }
+            return false;
+        }
+    }
+    /**
+     * Signs the given object as a jwt payload with private key retrieved by given kid.
+     * @param payload
+     * @param kid
+     */
+    async signJwt(payload, kid, shrOptions, correlationId) {
+        const signJwtMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.CryptoOptsSignJwt, correlationId);
+        const cachedKeyPair = await this.cache.getItem(kid);
+        if (!cachedKeyPair) {
+            throw createBrowserAuthError(cryptoKeyNotFound);
+        }
+        // Get public key as JWK
+        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
+        const shrHeader = JoseHeader.getShrHeaderString({
+            ...shrOptions?.header,
+            alg: publicKeyJwk.alg,
+            kid: encodedKeyIdThumbprint,
+        });
+        const encodedShrHeader = urlEncode(shrHeader);
+        // Generate payload
+        payload.cnf = {
+            jwk: JSON.parse(publicKeyJwkString),
+        };
+        const encodedPayload = urlEncode(JSON.stringify(payload));
+        // Form token string
+        const tokenString = `${encodedShrHeader}.${encodedPayload}`;
+        // Sign token
+        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) {
+            signJwtMeasurement.end({
+                success: true,
+            });
+        }
+        return signedJwt;
+    }
+    /**
+     * Returns the SHA-256 hash of an input string
+     * @param plainText
+     */
+    async hashString(plainText) {
+        return hashString(plainText);
+    }
+}
+CryptoOps.POP_KEY_USAGES = ["sign", "verify"];
+CryptoOps.EXTRACTABLE = true;
+function getSortedObjectString(obj) {
+    return JSON.stringify(obj, Object.keys(obj).sort());
 }
 
 export { CryptoOps };

package/dist/crypto/PkceGenerator.d.ts

@@ -1,9 +1,9 @@
-import { IPerformanceClient, Logger, PkceCodes } from "@azure/msal-common";
-/**
- * This file defines APIs to generate PKCE codes and code verifiers.
- */
-/**
- * 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>;
+import { IPerformanceClient, Logger, PkceCodes } from "@azure/msal-common";
+/**
+ * This file defines APIs to generate PKCE codes and code verifiers.
+ */
+/**
+ * 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.mjs

@@ -1,4 +1,4 @@
-/*! @azure/msal-browser v3.20.0 2024-07-23 */
+/*! @azure/msal-browser v3.21.0 2024-08-13 */
 'use strict';
 import { PerformanceEvents, invoke, invokeAsync } from '@azure/msal-common';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
@@ -6,59 +6,59 @@ import { urlEncodeArr } from '../encode/Base64Encode.mjs';
 import { getRandomValues, sha256Digest } from './BrowserCrypto.mjs';
 import { pkceNotCreated } from '../error/BrowserAuthErrorCodes.mjs';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-// Constant byte array length
-const RANDOM_BYTE_ARR_LENGTH = 32;
-/**
- * This file defines APIs to generate PKCE codes and code verifiers.
- */
-/**
- * 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;
-    }
-    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));
-    }
-    catch (e) {
-        throw createBrowserAuthError(pkceNotCreated);
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+// Constant byte array length
+const RANDOM_BYTE_ARR_LENGTH = 32;
+/**
+ * This file defines APIs to generate PKCE codes and code verifiers.
+ */
+/**
+ * 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;
+    }
+    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));
+    }
+    catch (e) {
+        throw createBrowserAuthError(pkceNotCreated);
+    }
 }
 
 export { generatePkceCodes };

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.mjs

@@ -1,47 +1,47 @@
-/*! @azure/msal-browser v3.20.0 2024-07-23 */
+/*! @azure/msal-browser v3.21.0 2024-08-13 */
 'use strict';
 import { CryptoOps } from './CryptoOps.mjs';
 import { Logger, PopTokenGenerator } from '@azure/msal-common';
 import { name, version } from '../packageMetadata.mjs';
 
-/*
- * 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 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 this.cryptoOps.removeTokenBindingKey(publicKeyThumbprint);
+    }
 }
 
 export { SignedHttpRequest };