@azure/msal-common 14.14.2 → 14.16.0

package/{dist/index.cjs → lib/index-node-C9XsExml.js}

@@ -1,4 +1,4 @@
-/*! @azure/msal-common v14.14.2 2024-08-28 */
+/*! @azure/msal-common v14.16.0 2024-11-05 */
 'use strict';
 'use strict';
 
@@ -96,6 +96,7 @@ const OIDC_SCOPES = [...OIDC_DEFAULT_SCOPES, Constants.EMAIL_SCOPE];
  */
 const HeaderNames = {
     CONTENT_TYPE: "Content-Type",
+    CONTENT_LENGTH: "Content-Length",
     RETRY_AFTER: "Retry-After",
     CCS_HEADER: "X-AnchorMailbox",
     WWWAuthenticate: "WWW-Authenticate",
@@ -1612,6 +1613,7 @@ const PerformanceEvents = {
     /**
      * Time spent sending/waiting for the response of a request to the token endpoint
      */
+    NetworkClientSendPostRequestAsync: "networkClientSendPostRequestAsync",
     RefreshTokenClientExecutePostToTokenEndpoint: "refreshTokenClientExecutePostToTokenEndpoint",
     AuthorizationCodeClientExecutePostToTokenEndpoint: "authorizationCodeClientExecutePostToTokenEndpoint",
     /**
@@ -1785,6 +1787,10 @@ const PerformanceEventAbbreviations = new Map([
         PerformanceEvents.BaseClientCreateTokenRequestHeaders,
         "BaseClientCreateTReqHead",
     ],
+    [
+        PerformanceEvents.NetworkClientSendPostRequestAsync,
+        "NetClientSendPost",
+    ],
     [
         PerformanceEvents.RefreshTokenClientExecutePostToTokenEndpoint,
         "RTClientExecPost",
@@ -3463,28 +3469,6 @@ var AuthorityFactory = /*#__PURE__*/Object.freeze({
     createDiscoveredInstance: createDiscoveredInstance
 });
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-async function getClientAssertion(clientAssertion, clientId, tokenEndpoint) {
-    if (typeof clientAssertion === "string") {
-        return clientAssertion;
-    }
-    else {
-        const config = {
-            clientId: clientId,
-            tokenEndpoint: tokenEndpoint,
-        };
-        return clientAssertion(config);
-    }
-}
-
-var ClientAssertionUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getClientAssertion: getClientAssertion
-});
-
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
@@ -3541,11 +3525,15 @@ const LOGOUT_HINT = "logout_hint";
 const SID = "sid";
 const LOGIN_HINT = "login_hint";
 const DOMAIN_HINT = "domain_hint";
-const X_CLIENT_EXTRA_SKU = "x-client-xtra-sku";
+const X_CLIENT_EXTRA_SKU = "x-client-xtra-sku";
+const BROKER_CLIENT_ID = "brk_client_id";
+const BROKER_REDIRECT_URI = "brk_redirect_uri";
 
 var AADServerParamKeys = /*#__PURE__*/Object.freeze({
     __proto__: null,
     ACCESS_TOKEN: ACCESS_TOKEN,
+    BROKER_CLIENT_ID: BROKER_CLIENT_ID,
+    BROKER_REDIRECT_URI: BROKER_REDIRECT_URI,
     CCS_HEADER: CCS_HEADER,
     CLAIMS: CLAIMS,
     CLIENT_ASSERTION: CLIENT_ASSERTION,
@@ -3828,7 +3816,7 @@ class Logger {
 
 /* eslint-disable header/header */
 const name = "@azure/msal-common";
-const version = "14.14.2";
+const version = "14.16.0";
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -5683,9 +5671,6 @@ class DefaultStorageClass extends CacheManager {
     getTokenKeys() {
         throw createClientAuthError(methodNotImplemented);
     }
-    async clear() {
-        throw createClientAuthError(methodNotImplemented);
-    }
     updateCredentialCacheKey() {
         throw createClientAuthError(methodNotImplemented);
     }
@@ -5779,6 +5764,7 @@ function buildAuthOptions(authOptions) {
         clientCapabilities: [],
         azureCloudOptions: DEFAULT_AZURE_CLOUD_OPTIONS,
         skipAuthorityMetadataCache: false,
+        instanceAware: false,
         ...authOptions,
     };
 }
@@ -5790,154 +5776,6 @@ function isOidcProtocolMode(config) {
     return (config.authOptions.authority.options.protocolMode === ProtocolMode.OIDC);
 }
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Error thrown when there is an error with the server code, for example, unavailability.
- */
-class ServerError extends AuthError {
-    constructor(errorCode, errorMessage, subError, errorNo, status) {
-        super(errorCode, errorMessage, subError);
-        this.name = "ServerError";
-        this.errorNo = errorNo;
-        this.status = status;
-        Object.setPrototypeOf(this, ServerError.prototype);
-    }
-}
-
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/** @internal */
-class ThrottlingUtils {
-    /**
-     * Prepares a RequestThumbprint to be stored as a key.
-     * @param thumbprint
-     */
-    static generateThrottlingStorageKey(thumbprint) {
-        return `${ThrottlingConstants.THROTTLING_PREFIX}.${JSON.stringify(thumbprint)}`;
-    }
-    /**
-     * Performs necessary throttling checks before a network request.
-     * @param cacheManager
-     * @param thumbprint
-     */
-    static preProcess(cacheManager, thumbprint) {
-        const key = ThrottlingUtils.generateThrottlingStorageKey(thumbprint);
-        const value = cacheManager.getThrottlingCache(key);
-        if (value) {
-            if (value.throttleTime < Date.now()) {
-                cacheManager.removeItem(key);
-                return;
-            }
-            throw new ServerError(value.errorCodes?.join(" ") || Constants.EMPTY_STRING, value.errorMessage, value.subError);
-        }
-    }
-    /**
-     * Performs necessary throttling checks after a network request.
-     * @param cacheManager
-     * @param thumbprint
-     * @param response
-     */
-    static postProcess(cacheManager, thumbprint, response) {
-        if (ThrottlingUtils.checkResponseStatus(response) ||
-            ThrottlingUtils.checkResponseForRetryAfter(response)) {
-            const thumbprintValue = {
-                throttleTime: ThrottlingUtils.calculateThrottleTime(parseInt(response.headers[HeaderNames.RETRY_AFTER])),
-                error: response.body.error,
-                errorCodes: response.body.error_codes,
-                errorMessage: response.body.error_description,
-                subError: response.body.suberror,
-            };
-            cacheManager.setThrottlingCache(ThrottlingUtils.generateThrottlingStorageKey(thumbprint), thumbprintValue);
-        }
-    }
-    /**
-     * Checks a NetworkResponse object's status codes against 429 or 5xx
-     * @param response
-     */
-    static checkResponseStatus(response) {
-        return (response.status === 429 ||
-            (response.status >= 500 && response.status < 600));
-    }
-    /**
-     * Checks a NetworkResponse object's RetryAfter header
-     * @param response
-     */
-    static checkResponseForRetryAfter(response) {
-        if (response.headers) {
-            return (response.headers.hasOwnProperty(HeaderNames.RETRY_AFTER) &&
-                (response.status < 200 || response.status >= 300));
-        }
-        return false;
-    }
-    /**
-     * Calculates the Unix-time value for a throttle to expire given throttleTime in seconds.
-     * @param throttleTime
-     */
-    static calculateThrottleTime(throttleTime) {
-        const time = throttleTime <= 0 ? 0 : throttleTime;
-        const currentSeconds = Date.now() / 1000;
-        return Math.floor(Math.min(currentSeconds +
-            (time || ThrottlingConstants.DEFAULT_THROTTLE_TIME_SECONDS), currentSeconds +
-            ThrottlingConstants.DEFAULT_MAX_THROTTLE_TIME_SECONDS) * 1000);
-    }
-    static removeThrottle(cacheManager, clientId, request, homeAccountIdentifier) {
-        const thumbprint = {
-            clientId: clientId,
-            authority: request.authority,
-            scopes: request.scopes,
-            homeAccountIdentifier: homeAccountIdentifier,
-            claims: request.claims,
-            authenticationScheme: request.authenticationScheme,
-            resourceRequestMethod: request.resourceRequestMethod,
-            resourceRequestUri: request.resourceRequestUri,
-            shrClaims: request.shrClaims,
-            sshKid: request.sshKid,
-        };
-        const key = this.generateThrottlingStorageKey(thumbprint);
-        cacheManager.removeItem(key);
-    }
-}
-
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/** @internal */
-class NetworkManager {
-    constructor(networkClient, cacheManager) {
-        this.networkClient = networkClient;
-        this.cacheManager = cacheManager;
-    }
-    /**
-     * Wraps sendPostRequestAsync with necessary preflight and postflight logic
-     * @param thumbprint
-     * @param tokenEndpoint
-     * @param options
-     */
-    async sendPostRequest(thumbprint, tokenEndpoint, options) {
-        ThrottlingUtils.preProcess(this.cacheManager, thumbprint);
-        let response;
-        try {
-            response = await this.networkClient.sendPostRequestAsync(tokenEndpoint, options);
-        }
-        catch (e) {
-            if (e instanceof AuthError) {
-                throw e;
-            }
-            else {
-                throw createClientAuthError(networkError);
-            }
-        }
-        ThrottlingUtils.postProcess(this.cacheManager, thumbprint, response);
-        return response;
-    }
-}
-
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
@@ -6016,10 +5854,24 @@ class RequestValidator {
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
+function instrumentBrokerParams(parameters, correlationId, performanceClient) {
+    if (!correlationId) {
+        return;
+    }
+    const clientId = parameters.get(CLIENT_ID);
+    if (clientId && parameters.has(BROKER_CLIENT_ID)) {
+        performanceClient?.addFields({
+            embeddedClientId: clientId,
+            embeddedRedirectUri: parameters.get(REDIRECT_URI),
+        }, correlationId);
+    }
+}
 /** @internal */
 class RequestParameterBuilder {
-    constructor() {
+    constructor(correlationId, performanceClient) {
         this.parameters = new Map();
+        this.performanceClient = performanceClient;
+        this.correlationId = correlationId;
     }
     /**
      * add response_type = code
@@ -6383,6 +6235,14 @@ class RequestParameterBuilder {
     addLogoutHint(logoutHint) {
         this.parameters.set(LOGOUT_HINT, encodeURIComponent(logoutHint));
     }
+    addBrokerParameters(params) {
+        const brokerParams = {};
+        brokerParams[BROKER_CLIENT_ID] =
+            params.brokerClientId;
+        brokerParams[BROKER_REDIRECT_URI] =
+            params.brokerRedirectUri;
+        this.addExtraQueryParameters(brokerParams);
+    }
     /**
      * Utility to create a URL from the params map
      */
@@ -6391,6 +6251,7 @@ class RequestParameterBuilder {
         this.parameters.forEach((value, key) => {
             queryParameterArray.push(`${key}=${value}`);
         });
+        instrumentBrokerParams(this.parameters, this.correlationId, this.performanceClient);
         return queryParameterArray.join("&");
     }
 }
@@ -6400,71 +6261,206 @@ class RequestParameterBuilder {
  * Licensed under the MIT License.
  */
 /**
- * Base application class which will construct requests to send to and handle responses from the Microsoft STS using the authorization code flow.
- * @internal
+ * Error thrown when there is an error with the server code, for example, unavailability.
  */
-class BaseClient {
-    constructor(configuration, performanceClient) {
-        // Set the configuration
-        this.config = buildClientConfiguration(configuration);
-        // Initialize the logger
-        this.logger = new Logger(this.config.loggerOptions, name, version);
-        // Initialize crypto
-        this.cryptoUtils = this.config.cryptoInterface;
-        // Initialize storage interface
-        this.cacheManager = this.config.storageInterface;
-        // Set the network interface
-        this.networkClient = this.config.networkInterface;
-        // Set the NetworkManager
-        this.networkManager = new NetworkManager(this.networkClient, this.cacheManager);
-        // Set TelemetryManager
-        this.serverTelemetryManager = this.config.serverTelemetryManager;
-        // set Authority
-        this.authority = this.config.authOptions.authority;
-        // set performance telemetry client
-        this.performanceClient = performanceClient;
+class ServerError extends AuthError {
+    constructor(errorCode, errorMessage, subError, errorNo, status) {
+        super(errorCode, errorMessage, subError);
+        this.name = "ServerError";
+        this.errorNo = errorNo;
+        this.status = status;
+        Object.setPrototypeOf(this, ServerError.prototype);
     }
+}
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/** @internal */
+class ThrottlingUtils {
     /**
-     * Creates default headers for requests to token endpoint
+     * Prepares a RequestThumbprint to be stored as a key.
+     * @param thumbprint
      */
-    createTokenRequestHeaders(ccsCred) {
-        const headers = {};
-        headers[HeaderNames.CONTENT_TYPE] = Constants.URL_FORM_CONTENT_TYPE;
-        if (!this.config.systemOptions.preventCorsPreflight && ccsCred) {
-            switch (ccsCred.type) {
-                case CcsCredentialType.HOME_ACCOUNT_ID:
-                    try {
-                        const clientInfo = buildClientInfoFromHomeAccountId(ccsCred.credential);
-                        headers[HeaderNames.CCS_HEADER] = `Oid:${clientInfo.uid}@${clientInfo.utid}`;
-                    }
-                    catch (e) {
-                        this.logger.verbose("Could not parse home account ID for CCS Header: " +
-                            e);
-                    }
-                    break;
-                case CcsCredentialType.UPN:
-                    headers[HeaderNames.CCS_HEADER] = `UPN: ${ccsCred.credential}`;
-                    break;
-            }
-        }
-        return headers;
+    static generateThrottlingStorageKey(thumbprint) {
+        return `${ThrottlingConstants.THROTTLING_PREFIX}.${JSON.stringify(thumbprint)}`;
     }
     /**
-     * Http post to token endpoint
-     * @param tokenEndpoint
-     * @param queryString
-     * @param headers
+     * Performs necessary throttling checks before a network request.
+     * @param cacheManager
      * @param thumbprint
      */
-    async executePostToTokenEndpoint(tokenEndpoint, queryString, headers, thumbprint, correlationId, queuedEvent) {
-        if (queuedEvent) {
-            this.performanceClient?.addQueueMeasurement(queuedEvent, correlationId);
+    static preProcess(cacheManager, thumbprint) {
+        const key = ThrottlingUtils.generateThrottlingStorageKey(thumbprint);
+        const value = cacheManager.getThrottlingCache(key);
+        if (value) {
+            if (value.throttleTime < Date.now()) {
+                cacheManager.removeItem(key);
+                return;
+            }
+            throw new ServerError(value.errorCodes?.join(" ") || Constants.EMPTY_STRING, value.errorMessage, value.subError);
         }
-        const response = await this.networkManager.sendPostRequest(thumbprint, tokenEndpoint, { body: queryString, headers: headers });
-        this.performanceClient?.addFields({
-            refreshTokenSize: response.body.refresh_token?.length || 0,
-            httpVerToken: response.headers?.[HeaderNames.X_MS_HTTP_VERSION] || "",
-        }, correlationId);
+    }
+    /**
+     * Performs necessary throttling checks after a network request.
+     * @param cacheManager
+     * @param thumbprint
+     * @param response
+     */
+    static postProcess(cacheManager, thumbprint, response) {
+        if (ThrottlingUtils.checkResponseStatus(response) ||
+            ThrottlingUtils.checkResponseForRetryAfter(response)) {
+            const thumbprintValue = {
+                throttleTime: ThrottlingUtils.calculateThrottleTime(parseInt(response.headers[HeaderNames.RETRY_AFTER])),
+                error: response.body.error,
+                errorCodes: response.body.error_codes,
+                errorMessage: response.body.error_description,
+                subError: response.body.suberror,
+            };
+            cacheManager.setThrottlingCache(ThrottlingUtils.generateThrottlingStorageKey(thumbprint), thumbprintValue);
+        }
+    }
+    /**
+     * Checks a NetworkResponse object's status codes against 429 or 5xx
+     * @param response
+     */
+    static checkResponseStatus(response) {
+        return (response.status === 429 ||
+            (response.status >= 500 && response.status < 600));
+    }
+    /**
+     * Checks a NetworkResponse object's RetryAfter header
+     * @param response
+     */
+    static checkResponseForRetryAfter(response) {
+        if (response.headers) {
+            return (response.headers.hasOwnProperty(HeaderNames.RETRY_AFTER) &&
+                (response.status < 200 || response.status >= 300));
+        }
+        return false;
+    }
+    /**
+     * Calculates the Unix-time value for a throttle to expire given throttleTime in seconds.
+     * @param throttleTime
+     */
+    static calculateThrottleTime(throttleTime) {
+        const time = throttleTime <= 0 ? 0 : throttleTime;
+        const currentSeconds = Date.now() / 1000;
+        return Math.floor(Math.min(currentSeconds +
+            (time || ThrottlingConstants.DEFAULT_THROTTLE_TIME_SECONDS), currentSeconds +
+            ThrottlingConstants.DEFAULT_MAX_THROTTLE_TIME_SECONDS) * 1000);
+    }
+    static removeThrottle(cacheManager, clientId, request, homeAccountIdentifier) {
+        const thumbprint = {
+            clientId: clientId,
+            authority: request.authority,
+            scopes: request.scopes,
+            homeAccountIdentifier: homeAccountIdentifier,
+            claims: request.claims,
+            authenticationScheme: request.authenticationScheme,
+            resourceRequestMethod: request.resourceRequestMethod,
+            resourceRequestUri: request.resourceRequestUri,
+            shrClaims: request.shrClaims,
+            sshKid: request.sshKid,
+        };
+        const key = this.generateThrottlingStorageKey(thumbprint);
+        cacheManager.removeItem(key);
+    }
+}
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Represents network related errors
+ */
+class NetworkError extends AuthError {
+    constructor(error, httpStatus, responseHeaders) {
+        super(error.errorCode, error.errorMessage, error.subError);
+        Object.setPrototypeOf(this, NetworkError.prototype);
+        this.name = "NetworkError";
+        this.error = error;
+        this.httpStatus = httpStatus;
+        this.responseHeaders = responseHeaders;
+    }
+}
+/**
+ * Creates NetworkError object for a failed network request
+ * @param error - Error to be thrown back to the caller
+ * @param httpStatus - Status code of the network request
+ * @param responseHeaders - Response headers of the network request, when available
+ * @returns NetworkError object
+ */
+function createNetworkError(error, httpStatus, responseHeaders) {
+    return new NetworkError(error, httpStatus, responseHeaders);
+}
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Base application class which will construct requests to send to and handle responses from the Microsoft STS using the authorization code flow.
+ * @internal
+ */
+class BaseClient {
+    constructor(configuration, performanceClient) {
+        // Set the configuration
+        this.config = buildClientConfiguration(configuration);
+        // Initialize the logger
+        this.logger = new Logger(this.config.loggerOptions, name, version);
+        // Initialize crypto
+        this.cryptoUtils = this.config.cryptoInterface;
+        // Initialize storage interface
+        this.cacheManager = this.config.storageInterface;
+        // Set the network interface
+        this.networkClient = this.config.networkInterface;
+        // Set TelemetryManager
+        this.serverTelemetryManager = this.config.serverTelemetryManager;
+        // set Authority
+        this.authority = this.config.authOptions.authority;
+        // set performance telemetry client
+        this.performanceClient = performanceClient;
+    }
+    /**
+     * Creates default headers for requests to token endpoint
+     */
+    createTokenRequestHeaders(ccsCred) {
+        const headers = {};
+        headers[HeaderNames.CONTENT_TYPE] = Constants.URL_FORM_CONTENT_TYPE;
+        if (!this.config.systemOptions.preventCorsPreflight && ccsCred) {
+            switch (ccsCred.type) {
+                case CcsCredentialType.HOME_ACCOUNT_ID:
+                    try {
+                        const clientInfo = buildClientInfoFromHomeAccountId(ccsCred.credential);
+                        headers[HeaderNames.CCS_HEADER] = `Oid:${clientInfo.uid}@${clientInfo.utid}`;
+                    }
+                    catch (e) {
+                        this.logger.verbose("Could not parse home account ID for CCS Header: " +
+                            e);
+                    }
+                    break;
+                case CcsCredentialType.UPN:
+                    headers[HeaderNames.CCS_HEADER] = `UPN: ${ccsCred.credential}`;
+                    break;
+            }
+        }
+        return headers;
+    }
+    /**
+     * Http post to token endpoint
+     * @param tokenEndpoint
+     * @param queryString
+     * @param headers
+     * @param thumbprint
+     */
+    async executePostToTokenEndpoint(tokenEndpoint, queryString, headers, thumbprint, correlationId, queuedEvent) {
+        if (queuedEvent) {
+            this.performanceClient?.addQueueMeasurement(queuedEvent, correlationId);
+        }
+        const response = await this.sendPostRequest(thumbprint, tokenEndpoint, { body: queryString, headers: headers }, correlationId);
         if (this.config.serverTelemetryManager &&
             response.status < 500 &&
             response.status !== 429) {
@@ -6473,6 +6469,52 @@ class BaseClient {
         }
         return response;
     }
+    /**
+     * Wraps sendPostRequestAsync with necessary preflight and postflight logic
+     * @param thumbprint - Request thumbprint for throttling
+     * @param tokenEndpoint - Endpoint to make the POST to
+     * @param options - Body and Headers to include on the POST request
+     * @param correlationId - CorrelationId for telemetry
+     */
+    async sendPostRequest(thumbprint, tokenEndpoint, options, correlationId) {
+        ThrottlingUtils.preProcess(this.cacheManager, thumbprint);
+        let response;
+        try {
+            response = await invokeAsync((this.networkClient.sendPostRequestAsync.bind(this.networkClient)), PerformanceEvents.NetworkClientSendPostRequestAsync, this.logger, this.performanceClient, correlationId)(tokenEndpoint, options);
+            const responseHeaders = response.headers || {};
+            this.performanceClient?.addFields({
+                refreshTokenSize: response.body.refresh_token?.length || 0,
+                httpVerToken: responseHeaders[HeaderNames.X_MS_HTTP_VERSION] || "",
+                requestId: responseHeaders[HeaderNames.X_MS_REQUEST_ID] || "",
+            }, correlationId);
+        }
+        catch (e) {
+            if (e instanceof NetworkError) {
+                const responseHeaders = e.responseHeaders;
+                if (responseHeaders) {
+                    this.performanceClient?.addFields({
+                        httpVerToken: responseHeaders[HeaderNames.X_MS_HTTP_VERSION] || "",
+                        requestId: responseHeaders[HeaderNames.X_MS_REQUEST_ID] ||
+                            "",
+                        contentTypeHeader: responseHeaders[HeaderNames.CONTENT_TYPE] ||
+                            undefined,
+                        contentLengthHeader: responseHeaders[HeaderNames.CONTENT_LENGTH] ||
+                            undefined,
+                        httpStatus: e.httpStatus,
+                    }, correlationId);
+                }
+                throw e.error;
+            }
+            if (e instanceof AuthError) {
+                throw e;
+            }
+            else {
+                throw createClientAuthError(networkError);
+            }
+        }
+        ThrottlingUtils.postProcess(this.cacheManager, thumbprint, response);
+        return response;
+    }
     /**
      * Updates the authority object of the client. Endpoint discovery must be completed.
      * @param updatedAuthority
@@ -6488,10 +6530,17 @@ class BaseClient {
      * @param request
      */
     createTokenQueryParameters(request) {
-        const parameterBuilder = new RequestParameterBuilder();
+        const parameterBuilder = new RequestParameterBuilder(request.correlationId, this.performanceClient);
+        if (request.embeddedClientId) {
+            parameterBuilder.addBrokerParameters({
+                brokerClientId: this.config.authOptions.clientId,
+                brokerRedirectUri: this.config.authOptions.redirectUri,
+            });
+        }
         if (request.tokenQueryParameters) {
             parameterBuilder.addExtraQueryParameters(request.tokenQueryParameters);
         }
+        parameterBuilder.addCorrelationId(request.correlationId);
         return parameterBuilder.createQueryString();
     }
 }
@@ -7160,6 +7209,28 @@ function buildAccountToCache(cacheStorage, authority, homeAccountId, base64Decod
     return baseAccount;
 }
 
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+async function getClientAssertion(clientAssertion, clientId, tokenEndpoint) {
+    if (typeof clientAssertion === "string") {
+        return clientAssertion;
+    }
+    else {
+        const config = {
+            clientId: clientId,
+            tokenEndpoint: tokenEndpoint,
+        };
+        return clientAssertion(config);
+    }
+}
+
+var ClientAssertionUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getClientAssertion: getClientAssertion
+});
+
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
@@ -7284,8 +7355,9 @@ class AuthorizationCodeClient extends BaseClient {
      */
     async createTokenRequestBody(request) {
         this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthClientCreateTokenRequestBody, request.correlationId);
-        const parameterBuilder = new RequestParameterBuilder();
-        parameterBuilder.addClientId(request.tokenBodyParameters?.[CLIENT_ID] ||
+        const parameterBuilder = new RequestParameterBuilder(request.correlationId, this.performanceClient);
+        parameterBuilder.addClientId(request.embeddedClientId ||
+            request.tokenBodyParameters?.[CLIENT_ID] ||
             this.config.authOptions.clientId);
         /*
          * For hybrid spa flow, there will be a code but no verifier
@@ -7345,9 +7417,6 @@ class AuthorizationCodeClient extends BaseClient {
                 throw createClientConfigurationError(missingSshJwk);
             }
         }
-        const correlationId = request.correlationId ||
-            this.config.cryptoInterface.createNewGuid();
-        parameterBuilder.addCorrelationId(correlationId);
         if (!StringUtils.isEmptyObj(request.claims) ||
             (this.config.authOptions.clientCapabilities &&
                 this.config.authOptions.clientCapabilities.length > 0)) {
@@ -7387,6 +7456,12 @@ class AuthorizationCodeClient extends BaseClient {
                     break;
             }
         }
+        if (request.embeddedClientId) {
+            parameterBuilder.addBrokerParameters({
+                brokerClientId: this.config.authOptions.clientId,
+                brokerRedirectUri: this.config.authOptions.redirectUri,
+            });
+        }
         if (request.tokenBodyParameters) {
             parameterBuilder.addExtraQueryParameters(request.tokenBodyParameters);
         }
@@ -7405,9 +7480,13 @@ class AuthorizationCodeClient extends BaseClient {
      * @param request
      */
     async createAuthCodeUrlQueryString(request) {
-        this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthClientCreateQueryString, request.correlationId);
-        const parameterBuilder = new RequestParameterBuilder();
-        parameterBuilder.addClientId(request.extraQueryParameters?.[CLIENT_ID] ||
+        // generate the correlationId if not set by the user and add
+        const correlationId = request.correlationId ||
+            this.config.cryptoInterface.createNewGuid();
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.AuthClientCreateQueryString, correlationId);
+        const parameterBuilder = new RequestParameterBuilder(correlationId, this.performanceClient);
+        parameterBuilder.addClientId(request.embeddedClientId ||
+            request.extraQueryParameters?.[CLIENT_ID] ||
             this.config.authOptions.clientId);
         const requestScopes = [
             ...(request.scopes || []),
@@ -7416,9 +7495,6 @@ class AuthorizationCodeClient extends BaseClient {
         parameterBuilder.addScopes(requestScopes, true, this.oidcDefaultScopes);
         // validate the redirectUri (to be a non null value)
         parameterBuilder.addRedirectUri(request.redirectUri);
-        // generate the correlationId if not set by the user and add
-        const correlationId = request.correlationId ||
-            this.config.cryptoInterface.createNewGuid();
         parameterBuilder.addCorrelationId(correlationId);
         // add response_mode. If not passed in it defaults to query.
         parameterBuilder.addResponseMode(request.responseMode);
@@ -7520,9 +7596,13 @@ class AuthorizationCodeClient extends BaseClient {
                 this.config.authOptions.clientCapabilities.length > 0)) {
             parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);
         }
-        if (request.extraQueryParameters) {
-            parameterBuilder.addExtraQueryParameters(request.extraQueryParameters);
+        if (request.embeddedClientId) {
+            parameterBuilder.addBrokerParameters({
+                brokerClientId: this.config.authOptions.clientId,
+                brokerRedirectUri: this.config.authOptions.redirectUri,
+            });
         }
+        this.addExtraQueryParams(request, parameterBuilder);
         if (request.nativeBroker) {
             // signal ests that this is a WAM call
             parameterBuilder.addNativeBroker();
@@ -7548,7 +7628,7 @@ class AuthorizationCodeClient extends BaseClient {
      * @param request
      */
     createLogoutUrlQueryString(request) {
-        const parameterBuilder = new RequestParameterBuilder();
+        const parameterBuilder = new RequestParameterBuilder(request.correlationId, this.performanceClient);
         if (request.postLogoutRedirectUri) {
             parameterBuilder.addPostLogoutRedirectUri(request.postLogoutRedirectUri);
         }
@@ -7564,10 +7644,20 @@ class AuthorizationCodeClient extends BaseClient {
         if (request.logoutHint) {
             parameterBuilder.addLogoutHint(request.logoutHint);
         }
+        this.addExtraQueryParams(request, parameterBuilder);
+        return parameterBuilder.createQueryString();
+    }
+    addExtraQueryParams(request, parameterBuilder) {
+        const hasRequestInstanceAware = request.extraQueryParameters &&
+            request.extraQueryParameters.hasOwnProperty("instance_aware");
+        // Set instance_aware flag if config auth param is set
+        if (!hasRequestInstanceAware && this.config.authOptions.instanceAware) {
+            request.extraQueryParameters = request.extraQueryParameters || {};
+            request.extraQueryParameters["instance_aware"] = "true";
+        }
         if (request.extraQueryParameters) {
             parameterBuilder.addExtraQueryParameters(request.extraQueryParameters);
         }
-        return parameterBuilder.createQueryString();
     }
     /**
      * Helper to get sid from account. Returns null if idTokenClaims are not present or sid is not present.
@@ -7717,8 +7807,9 @@ class RefreshTokenClient extends BaseClient {
     async createTokenRequestBody(request) {
         this.performanceClient?.addQueueMeasurement(PerformanceEvents.RefreshTokenClientCreateTokenRequestBody, request.correlationId);
         const correlationId = request.correlationId;
-        const parameterBuilder = new RequestParameterBuilder();
-        parameterBuilder.addClientId(request.tokenBodyParameters?.[CLIENT_ID] ||
+        const parameterBuilder = new RequestParameterBuilder(correlationId, this.performanceClient);
+        parameterBuilder.addClientId(request.embeddedClientId ||
+            request.tokenBodyParameters?.[CLIENT_ID] ||
             this.config.authOptions.clientId);
         if (request.redirectUri) {
             parameterBuilder.addRedirectUri(request.redirectUri);
@@ -7732,7 +7823,6 @@ class RefreshTokenClient extends BaseClient {
         if (this.serverTelemetryManager && !isOidcProtocolMode(this.config)) {
             parameterBuilder.addServerTelemetry(this.serverTelemetryManager);
         }
-        parameterBuilder.addCorrelationId(correlationId);
         parameterBuilder.addRefreshToken(request.refreshToken);
         if (this.config.clientCredentials.clientSecret) {
             parameterBuilder.addClientSecret(this.config.clientCredentials.clientSecret);
@@ -7786,6 +7876,12 @@ class RefreshTokenClient extends BaseClient {
                     break;
             }
         }
+        if (request.embeddedClientId) {
+            parameterBuilder.addBrokerParameters({
+                brokerClientId: this.config.authOptions.clientId,
+                brokerRedirectUri: this.config.authOptions.redirectUri,
+            });
+        }
         if (request.tokenBodyParameters) {
             parameterBuilder.addExtraQueryParameters(request.tokenBodyParameters);
         }
@@ -7940,74 +8036,6 @@ const StubbedNetworkModule = {
     },
 };
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-const missingKidError = "missing_kid_error";
-const missingAlgError = "missing_alg_error";
-
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-const JoseHeaderErrorMessages = {
-    [missingKidError]: "The JOSE Header for the requested JWT, JWS or JWK object requires a keyId to be configured as the 'kid' header claim. No 'kid' value was provided.",
-    [missingAlgError]: "The JOSE Header for the requested JWT, JWS or JWK object requires an algorithm to be specified as the 'alg' header claim. No 'alg' value was provided.",
-};
-/**
- * Error thrown when there is an error in the client code running on the browser.
- */
-class JoseHeaderError extends AuthError {
-    constructor(errorCode, errorMessage) {
-        super(errorCode, errorMessage);
-        this.name = "JoseHeaderError";
-        Object.setPrototypeOf(this, JoseHeaderError.prototype);
-    }
-}
-/** Returns JoseHeaderError object */
-function createJoseHeaderError(code) {
-    return new JoseHeaderError(code, JoseHeaderErrorMessages[code]);
-}
-
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/** @internal */
-class JoseHeader {
-    constructor(options) {
-        this.typ = options.typ;
-        this.alg = options.alg;
-        this.kid = options.kid;
-    }
-    /**
-     * Builds SignedHttpRequest formatted JOSE Header from the
-     * JOSE Header options provided or previously set on the object and returns
-     * the stringified header object.
-     * Throws if keyId or algorithm aren't provided since they are required for Access Token Binding.
-     * @param shrHeaderOptions
-     * @returns
-     */
-    static getShrHeaderString(shrHeaderOptions) {
-        // KeyID is required on the SHR header
-        if (!shrHeaderOptions.kid) {
-            throw createJoseHeaderError(missingKidError);
-        }
-        // Alg is required on the SHR header
-        if (!shrHeaderOptions.alg) {
-            throw createJoseHeaderError(missingAlgError);
-        }
-        const shrHeader = new JoseHeader({
-            // Access Token PoP headers must have type pop, but the type header can be overriden for special cases
-            typ: shrHeaderOptions.typ || JsonWebTokenTypes.Pop,
-            kid: shrHeaderOptions.kid,
-            alg: shrHeaderOptions.alg,
-        });
-        return JSON.stringify(shrHeader);
-    }
-}
-
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
@@ -8325,671 +8353,6 @@ class ServerTelemetryManager {
     }
 }
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class StubPerformanceMeasurement {
-    startMeasurement() {
-        return;
-    }
-    endMeasurement() {
-        return;
-    }
-    flushMeasurement() {
-        return null;
-    }
-}
-class StubPerformanceClient {
-    generateId() {
-        return "callback-id";
-    }
-    startMeasurement(measureName, correlationId) {
-        return {
-            end: () => null,
-            discard: () => { },
-            add: () => { },
-            increment: () => { },
-            event: {
-                eventId: this.generateId(),
-                status: PerformanceEventStatus.InProgress,
-                authority: "",
-                libraryName: "",
-                libraryVersion: "",
-                clientId: "",
-                name: measureName,
-                startTimeMs: Date.now(),
-                correlationId: correlationId || "",
-            },
-            measurement: new StubPerformanceMeasurement(),
-        };
-    }
-    startPerformanceMeasurement() {
-        return new StubPerformanceMeasurement();
-    }
-    calculateQueuedTime() {
-        return 0;
-    }
-    addQueueMeasurement() {
-        return;
-    }
-    setPreQueueTime() {
-        return;
-    }
-    endMeasurement() {
-        return null;
-    }
-    discardMeasurements() {
-        return;
-    }
-    removePerformanceCallback() {
-        return true;
-    }
-    addPerformanceCallback() {
-        return "";
-    }
-    emitEvents() {
-        return;
-    }
-    addFields() {
-        return;
-    }
-    incrementFields() {
-        return;
-    }
-    cacheEventByCorrelationId() {
-        return;
-    }
-}
-
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Starts context by adding payload to the stack
- * @param event {PerformanceEvent}
- * @param abbreviations {Map<string, string>} event name abbreviations
- * @param stack {?PerformanceEventStackedContext[]} stack
- */
-function startContext(event, abbreviations, stack) {
-    if (!stack) {
-        return;
-    }
-    stack.push({
-        name: abbreviations.get(event.name) || event.name,
-    });
-}
-/**
- * Ends context by removing payload from the stack and returning parent or self, if stack is empty, payload
- *
- * @param event {PerformanceEvent}
- * @param abbreviations {Map<string, string>} event name abbreviations
- * @param stack {?PerformanceEventStackedContext[]} stack
- * @param error {?unknown} error
- */
-function endContext(event, abbreviations, stack, error) {
-    if (!stack?.length) {
-        return;
-    }
-    const peek = (stack) => {
-        return stack.length ? stack[stack.length - 1] : undefined;
-    };
-    const abbrEventName = abbreviations.get(event.name) || event.name;
-    const top = peek(stack);
-    if (top?.name !== abbrEventName) {
-        return;
-    }
-    const current = stack?.pop();
-    if (!current) {
-        return;
-    }
-    const errorCode = error instanceof AuthError
-        ? error.errorCode
-        : error instanceof Error
-            ? error.name
-            : undefined;
-    const subErr = error instanceof AuthError ? error.subError : undefined;
-    if (errorCode && current.childErr !== errorCode) {
-        current.err = errorCode;
-        if (subErr) {
-            current.subErr = subErr;
-        }
-    }
-    delete current.name;
-    delete current.childErr;
-    const context = {
-        ...current,
-        dur: event.durationMs,
-    };
-    if (!event.success) {
-        context.fail = 1;
-    }
-    const parent = peek(stack);
-    if (!parent) {
-        return { [abbrEventName]: context };
-    }
-    if (errorCode) {
-        parent.childErr = errorCode;
-    }
-    let childName;
-    if (!parent[abbrEventName]) {
-        childName = abbrEventName;
-    }
-    else {
-        const siblings = Object.keys(parent).filter((key) => key.startsWith(abbrEventName)).length;
-        childName = `${abbrEventName}_${siblings + 1}`;
-    }
-    parent[childName] = context;
-    return parent;
-}
-/**
- * Adds error name and stack trace to the telemetry event
- * @param error {Error}
- * @param logger {Logger}
- * @param event {PerformanceEvent}
- * @param stackMaxSize {number} max error stack size to capture
- */
-function addError(error, logger, event, stackMaxSize = 5) {
-    if (!(error instanceof Error)) {
-        logger.trace("PerformanceClient.addErrorStack: Input error is not instance of Error", event.correlationId);
-        return;
-    }
-    else if (error instanceof AuthError) {
-        event.errorCode = error.errorCode;
-        event.subErrorCode = error.subError;
-        if (error instanceof ServerError ||
-            error instanceof InteractionRequiredAuthError) {
-            event.serverErrorNo = error.errorNo;
-        }
-        return;
-    }
-    else if (error instanceof CacheError) {
-        event.errorCode = error.errorCode;
-        return;
-    }
-    else if (event.errorStack?.length) {
-        logger.trace("PerformanceClient.addErrorStack: Stack already exist", event.correlationId);
-        return;
-    }
-    else if (!error.stack?.length) {
-        logger.trace("PerformanceClient.addErrorStack: Input stack is empty", event.correlationId);
-        return;
-    }
-    if (error.stack) {
-        event.errorStack = compactStack(error.stack, stackMaxSize);
-    }
-    event.errorName = error.name;
-}
-/**
- * Compacts error stack into array by fetching N first entries
- * @param stack {string} error stack
- * @param stackMaxSize {number} max error stack size to capture
- * @returns {string[]}
- */
-function compactStack(stack, stackMaxSize) {
-    if (stackMaxSize < 0) {
-        return [];
-    }
-    const stackArr = stack.split("\n") || [];
-    if (stackArr.length < 2) {
-        return [];
-    }
-    const res = [];
-    // Get top N stack lines
-    for (
-    // Skip first line as it may contain PII data
-    let ix = Math.max(stackArr.length - stackMaxSize - 1, 1); ix < stackArr.length; ix++) {
-        const line = stackArr[ix];
-        if (res.length >= stackMaxSize) {
-            break;
-        }
-        res.push(compactStackLine(line));
-    }
-    return res;
-}
-/**
- * Compacts error stack line by shortening file path
- * Example: https://localhost/msal-common/src/authority/Authority.js:100:1 -> Authority.js:100:1
- * @param line {string} stack line
- * @returns {string}
- */
-function compactStackLine(line) {
-    const filePathIx = line.lastIndexOf(" ") + 1;
-    if (filePathIx < 1) {
-        return line;
-    }
-    const filePath = line.substring(filePathIx);
-    let fileNameIx = filePath.lastIndexOf("/");
-    fileNameIx = fileNameIx < 0 ? filePath.lastIndexOf("\\") : fileNameIx;
-    if (fileNameIx >= 0) {
-        return (line.substring(0, filePathIx) +
-            "(" +
-            filePath.substring(fileNameIx + 1) +
-            (filePath.charAt(filePath.length - 1) === ")" ? "" : ")")).trimStart();
-    }
-    return line.trimStart();
-}
-class PerformanceClient {
-    /**
-     * Creates an instance of PerformanceClient,
-     * an abstract class containing core performance telemetry logic.
-     *
-     * @constructor
-     * @param {string} clientId Client ID of the application
-     * @param {string} authority Authority used by the application
-     * @param {Logger} logger Logger used by the application
-     * @param {string} libraryName Name of the library
-     * @param {string} libraryVersion Version of the library
-     * @param {ApplicationTelemetry} applicationTelemetry application name and version
-     * @param {Set<String>} intFields integer fields to be truncated
-     * @param {Map<string, string>} abbreviations event name abbreviations
-     */
-    constructor(clientId, authority, logger, libraryName, libraryVersion, applicationTelemetry, intFields, abbreviations) {
-        this.authority = authority;
-        this.libraryName = libraryName;
-        this.libraryVersion = libraryVersion;
-        this.applicationTelemetry = applicationTelemetry;
-        this.clientId = clientId;
-        this.logger = logger;
-        this.callbacks = new Map();
-        this.eventsByCorrelationId = new Map();
-        this.eventStack = new Map();
-        this.queueMeasurements = new Map();
-        this.preQueueTimeByCorrelationId = new Map();
-        this.intFields = intFields || new Set();
-        for (const item of IntFields) {
-            this.intFields.add(item);
-        }
-        this.abbreviations = abbreviations || new Map();
-        for (const [key, value] of PerformanceEventAbbreviations) {
-            this.abbreviations.set(key, value);
-        }
-    }
-    /**
-     * Starts and returns an platform-specific implementation of IPerformanceMeasurement.
-     * Note: this function can be changed to abstract at the next major version bump.
-     *
-     * @param {string} measureName
-     * @param {string} correlationId
-     * @returns {IPerformanceMeasurement}
-     * @deprecated This method will be removed in the next major version
-     */
-    startPerformanceMeasurement(measureName, // eslint-disable-line @typescript-eslint/no-unused-vars
-    correlationId // eslint-disable-line @typescript-eslint/no-unused-vars
-    ) {
-        return {};
-    }
-    /**
-     * Gets map of pre-queue times by correlation Id
-     *
-     * @param {PerformanceEvents} eventName
-     * @param {string} correlationId
-     * @returns {number}
-     */
-    getPreQueueTime(eventName, correlationId) {
-        const preQueueEvent = this.preQueueTimeByCorrelationId.get(correlationId);
-        if (!preQueueEvent) {
-            this.logger.trace(`PerformanceClient.getPreQueueTime: no pre-queue times found for correlationId: ${correlationId}, unable to add queue measurement`);
-            return;
-        }
-        else if (preQueueEvent.name !== eventName) {
-            this.logger.trace(`PerformanceClient.getPreQueueTime: no pre-queue time found for ${eventName}, unable to add queue measurement`);
-            return;
-        }
-        return preQueueEvent.time;
-    }
-    /**
-     * Calculates the difference between current time and time when function was queued.
-     * Note: It is possible to have 0 as the queue time if the current time and the queued time was the same.
-     *
-     * @param {number} preQueueTime
-     * @param {number} currentTime
-     * @returns {number}
-     */
-    calculateQueuedTime(preQueueTime, currentTime) {
-        if (preQueueTime < 1) {
-            this.logger.trace(`PerformanceClient: preQueueTime should be a positive integer and not ${preQueueTime}`);
-            return 0;
-        }
-        if (currentTime < 1) {
-            this.logger.trace(`PerformanceClient: currentTime should be a positive integer and not ${currentTime}`);
-            return 0;
-        }
-        if (currentTime < preQueueTime) {
-            this.logger.trace("PerformanceClient: currentTime is less than preQueueTime, check how time is being retrieved");
-            return 0;
-        }
-        return currentTime - preQueueTime;
-    }
-    /**
-     * Adds queue measurement time to QueueMeasurements array for given correlation ID.
-     *
-     * @param {PerformanceEvents} eventName
-     * @param {?string} correlationId
-     * @param {?number} queueTime
-     * @param {?boolean} manuallyCompleted - indicator for manually completed queue measurements
-     * @returns
-     */
-    addQueueMeasurement(eventName, correlationId, queueTime, manuallyCompleted) {
-        if (!correlationId) {
-            this.logger.trace(`PerformanceClient.addQueueMeasurement: correlationId not provided for ${eventName}, cannot add queue measurement`);
-            return;
-        }
-        if (queueTime === 0) {
-            // Possible for there to be no queue time after calculation
-            this.logger.trace(`PerformanceClient.addQueueMeasurement: queue time provided for ${eventName} is ${queueTime}`);
-        }
-        else if (!queueTime) {
-            this.logger.trace(`PerformanceClient.addQueueMeasurement: no queue time provided for ${eventName}`);
-            return;
-        }
-        const queueMeasurement = {
-            eventName,
-            // Always default queue time to 0 for manually completed (improperly instrumented)
-            queueTime: manuallyCompleted ? 0 : queueTime,
-            manuallyCompleted,
-        };
-        // Adds to existing correlation Id if present in queueMeasurements
-        const existingMeasurements = this.queueMeasurements.get(correlationId);
-        if (existingMeasurements) {
-            existingMeasurements.push(queueMeasurement);
-            this.queueMeasurements.set(correlationId, existingMeasurements);
-        }
-        else {
-            // Sets new correlation Id if not present in queueMeasurements
-            this.logger.trace(`PerformanceClient.addQueueMeasurement: adding correlationId ${correlationId} to queue measurements`);
-            const measurementArray = [queueMeasurement];
-            this.queueMeasurements.set(correlationId, measurementArray);
-        }
-        // Delete processed pre-queue event.
-        this.preQueueTimeByCorrelationId.delete(correlationId);
-    }
-    /**
-     * Starts measuring performance for a given operation. Returns a function that should be used to end the measurement.
-     *
-     * @param {PerformanceEvents} measureName
-     * @param {?string} [correlationId]
-     * @returns {InProgressPerformanceEvent}
-     */
-    startMeasurement(measureName, correlationId) {
-        // Generate a placeholder correlation if the request does not provide one
-        const eventCorrelationId = correlationId || this.generateId();
-        if (!correlationId) {
-            this.logger.info(`PerformanceClient: No correlation id provided for ${measureName}, generating`, eventCorrelationId);
-        }
-        this.logger.trace(`PerformanceClient: Performance measurement started for ${measureName}`, eventCorrelationId);
-        const inProgressEvent = {
-            eventId: this.generateId(),
-            status: PerformanceEventStatus.InProgress,
-            authority: this.authority,
-            libraryName: this.libraryName,
-            libraryVersion: this.libraryVersion,
-            clientId: this.clientId,
-            name: measureName,
-            startTimeMs: Date.now(),
-            correlationId: eventCorrelationId,
-            appName: this.applicationTelemetry?.appName,
-            appVersion: this.applicationTelemetry?.appVersion,
-        };
-        // Store in progress events so they can be discarded if not ended properly
-        this.cacheEventByCorrelationId(inProgressEvent);
-        startContext(inProgressEvent, this.abbreviations, this.eventStack.get(eventCorrelationId));
-        // Return the event and functions the caller can use to properly end/flush the measurement
-        return {
-            end: (event, error) => {
-                return this.endMeasurement({
-                    // Initial set of event properties
-                    ...inProgressEvent,
-                    // Properties set when event ends
-                    ...event,
-                }, error);
-            },
-            discard: () => {
-                return this.discardMeasurements(inProgressEvent.correlationId);
-            },
-            add: (fields) => {
-                return this.addFields(fields, inProgressEvent.correlationId);
-            },
-            increment: (fields) => {
-                return this.incrementFields(fields, inProgressEvent.correlationId);
-            },
-            event: inProgressEvent,
-            measurement: new StubPerformanceMeasurement(),
-        };
-    }
-    /**
-     * Stops measuring the performance for an operation. Should only be called directly by PerformanceClient classes,
-     * as consumers should instead use the function returned by startMeasurement.
-     * Adds a new field named as "[event name]DurationMs" for sub-measurements, completes and emits an event
-     * otherwise.
-     *
-     * @param {PerformanceEvent} event
-     * @param {unknown} error
-     * @returns {(PerformanceEvent | null)}
-     */
-    endMeasurement(event, error) {
-        const rootEvent = this.eventsByCorrelationId.get(event.correlationId);
-        if (!rootEvent) {
-            this.logger.trace(`PerformanceClient: Measurement not found for ${event.eventId}`, event.correlationId);
-            return null;
-        }
-        const isRoot = event.eventId === rootEvent.eventId;
-        let queueInfo = {
-            totalQueueTime: 0,
-            totalQueueCount: 0,
-            manuallyCompletedCount: 0,
-        };
-        event.durationMs = Math.round(event.durationMs || this.getDurationMs(event.startTimeMs));
-        const context = JSON.stringify(endContext(event, this.abbreviations, this.eventStack.get(rootEvent.correlationId), error));
-        if (isRoot) {
-            queueInfo = this.getQueueInfo(event.correlationId);
-            this.discardMeasurements(rootEvent.correlationId);
-        }
-        else {
-            rootEvent.incompleteSubMeasurements?.delete(event.eventId);
-        }
-        this.logger.trace(`PerformanceClient: Performance measurement ended for ${event.name}: ${event.durationMs} ms`, event.correlationId);
-        // Add sub-measurement attribute to root event.
-        if (!isRoot) {
-            rootEvent[event.name + "DurationMs"] = Math.floor(event.durationMs);
-            return { ...rootEvent };
-        }
-        if (error) {
-            addError(error, this.logger, rootEvent);
-        }
-        let finalEvent = { ...rootEvent, ...event };
-        let incompleteSubsCount = 0;
-        // Incomplete sub-measurements are discarded. They are likely an instrumentation bug that should be fixed.
-        finalEvent.incompleteSubMeasurements?.forEach((subMeasurement) => {
-            this.logger.trace(`PerformanceClient: Incomplete submeasurement ${subMeasurement.name} found for ${event.name}`, finalEvent.correlationId);
-            incompleteSubsCount++;
-        });
-        finalEvent.incompleteSubMeasurements = undefined;
-        finalEvent = {
-            ...finalEvent,
-            queuedTimeMs: queueInfo.totalQueueTime,
-            queuedCount: queueInfo.totalQueueCount,
-            queuedManuallyCompletedCount: queueInfo.manuallyCompletedCount,
-            status: PerformanceEventStatus.Completed,
-            incompleteSubsCount,
-            context,
-        };
-        this.truncateIntegralFields(finalEvent);
-        this.emitEvents([finalEvent], event.correlationId);
-        return finalEvent;
-    }
-    /**
-     * Saves extra information to be emitted when the measurements are flushed
-     * @param fields
-     * @param correlationId
-     */
-    addFields(fields, correlationId) {
-        this.logger.trace("PerformanceClient: Updating static fields");
-        const event = this.eventsByCorrelationId.get(correlationId);
-        if (event) {
-            this.eventsByCorrelationId.set(correlationId, {
-                ...event,
-                ...fields,
-            });
-        }
-        else {
-            this.logger.trace("PerformanceClient: Event not found for", correlationId);
-        }
-    }
-    /**
-     * Increment counters to be emitted when the measurements are flushed
-     * @param fields {string[]}
-     * @param correlationId {string} correlation identifier
-     */
-    incrementFields(fields, correlationId) {
-        this.logger.trace("PerformanceClient: Updating counters");
-        const event = this.eventsByCorrelationId.get(correlationId);
-        if (event) {
-            for (const counter in fields) {
-                if (!event.hasOwnProperty(counter)) {
-                    event[counter] = 0;
-                }
-                else if (isNaN(Number(event[counter]))) {
-                    return;
-                }
-                event[counter] += fields[counter];
-            }
-        }
-        else {
-            this.logger.trace("PerformanceClient: Event not found for", correlationId);
-        }
-    }
-    /**
-     * Upserts event into event cache.
-     * First key is the correlation id, second key is the event id.
-     * Allows for events to be grouped by correlation id,
-     * and to easily allow for properties on them to be updated.
-     *
-     * @private
-     * @param {PerformanceEvent} event
-     */
-    cacheEventByCorrelationId(event) {
-        const rootEvent = this.eventsByCorrelationId.get(event.correlationId);
-        if (rootEvent) {
-            this.logger.trace(`PerformanceClient: Performance measurement for ${event.name} added/updated`, event.correlationId);
-            rootEvent.incompleteSubMeasurements =
-                rootEvent.incompleteSubMeasurements || new Map();
-            rootEvent.incompleteSubMeasurements.set(event.eventId, {
-                name: event.name,
-                startTimeMs: event.startTimeMs,
-            });
-        }
-        else {
-            this.logger.trace(`PerformanceClient: Performance measurement for ${event.name} started`, event.correlationId);
-            this.eventsByCorrelationId.set(event.correlationId, { ...event });
-            this.eventStack.set(event.correlationId, []);
-        }
-    }
-    getQueueInfo(correlationId) {
-        const queueMeasurementForCorrelationId = this.queueMeasurements.get(correlationId);
-        if (!queueMeasurementForCorrelationId) {
-            this.logger.trace(`PerformanceClient: no queue measurements found for for correlationId: ${correlationId}`);
-        }
-        let totalQueueTime = 0;
-        let totalQueueCount = 0;
-        let manuallyCompletedCount = 0;
-        queueMeasurementForCorrelationId?.forEach((measurement) => {
-            totalQueueTime += measurement.queueTime;
-            totalQueueCount++;
-            manuallyCompletedCount += measurement.manuallyCompleted ? 1 : 0;
-        });
-        return {
-            totalQueueTime,
-            totalQueueCount,
-            manuallyCompletedCount,
-        };
-    }
-    /**
-     * Removes measurements and aux data for a given correlation id.
-     *
-     * @param {string} correlationId
-     */
-    discardMeasurements(correlationId) {
-        this.logger.trace("PerformanceClient: Performance measurements discarded", correlationId);
-        this.eventsByCorrelationId.delete(correlationId);
-        this.logger.trace("PerformanceClient: QueueMeasurements discarded", correlationId);
-        this.queueMeasurements.delete(correlationId);
-        this.logger.trace("PerformanceClient: Pre-queue times discarded", correlationId);
-        this.preQueueTimeByCorrelationId.delete(correlationId);
-        this.logger.trace("PerformanceClient: Event stack discarded", correlationId);
-        this.eventStack.delete(correlationId);
-    }
-    /**
-     * Registers a callback function to receive performance events.
-     *
-     * @param {PerformanceCallbackFunction} callback
-     * @returns {string}
-     */
-    addPerformanceCallback(callback) {
-        for (const [id, cb] of this.callbacks) {
-            if (cb.toString() === callback.toString()) {
-                this.logger.warning(`PerformanceClient: Performance callback is already registered with id: ${id}`);
-                return id;
-            }
-        }
-        const callbackId = this.generateId();
-        this.callbacks.set(callbackId, callback);
-        this.logger.verbose(`PerformanceClient: Performance callback registered with id: ${callbackId}`);
-        return callbackId;
-    }
-    /**
-     * Removes a callback registered with addPerformanceCallback.
-     *
-     * @param {string} callbackId
-     * @returns {boolean}
-     */
-    removePerformanceCallback(callbackId) {
-        const result = this.callbacks.delete(callbackId);
-        if (result) {
-            this.logger.verbose(`PerformanceClient: Performance callback ${callbackId} removed.`);
-        }
-        else {
-            this.logger.verbose(`PerformanceClient: Performance callback ${callbackId} not removed.`);
-        }
-        return result;
-    }
-    /**
-     * Emits events to all registered callbacks.
-     *
-     * @param {PerformanceEvent[]} events
-     * @param {?string} [correlationId]
-     */
-    emitEvents(events, correlationId) {
-        this.logger.verbose("PerformanceClient: Emitting performance events", correlationId);
-        this.callbacks.forEach((callback, callbackId) => {
-            this.logger.trace(`PerformanceClient: Emitting event to callback ${callbackId}`, correlationId);
-            callback.apply(null, [events]);
-        });
-    }
-    /**
-     * Enforce truncation of integral fields in performance event.
-     * @param {PerformanceEvent} event performance event to update.
-     */
-    truncateIntegralFields(event) {
-        this.intFields.forEach((key) => {
-            if (key in event && typeof event[key] === "number") {
-                event[key] = Math.floor(event[key]);
-            }
-        });
-    }
-    /**
-     * Returns event duration in milliseconds
-     * @param startTimeMs {number}
-     * @returns {number}
-     */
-    getDurationMs(startTimeMs) {
-        const durationMs = Date.now() - startTimeMs;
-        // Handle clock skew
-        return durationMs < 0 ? durationMs : 0;
-    }
-}
-
 exports.AADAuthorityConstants = AADAuthorityConstants;
 exports.AADServerParamKeys = AADServerParamKeys;
 exports.AccountEntity = AccountEntity;
@@ -9036,14 +8399,13 @@ exports.IntFields = IntFields;
 exports.InteractionRequiredAuthError = InteractionRequiredAuthError;
 exports.InteractionRequiredAuthErrorCodes = InteractionRequiredAuthErrorCodes;
 exports.InteractionRequiredAuthErrorMessage = InteractionRequiredAuthErrorMessage;
-exports.JoseHeader = JoseHeader;
 exports.JsonWebTokenTypes = JsonWebTokenTypes;
 exports.Logger = Logger;
-exports.NetworkManager = NetworkManager;
+exports.NetworkError = NetworkError;
 exports.OIDC_DEFAULT_SCOPES = OIDC_DEFAULT_SCOPES;
 exports.ONE_DAY_IN_MS = ONE_DAY_IN_MS;
 exports.PasswordGrantConstants = PasswordGrantConstants;
-exports.PerformanceClient = PerformanceClient;
+exports.PerformanceEventAbbreviations = PerformanceEventAbbreviations;
 exports.PerformanceEventStatus = PerformanceEventStatus;
 exports.PerformanceEvents = PerformanceEvents;
 exports.PersistentCacheKeys = PersistentCacheKeys;
@@ -9061,7 +8423,6 @@ exports.ServerResponseType = ServerResponseType;
 exports.ServerTelemetryManager = ServerTelemetryManager;
 exports.SilentFlowClient = SilentFlowClient;
 exports.StringUtils = StringUtils;
-exports.StubPerformanceClient = StubPerformanceClient;
 exports.StubbedNetworkModule = StubbedNetworkModule;
 exports.THE_FAMILY_ID = THE_FAMILY_ID;
 exports.ThrottlingConstants = ThrottlingConstants;
@@ -9079,6 +8440,7 @@ exports.createAuthError = createAuthError;
 exports.createClientAuthError = createClientAuthError;
 exports.createClientConfigurationError = createClientConfigurationError;
 exports.createInteractionRequiredAuthError = createInteractionRequiredAuthError;
+exports.createNetworkError = createNetworkError;
 exports.formatAuthorityUri = formatAuthorityUri;
 exports.getClientAssertion = getClientAssertion;
 exports.getTenantIdFromIdTokenClaims = getTenantIdFromIdTokenClaims;
@@ -9087,4 +8449,4 @@ exports.invokeAsync = invokeAsync;
 exports.tenantIdMatchesHomeTenant = tenantIdMatchesHomeTenant;
 exports.updateAccountTenantProfileData = updateAccountTenantProfileData;
 exports.version = version;
-//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index-node-C9XsExml.js.map