@azure/identity 2.0.2-alpha.20220106.1 → 2.0.3-alpha.20220211.2

package/dist/index.js

@@ -2,8 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
 var msalNode = require('@azure/msal-node');
 var coreTracing = require('@azure/core-tracing');
 var coreClient = require('@azure/core-client');
@@ -14,17 +12,47 @@ var logger$k = require('@azure/logger');
 var msalCommon = require('@azure/msal-common');
 var uuid = require('uuid');
 var fs = require('fs');
-var fs__default = _interopDefault(fs);
-var os = _interopDefault(require('os'));
-var path = _interopDefault(require('path'));
+var os = require('os');
+var path = require('path');
 var child_process = require('child_process');
-var child_process__default = _interopDefault(child_process);
 var crypto = require('crypto');
 var util = require('util');
-var https = _interopDefault(require('https'));
-var http = _interopDefault(require('http'));
-var open = _interopDefault(require('open'));
-var stoppable = _interopDefault(require('stoppable'));
+var https = require('https');
+var http = require('http');
+var open = require('open');
+var stoppable = require('stoppable');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var msalNode__namespace = /*#__PURE__*/_interopNamespace(msalNode);
+var msalCommon__namespace = /*#__PURE__*/_interopNamespace(msalCommon);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var child_process__default = /*#__PURE__*/_interopDefaultLegacy(child_process);
+var child_process__namespace = /*#__PURE__*/_interopNamespace(child_process);
+var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+var open__default = /*#__PURE__*/_interopDefaultLegacy(open);
+var stoppable__default = /*#__PURE__*/_interopDefaultLegacy(stoppable);
 
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
@@ -171,6 +199,10 @@ const DeveloperSignOnClientId = "04b07795-8ddb-461a-bbee-02f9e1bf7b46";
  * @internal
  */
 const DefaultTenantId = "common";
+/**
+ * A list of known Azure authority hosts
+ */
+exports.AzureAuthorityHosts = void 0;
 (function (AzureAuthorityHosts) {
     /**
      * China-based Azure Authority Host
@@ -241,7 +273,7 @@ async function trace(operationName, options, fn, createSpanFn = createSpan) {
 /**
  * The AzureLogger used for all clients within the identity package
  */
-const logger = logger$k.createClientLogger("identity");
+const logger$j = logger$k.createClientLogger("identity");
 /**
  * Separates a list of environment variable names into a plain object with two arrays: an array of missing environment variables and another array with assigned environment variables.
  * @param supportedEnvVars - List of environment variable names
@@ -281,15 +313,19 @@ function formatError(scope, error) {
  *   `[title] => [message]`
  *
  */
-function credentialLoggerInstance(title, parent, log = logger) {
+function credentialLoggerInstance(title, parent, log = logger$j) {
     const fullTitle = parent ? `${parent.fullTitle} ${title}` : title;
     function info(message) {
         log.info(`${fullTitle} =>`, message);
     }
+    function warning(message) {
+        log.warning(`${fullTitle} =>`, message);
+    }
     return {
         title,
         fullTitle,
         info,
+        warning,
     };
 }
 /**
@@ -302,7 +338,7 @@ function credentialLoggerInstance(title, parent, log = logger) {
  *   `[title] => getToken() => [message]`
  *
  */
-function credentialLogger(title, log = logger) {
+function credentialLogger(title, log = logger$j) {
     const credLogger = credentialLoggerInstance(title, undefined, log);
     return Object.assign(Object.assign({}, credLogger), { parent: log, getToken: credentialLoggerInstance("=> getToken()", credLogger, log) });
 }
@@ -332,7 +368,7 @@ function getIdentityClientAuthorityHost(options) {
 class IdentityClient extends coreClient.ServiceClient {
     constructor(options) {
         var _a;
-        const packageDetails = `azsdk-js-identity/2.0.2`;
+        const packageDetails = `azsdk-js-identity/2.0.3`;
         const userAgentPrefix = ((_a = options === null || options === void 0 ? void 0 : options.userAgentOptions) === null || _a === void 0 ? void 0 : _a.userAgentPrefix)
             ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
             : `${packageDetails}`;
@@ -347,7 +383,7 @@ class IdentityClient extends coreClient.ServiceClient {
         this.abortControllers = new Map();
     }
     async sendTokenRequest(request, expiresOnParser) {
-        logger.info(`IdentityClient: sending token request to [${request.url}]`);
+        logger$j.info(`IdentityClient: sending token request to [${request.url}]`);
         const response = await this.sendRequest(request);
         expiresOnParser =
             expiresOnParser ||
@@ -366,12 +402,12 @@ class IdentityClient extends coreClient.ServiceClient {
                 },
                 refreshToken: parsedBody.refresh_token,
             };
-            logger.info(`IdentityClient: [${request.url}] token acquired, expires on ${token.accessToken.expiresOnTimestamp}`);
+            logger$j.info(`IdentityClient: [${request.url}] token acquired, expires on ${token.accessToken.expiresOnTimestamp}`);
             return token;
         }
         else {
             const error = new AuthenticationError(response.status, response.bodyAsText);
-            logger.warning(`IdentityClient: authentication error. HTTP status: ${response.status}, ${error.errorResponse.errorDescription}`);
+            logger$j.warning(`IdentityClient: authentication error. HTTP status: ${response.status}, ${error.errorResponse.errorDescription}`);
             throw error;
         }
     }
@@ -379,7 +415,7 @@ class IdentityClient extends coreClient.ServiceClient {
         if (refreshToken === undefined) {
             return null;
         }
-        logger.info(`IdentityClient: refreshing access token with client ID: ${clientId}, scopes: ${scopes} started`);
+        logger$j.info(`IdentityClient: refreshing access token with client ID: ${clientId}, scopes: ${scopes} started`);
         const { span, updatedOptions } = createSpan("IdentityClient-refreshAccessToken", options);
         const refreshParams = {
             grant_type: "refresh_token",
@@ -405,7 +441,7 @@ class IdentityClient extends coreClient.ServiceClient {
                 tracingOptions: updatedOptions === null || updatedOptions === void 0 ? void 0 : updatedOptions.tracingOptions,
             });
             const response = await this.sendTokenRequest(request, expiresOnParser);
-            logger.info(`IdentityClient: refreshed token for client ID: ${clientId}`);
+            logger$j.info(`IdentityClient: refreshed token for client ID: ${clientId}`);
             return response;
         }
         catch (err) {
@@ -414,7 +450,7 @@ class IdentityClient extends coreClient.ServiceClient {
                 // It's likely that the refresh token has expired, so
                 // return null so that the credential implementation will
                 // initiate the authentication flow again.
-                logger.info(`IdentityClient: interaction required for client ID: ${clientId}`);
+                logger$j.info(`IdentityClient: interaction required for client ID: ${clientId}`);
                 span.setStatus({
                     code: coreTracing.SpanStatusCode.ERROR,
                     message: err.message,
@@ -422,7 +458,7 @@ class IdentityClient extends coreClient.ServiceClient {
                 return null;
             }
             else {
-                logger.warning(`IdentityClient: failed refreshing token for client ID: ${clientId}: ${err}`);
+                logger$j.warning(`IdentityClient: failed refreshing token for client ID: ${clientId}: ${err}`);
                 span.setStatus({
                     code: coreTracing.SpanStatusCode.ERROR,
                     message: err.message,
@@ -595,16 +631,16 @@ const defaultLoggerCallback = (logger, platform = coreUtil.isNode ? "Node" : "Br
         return;
     }
     switch (level) {
-        case msalCommon.LogLevel.Error:
+        case msalCommon__namespace.LogLevel.Error:
             logger.info(`MSAL ${platform} V2 error: ${message}`);
             return;
-        case msalCommon.LogLevel.Info:
+        case msalCommon__namespace.LogLevel.Info:
             logger.info(`MSAL ${platform} V2 info message: ${message}`);
             return;
-        case msalCommon.LogLevel.Verbose:
+        case msalCommon__namespace.LogLevel.Verbose:
             logger.info(`MSAL ${platform} V2 verbose message: ${message}`);
             return;
-        case msalCommon.LogLevel.Warning:
+        case msalCommon__namespace.LogLevel.Warning:
             logger.info(`MSAL ${platform} V2 warning: ${message}`);
             return;
     }
@@ -977,12 +1013,12 @@ class MsalNode extends MsalBaseUtilities {
                 cachePlugin: await this.createCachePlugin(),
             };
         }
-        this.publicApp = new msalNode.PublicClientApplication(this.msalConfig);
+        this.publicApp = new msalNode__namespace.PublicClientApplication(this.msalConfig);
         // The confidential client requires either a secret, assertion or certificate.
         if (this.msalConfig.auth.clientSecret ||
             this.msalConfig.auth.clientAssertion ||
             this.msalConfig.auth.clientCertificate) {
-            this.confidentialApp = new msalNode.ConfidentialClientApplication(this.msalConfig);
+            this.confidentialApp = new msalNode__namespace.ConfidentialClientApplication(this.msalConfig);
         }
         else {
             if (this.requiresConfidential) {
@@ -1096,7 +1132,7 @@ To work with multiple accounts for the same Client ID and Tenant ID, please prov
 // Copyright (c) Microsoft Corporation.
 const CommonTenantId = "common";
 const AzureAccountClientId = "aebc6443-996d-45c2-90f0-388ff96faa56"; // VSC: 'aebc6443-996d-45c2-90f0-388ff96faa56'
-const logger$1 = credentialLogger("VisualStudioCodeCredential");
+const logger$i = credentialLogger("VisualStudioCodeCredential");
 let findCredentials = undefined;
 const vsCodeCredentialControl = {
     setVsCodeCredentialFinder(finder) {
@@ -1128,10 +1164,10 @@ function getPropertyFromVSCode(property) {
     const settingsPath = ["User", "settings.json"];
     // Eventually we can add more folders for more versions of VSCode.
     const vsCodeFolder = "Code";
-    const homedir = os.homedir();
+    const homedir = os__default["default"].homedir();
     function loadProperty(...pathSegments) {
-        const fullPath = path.join(...pathSegments, vsCodeFolder, ...settingsPath);
-        const settings = JSON.parse(fs__default.readFileSync(fullPath, { encoding: "utf8" }));
+        const fullPath = path__default["default"].join(...pathSegments, vsCodeFolder, ...settingsPath);
+        const settings = JSON.parse(fs__default["default"].readFileSync(fullPath, { encoding: "utf8" }));
         return settings[property];
     }
     try {
@@ -1149,7 +1185,7 @@ function getPropertyFromVSCode(property) {
         }
     }
     catch (e) {
-        logger$1.info(`Failed to load the Visual Studio Code configuration file. Error: ${e.message}`);
+        logger$i.info(`Failed to load the Visual Studio Code configuration file. Error: ${e.message}`);
         return;
     }
 }
@@ -1177,7 +1213,7 @@ class VisualStudioCodeCredential {
         const authorityHost = mapVSCodeAuthorityHosts[this.cloudName];
         this.identityClient = new IdentityClient(Object.assign({ authorityHost }, options));
         if (options && options.tenantId) {
-            checkTenantId(logger$1, options.tenantId);
+            checkTenantId(logger$i, options.tenantId);
             this.tenantId = options.tenantId;
         }
         else {
@@ -1229,7 +1265,7 @@ class VisualStudioCodeCredential {
         // Check to make sure the scope we get back is a valid scope
         if (!scopeString.match(/^[0-9a-zA-Z-.:/]+$/)) {
             const error = new Error("Invalid scope was specified by the user or calling client");
-            logger$1.getToken.info(formatError(scopes, error));
+            logger$i.getToken.info(formatError(scopes, error));
             throw error;
         }
         if (scopeString.indexOf("offline_access") < 0) {
@@ -1249,18 +1285,18 @@ class VisualStudioCodeCredential {
         if (refreshToken) {
             const tokenResponse = await this.identityClient.refreshAccessToken(tenantId, AzureAccountClientId, scopeString, refreshToken, undefined);
             if (tokenResponse) {
-                logger$1.getToken.info(formatSuccess(scopes));
+                logger$i.getToken.info(formatSuccess(scopes));
                 return tokenResponse.accessToken;
             }
             else {
                 const error = new CredentialUnavailableError("Could not retrieve the token associated with Visual Studio Code. Have you connected using the 'Azure Account' extension recently? To troubleshoot, visit https://aka.ms/azsdk/js/identity/vscodecredential/troubleshoot.");
-                logger$1.getToken.info(formatError(scopes, error));
+                logger$i.getToken.info(formatError(scopes, error));
                 throw error;
             }
         }
         else {
             const error = new CredentialUnavailableError("Could not retrieve the token associated with Visual Studio Code. Did you connect using the 'Azure Account' extension? To troubleshoot, visit https://aka.ms/azsdk/js/identity/vscodecredential/troubleshoot.");
-            logger$1.getToken.info(formatError(scopes, error));
+            logger$i.getToken.info(formatError(scopes, error));
             throw error;
         }
     }
@@ -1311,7 +1347,7 @@ function useIdentityPlugin(plugin) {
 /**
  * @internal
  */
-const logger$2 = credentialLogger("ChainedTokenCredential");
+const logger$h = credentialLogger("ChainedTokenCredential");
 /**
  * Enables multiple `TokenCredential` implementations to be tried in order
  * until one of the getToken methods returns an access token.
@@ -1366,7 +1402,7 @@ class ChainedTokenCredential {
                     errors.push(err);
                 }
                 else {
-                    logger$2.getToken.info(formatError(scopes, err));
+                    logger$h.getToken.info(formatError(scopes, err));
                     throw err;
                 }
             }
@@ -1377,11 +1413,11 @@ class ChainedTokenCredential {
                 code: coreTracing.SpanStatusCode.ERROR,
                 message: err.message,
             });
-            logger$2.getToken.info(formatError(scopes, err));
+            logger$h.getToken.info(formatError(scopes, err));
             throw err;
         }
         span.end();
-        logger$2.getToken.info(`Result for ${successfulCredentialName}: ${formatSuccess(scopes)}`);
+        logger$h.getToken.info(`Result for ${successfulCredentialName}: ${formatSuccess(scopes)}`);
         if (token === null) {
             throw new CredentialUnavailableError("Failed to retrieve a valid token");
         }
@@ -1441,7 +1477,7 @@ const cliCredentialInternals = {
         }
         return new Promise((resolve, reject) => {
             try {
-                child_process__default.execFile("az", [
+                child_process__default["default"].execFile("az", [
                     "account",
                     "get-access-token",
                     "--output",
@@ -1459,7 +1495,7 @@ const cliCredentialInternals = {
         });
     },
 };
-const logger$3 = credentialLogger("AzureCliCredential");
+const logger$g = credentialLogger("AzureCliCredential");
 /**
  * This credential will use the currently logged-in user login information
  * via the Azure CLI ('az') commandline tool.
@@ -1489,11 +1525,11 @@ class AzureCliCredential {
     async getToken(scopes, options) {
         const tenantId = processMultiTenantRequest(this.tenantId, options);
         if (tenantId) {
-            checkTenantId(logger$3, tenantId);
+            checkTenantId(logger$g, tenantId);
         }
         const scope = typeof scopes === "string" ? scopes : scopes[0];
-        logger$3.getToken.info(`Using the scope ${scope}`);
-        ensureValidScope(scope, logger$3);
+        logger$g.getToken.info(`Using the scope ${scope}`);
+        ensureValidScope(scope, logger$g);
         const resource = getScopeResource(scope);
         let responseData = "";
         const { span } = createSpan(`${this.constructor.name}.getToken`, options);
@@ -1504,22 +1540,22 @@ class AzureCliCredential {
                 const isNotInstallError = obj.stderr.match("az:(.*)not found") || obj.stderr.startsWith("'az' is not recognized");
                 if (isNotInstallError) {
                     const error = new CredentialUnavailableError("Azure CLI could not be found.  Please visit https://aka.ms/azure-cli for installation instructions and then, once installed, authenticate to your Azure account using 'az login'.");
-                    logger$3.getToken.info(formatError(scopes, error));
+                    logger$g.getToken.info(formatError(scopes, error));
                     throw error;
                 }
                 else if (isLoginError) {
                     const error = new CredentialUnavailableError("Please run 'az login' from a command prompt to authenticate before using this credential.");
-                    logger$3.getToken.info(formatError(scopes, error));
+                    logger$g.getToken.info(formatError(scopes, error));
                     throw error;
                 }
                 const error = new CredentialUnavailableError(obj.stderr);
-                logger$3.getToken.info(formatError(scopes, error));
+                logger$g.getToken.info(formatError(scopes, error));
                 throw error;
             }
             else {
                 responseData = obj.stdout;
                 const response = JSON.parse(responseData);
-                logger$3.getToken.info(formatSuccess(scopes));
+                logger$g.getToken.info(formatSuccess(scopes));
                 const returnValue = {
                     token: response.accessToken,
                     expiresOnTimestamp: new Date(response.expiresOn).getTime(),
@@ -1533,7 +1569,7 @@ class AzureCliCredential {
                 code: coreTracing.SpanStatusCode.ERROR,
                 message: error.message,
             });
-            logger$3.getToken.info(formatError(scopes, error));
+            logger$g.getToken.info(formatError(scopes, error));
             throw error;
         }
     }
@@ -1551,7 +1587,7 @@ const processUtils = {
      */
     execFile(file, params, options) {
         return new Promise((resolve, reject) => {
-            child_process.execFile(file, params, options, (error, stdout, stderr) => {
+            child_process__namespace.execFile(file, params, options, (error, stdout, stderr) => {
                 if (Buffer.isBuffer(stdout)) {
                     stdout = stdout.toString("utf8");
                 }
@@ -1570,7 +1606,7 @@ const processUtils = {
 };
 
 // Copyright (c) Microsoft Corporation.
-const logger$4 = credentialLogger("AzurePowerShellCredential");
+const logger$f = credentialLogger("AzurePowerShellCredential");
 const isWindows = process.platform === "win32";
 /**
  * Returns a platform-appropriate command name by appending ".exe" on Windows.
@@ -1701,15 +1737,15 @@ class AzurePowerShellCredential {
         return trace(`${this.constructor.name}.getToken`, options, async () => {
             const tenantId = processMultiTenantRequest(this.tenantId, options);
             if (tenantId) {
-                checkTenantId(logger$4, tenantId);
+                checkTenantId(logger$f, tenantId);
             }
             const scope = typeof scopes === "string" ? scopes : scopes[0];
-            ensureValidScope(scope, logger$4);
-            logger$4.getToken.info(`Using the scope ${scope}`);
+            ensureValidScope(scope, logger$f);
+            logger$f.getToken.info(`Using the scope ${scope}`);
             const resource = getScopeResource(scope);
             try {
                 const response = await this.getAzurePowerShellAccessToken(resource, tenantId);
-                logger$4.getToken.info(formatSuccess(scopes));
+                logger$f.getToken.info(formatSuccess(scopes));
                 return {
                     token: response.Token,
                     expiresOnTimestamp: new Date(response.ExpiresOn).getTime(),
@@ -1718,16 +1754,16 @@ class AzurePowerShellCredential {
             catch (err) {
                 if (isNotInstalledError(err)) {
                     const error = new CredentialUnavailableError(powerShellPublicErrorMessages.installed);
-                    logger$4.getToken.info(formatError(scope, error));
+                    logger$f.getToken.info(formatError(scope, error));
                     throw error;
                 }
                 else if (isLoginError(err)) {
                     const error = new CredentialUnavailableError(powerShellPublicErrorMessages.login);
-                    logger$4.getToken.info(formatError(scope, error));
+                    logger$f.getToken.info(formatError(scope, error));
                     throw error;
                 }
                 const error = new CredentialUnavailableError(`${err}. ${powerShellPublicErrorMessages.troubleshoot}`);
-                logger$4.getToken.info(formatError(scope, error));
+                logger$f.getToken.info(formatError(scope, error));
                 throw error;
             }
         });
@@ -1765,7 +1801,7 @@ class MsalClientSecret extends MsalNode {
 }
 
 // Copyright (c) Microsoft Corporation.
-const logger$5 = credentialLogger("ClientSecretCredential");
+const logger$e = credentialLogger("ClientSecretCredential");
 /**
  * Enables authentication to Azure Active Directory using a client secret
  * that was generated for an App Registration. More information on how
@@ -1789,7 +1825,7 @@ class ClientSecretCredential {
         if (!tenantId || !clientId || !clientSecret) {
             throw new Error("ClientSecretCredential: tenantId, clientId, and clientSecret are required parameters. To troubleshoot, visit https://aka.ms/azsdk/js/identity/serviceprincipalauthentication/troubleshoot.");
         }
-        this.msalFlow = new MsalClientSecret(Object.assign(Object.assign({}, options), { logger: logger$5,
+        this.msalFlow = new MsalClientSecret(Object.assign(Object.assign({}, options), { logger: logger$e,
             clientId,
             tenantId,
             clientSecret, tokenCredentialOptions: options }));
@@ -1811,7 +1847,7 @@ class ClientSecretCredential {
 }
 
 // Copyright (c) Microsoft Corporation.
-const readFileAsync = util.promisify(fs.readFile);
+const readFileAsync$2 = util.promisify(fs.readFile);
 /**
  * Tries to asynchronously load a certificate from the given path.
  *
@@ -1823,7 +1859,7 @@ const readFileAsync = util.promisify(fs.readFile);
 async function parseCertificate(configuration, sendCertificateChain) {
     const certificateParts = {};
     certificateParts.certificateContents =
-        configuration.certificate || (await readFileAsync(configuration.certificatePath, "utf8"));
+        configuration.certificate || (await readFileAsync$2(configuration.certificatePath, "utf8"));
     if (sendCertificateChain) {
         certificateParts.x5c = certificateParts.certificateContents;
     }
@@ -1894,8 +1930,8 @@ class MsalClientCertificate extends MsalNode {
 }
 
 // Copyright (c) Microsoft Corporation.
-const credentialName = "ClientCertificateCredential";
-const logger$6 = credentialLogger(credentialName);
+const credentialName$2 = "ClientCertificateCredential";
+const logger$d = credentialLogger(credentialName$2);
 /**
  * Enables authentication to Azure Active Directory using a PEM-encoded
  * certificate that is assigned to an App Registration. More information
@@ -1907,7 +1943,7 @@ const logger$6 = credentialLogger(credentialName);
 class ClientCertificateCredential {
     constructor(tenantId, clientId, certificatePathOrConfiguration, options = {}) {
         if (!tenantId || !clientId) {
-            throw new Error(`${credentialName}: tenantId and clientId are required parameters.`);
+            throw new Error(`${credentialName$2}: tenantId and clientId are required parameters.`);
         }
         const configuration = Object.assign({}, (typeof certificatePathOrConfiguration === "string"
             ? {
@@ -1915,13 +1951,13 @@ class ClientCertificateCredential {
             }
             : certificatePathOrConfiguration));
         if (!configuration || !(configuration.certificate || configuration.certificatePath)) {
-            throw new Error(`${credentialName}: Provide either a PEM certificate in string form, or the path to that certificate in the filesystem. To troubleshoot, visit https://aka.ms/azsdk/js/identity/serviceprincipalauthentication/troubleshoot.`);
+            throw new Error(`${credentialName$2}: Provide either a PEM certificate in string form, or the path to that certificate in the filesystem. To troubleshoot, visit https://aka.ms/azsdk/js/identity/serviceprincipalauthentication/troubleshoot.`);
         }
         if (configuration.certificate && configuration.certificatePath) {
-            throw new Error(`${credentialName}: To avoid unexpected behaviors, providing both the contents of a PEM certificate and the path to a PEM certificate is forbidden. To troubleshoot, visit https://aka.ms/azsdk/js/identity/serviceprincipalauthentication/troubleshoot.`);
+            throw new Error(`${credentialName$2}: To avoid unexpected behaviors, providing both the contents of a PEM certificate and the path to a PEM certificate is forbidden. To troubleshoot, visit https://aka.ms/azsdk/js/identity/serviceprincipalauthentication/troubleshoot.`);
         }
         this.msalFlow = new MsalClientCertificate(Object.assign(Object.assign({}, options), { configuration,
-            logger: logger$6,
+            logger: logger$d,
             clientId,
             tenantId, sendCertificateChain: options.sendCertificateChain, tokenCredentialOptions: options }));
     }
@@ -1934,7 +1970,7 @@ class ClientCertificateCredential {
      *                TokenCredential implementation might make.
      */
     async getToken(scopes, options = {}) {
-        return trace(`${credentialName}.getToken`, options, async (newOptions) => {
+        return trace(`${credentialName$2}.getToken`, options, async (newOptions) => {
             const arrayScopes = Array.isArray(scopes) ? scopes : [scopes];
             return this.msalFlow.getToken(arrayScopes, newOptions);
         });
@@ -1972,7 +2008,7 @@ class MsalUsernamePassword extends MsalNode {
 }
 
 // Copyright (c) Microsoft Corporation.
-const logger$7 = credentialLogger("UsernamePasswordCredential");
+const logger$c = credentialLogger("UsernamePasswordCredential");
 /**
  * Enables authentication to Azure Active Directory with a user's
  * username and password. This credential requires a high degree of
@@ -1995,7 +2031,7 @@ class UsernamePasswordCredential {
         if (!tenantId || !clientId || !username || !password) {
             throw new Error("UsernamePasswordCredential: tenantId, clientId, username and password are required parameters. To troubleshoot, visit https://aka.ms/azsdk/js/identity/usernamepasswordcredential/troubleshoot.");
         }
-        this.msalFlow = new MsalUsernamePassword(Object.assign(Object.assign({}, options), { logger: logger$7,
+        this.msalFlow = new MsalUsernamePassword(Object.assign(Object.assign({}, options), { logger: logger$c,
             clientId,
             tenantId,
             username,
@@ -2038,7 +2074,7 @@ const AllSupportedEnvironmentVariables = [
     "AZURE_PASSWORD",
 ];
 const credentialName$1 = "EnvironmentCredential";
-const logger$8 = credentialLogger(credentialName$1);
+const logger$b = credentialLogger(credentialName$1);
 /**
  * Enables authentication to Azure Active Directory using client secret
  * details configured in environment variables
@@ -2068,26 +2104,26 @@ class EnvironmentCredential {
         // Keep track of any missing environment variables for error details
         this._credential = undefined;
         const assigned = processEnvVars(AllSupportedEnvironmentVariables).assigned.join(", ");
-        logger$8.info(`Found the following environment variables: ${assigned}`);
+        logger$b.info(`Found the following environment variables: ${assigned}`);
         const tenantId = process.env.AZURE_TENANT_ID, clientId = process.env.AZURE_CLIENT_ID, clientSecret = process.env.AZURE_CLIENT_SECRET;
         if (tenantId) {
-            checkTenantId(logger$8, tenantId);
+            checkTenantId(logger$b, tenantId);
         }
         if (tenantId && clientId && clientSecret) {
-            logger$8.info(`Invoking ClientSecretCredential with tenant ID: ${tenantId}, clientId: ${clientId} and clientSecret: [REDACTED]`);
+            logger$b.info(`Invoking ClientSecretCredential with tenant ID: ${tenantId}, clientId: ${clientId} and clientSecret: [REDACTED]`);
             this._credential = new ClientSecretCredential(tenantId, clientId, clientSecret, options);
             return;
         }
         const certificatePath = process.env.AZURE_CLIENT_CERTIFICATE_PATH;
         if (tenantId && clientId && certificatePath) {
-            logger$8.info(`Invoking ClientCertificateCredential with tenant ID: ${tenantId}, clientId: ${clientId} and certificatePath: ${certificatePath}`);
+            logger$b.info(`Invoking ClientCertificateCredential with tenant ID: ${tenantId}, clientId: ${clientId} and certificatePath: ${certificatePath}`);
             this._credential = new ClientCertificateCredential(tenantId, clientId, { certificatePath }, options);
             return;
         }
         const username = process.env.AZURE_USERNAME;
         const password = process.env.AZURE_PASSWORD;
         if (tenantId && clientId && username && password) {
-            logger$8.info(`Invoking UsernamePasswordCredential with tenant ID: ${tenantId}, clientId: ${clientId} and username: ${username}`);
+            logger$b.info(`Invoking UsernamePasswordCredential with tenant ID: ${tenantId}, clientId: ${clientId} and username: ${username}`);
             this._credential = new UsernamePasswordCredential(tenantId, clientId, username, password, options);
         }
     }
@@ -2102,7 +2138,7 @@ class EnvironmentCredential {
             if (this._credential) {
                 try {
                     const result = await this._credential.getToken(scopes, newOptions);
-                    logger$8.getToken.info(formatSuccess(scopes));
+                    logger$b.getToken.info(formatSuccess(scopes));
                     return result;
                 }
                 catch (err) {
@@ -2110,7 +2146,7 @@ class EnvironmentCredential {
                         error: `${credentialName$1} authentication failed. To troubleshoot, visit https://aka.ms/azsdk/js/identity/environmentcredential/troubleshoot.`,
                         error_description: err.message.toString().split("More details:").join(""),
                     });
-                    logger$8.getToken.info(formatError(scopes, authenticationError));
+                    logger$b.getToken.info(formatError(scopes, authenticationError));
                     throw authenticationError;
                 }
             }
@@ -2156,22 +2192,22 @@ function mapScopesToResource(scopes) {
 }
 
 // Copyright (c) Microsoft Corporation.
-const msiName = "ManagedIdentityCredential - AppServiceMSI 2017";
-const logger$9 = credentialLogger(msiName);
+const msiName$5 = "ManagedIdentityCredential - AppServiceMSI 2017";
+const logger$a = credentialLogger(msiName$5);
 /**
  * Formats the expiration date of the received token into the number of milliseconds between that date and midnight, January 1, 1970.
  */
-function expiresOnParser(requestBody) {
+function expiresOnParser$2(requestBody) {
     // App Service always returns string expires_on values.
     return Date.parse(requestBody.expires_on);
 }
 /**
  * Generates the options used on the request for an access token.
  */
-function prepareRequestOptions(scopes, clientId) {
+function prepareRequestOptions$5(scopes, clientId) {
     const resource = mapScopesToResource(scopes);
     if (!resource) {
-        throw new Error(`${msiName}: Multiple scopes are not supported.`);
+        throw new Error(`${msiName$5}: Multiple scopes are not supported.`);
     }
     const queryParameters = {
         resource,
@@ -2183,10 +2219,10 @@ function prepareRequestOptions(scopes, clientId) {
     const query = new URLSearchParams(queryParameters);
     // This error should not bubble up, since we verify that this environment variable is defined in the isAvailable() method defined below.
     if (!process.env.MSI_ENDPOINT) {
-        throw new Error(`${msiName}: Missing environment variable: MSI_ENDPOINT`);
+        throw new Error(`${msiName$5}: Missing environment variable: MSI_ENDPOINT`);
     }
     if (!process.env.MSI_SECRET) {
-        throw new Error(`${msiName}: Missing environment variable: MSI_SECRET`);
+        throw new Error(`${msiName$5}: Missing environment variable: MSI_SECRET`);
     }
     return {
         url: `${process.env.MSI_ENDPOINT}?${query.toString()}`,
@@ -2204,37 +2240,37 @@ const appServiceMsi2017 = {
     async isAvailable(scopes) {
         const resource = mapScopesToResource(scopes);
         if (!resource) {
-            logger$9.info(`${msiName}: Unavailable. Multiple scopes are not supported.`);
+            logger$a.info(`${msiName$5}: Unavailable. Multiple scopes are not supported.`);
             return false;
         }
         const env = process.env;
         const result = Boolean(env.MSI_ENDPOINT && env.MSI_SECRET);
         if (!result) {
-            logger$9.info(`${msiName}: Unavailable. The environment variables needed are: MSI_ENDPOINT and MSI_SECRET.`);
+            logger$a.info(`${msiName$5}: Unavailable. The environment variables needed are: MSI_ENDPOINT and MSI_SECRET.`);
         }
         return result;
     },
     async getToken(configuration, getTokenOptions = {}) {
         const { identityClient, scopes, clientId } = configuration;
-        logger$9.info(`${msiName}: Using the endpoint and the secret coming form the environment variables: MSI_ENDPOINT=${process.env.MSI_ENDPOINT} and MSI_SECRET=[REDACTED].`);
-        const request = coreRestPipeline.createPipelineRequest(Object.assign(Object.assign({ abortSignal: getTokenOptions.abortSignal }, prepareRequestOptions(scopes, clientId)), { 
+        logger$a.info(`${msiName$5}: Using the endpoint and the secret coming form the environment variables: MSI_ENDPOINT=${process.env.MSI_ENDPOINT} and MSI_SECRET=[REDACTED].`);
+        const request = coreRestPipeline.createPipelineRequest(Object.assign(Object.assign({ abortSignal: getTokenOptions.abortSignal }, prepareRequestOptions$5(scopes, clientId)), { 
             // Generally, MSI endpoints use the HTTP protocol, without transport layer security (TLS).
             allowInsecureConnection: true }));
-        const tokenResponse = await identityClient.sendTokenRequest(request, expiresOnParser);
+        const tokenResponse = await identityClient.sendTokenRequest(request, expiresOnParser$2);
         return (tokenResponse && tokenResponse.accessToken) || null;
     },
 };
 
 // Copyright (c) Microsoft Corporation.
-const msiName$1 = "ManagedIdentityCredential - CloudShellMSI";
-const logger$a = credentialLogger(msiName$1);
+const msiName$4 = "ManagedIdentityCredential - CloudShellMSI";
+const logger$9 = credentialLogger(msiName$4);
 /**
  * Generates the options used on the request for an access token.
  */
-function prepareRequestOptions$1(scopes, clientId) {
+function prepareRequestOptions$4(scopes, clientId) {
     const resource = mapScopesToResource(scopes);
     if (!resource) {
-        throw new Error(`${msiName$1}: Multiple scopes are not supported.`);
+        throw new Error(`${msiName$4}: Multiple scopes are not supported.`);
     }
     const body = {
         resource,
@@ -2244,7 +2280,7 @@ function prepareRequestOptions$1(scopes, clientId) {
     }
     // This error should not bubble up, since we verify that this environment variable is defined in the isAvailable() method defined below.
     if (!process.env.MSI_ENDPOINT) {
-        throw new Error(`${msiName$1}: Missing environment variable: MSI_ENDPOINT`);
+        throw new Error(`${msiName$4}: Missing environment variable: MSI_ENDPOINT`);
     }
     const params = new URLSearchParams(body);
     return {
@@ -2260,24 +2296,28 @@ function prepareRequestOptions$1(scopes, clientId) {
 }
 /**
  * Defines how to determine whether the Azure Cloud Shell MSI is available, and also how to retrieve a token from the Azure Cloud Shell MSI.
+ * Since Azure Managed Identities aren't available in the Azure Cloud Shell, we log a warning for users that try to access cloud shell using user assigned identity.
  */
 const cloudShellMsi = {
     async isAvailable(scopes) {
         const resource = mapScopesToResource(scopes);
         if (!resource) {
-            logger$a.info(`${msiName$1}: Unavailable. Multiple scopes are not supported.`);
+            logger$9.info(`${msiName$4}: Unavailable. Multiple scopes are not supported.`);
             return false;
         }
         const result = Boolean(process.env.MSI_ENDPOINT);
         if (!result) {
-            logger$a.info(`${msiName$1}: Unavailable. The environment variable MSI_ENDPOINT is needed.`);
+            logger$9.info(`${msiName$4}: Unavailable. The environment variable MSI_ENDPOINT is needed.`);
         }
         return result;
     },
     async getToken(configuration, getTokenOptions = {}) {
         const { identityClient, scopes, clientId } = configuration;
-        logger$a.info(`${msiName$1}: Using the endpoint coming form the environment variable MSI_ENDPOINT = ${process.env.MSI_ENDPOINT}.`);
-        const request = coreRestPipeline.createPipelineRequest(Object.assign(Object.assign({ abortSignal: getTokenOptions.abortSignal }, prepareRequestOptions$1(scopes, clientId)), { 
+        if (clientId) {
+            logger$9.warning(`${msiName$4}: does not support user-assigned identities in the Cloud Shell environment. Argument clientId will be ignored.`);
+        }
+        logger$9.info(`${msiName$4}: Using the endpoint coming form the environment variable MSI_ENDPOINT = ${process.env.MSI_ENDPOINT}.`);
+        const request = coreRestPipeline.createPipelineRequest(Object.assign(Object.assign({ abortSignal: getTokenOptions.abortSignal }, prepareRequestOptions$4(scopes, clientId)), { 
             // Generally, MSI endpoints use the HTTP protocol, without transport layer security (TLS).
             allowInsecureConnection: true }));
         const tokenResponse = await identityClient.sendTokenRequest(request);
@@ -2286,8 +2326,8 @@ const cloudShellMsi = {
 };
 
 // Copyright (c) Microsoft Corporation.
-const msiName$2 = "ManagedIdentityCredential - IMDS";
-const logger$b = credentialLogger(msiName$2);
+const msiName$3 = "ManagedIdentityCredential - IMDS";
+const logger$8 = credentialLogger(msiName$3);
 /**
  * Formats the expiration date of the received token into the number of milliseconds between that date and midnight, January 1, 1970.
  */
@@ -2295,24 +2335,24 @@ function expiresOnParser$1(requestBody) {
     if (requestBody.expires_on) {
         // Use the expires_on timestamp if it's available
         const expires = +requestBody.expires_on * 1000;
-        logger$b.info(`${msiName$2}: Using expires_on: ${expires} (original value: ${requestBody.expires_on})`);
+        logger$8.info(`${msiName$3}: Using expires_on: ${expires} (original value: ${requestBody.expires_on})`);
         return expires;
     }
     else {
         // If these aren't possible, use expires_in and calculate a timestamp
         const expires = Date.now() + requestBody.expires_in * 1000;
-        logger$b.info(`${msiName$2}: IMDS using expires_in: ${expires} (original value: ${requestBody.expires_in})`);
+        logger$8.info(`${msiName$3}: IMDS using expires_in: ${expires} (original value: ${requestBody.expires_in})`);
         return expires;
     }
 }
 /**
  * Generates the options used on the request for an access token.
  */
-function prepareRequestOptions$2(scopes, clientId, options) {
+function prepareRequestOptions$3(scopes, clientId, options) {
     var _a;
     const resource = mapScopesToResource(scopes);
     if (!resource) {
-        throw new Error(`${msiName$2}: Multiple scopes are not supported.`);
+        throw new Error(`${msiName$3}: Multiple scopes are not supported.`);
     }
     const { skipQuery, skipMetadataHeader } = options || {};
     let query = "";
@@ -2359,7 +2399,7 @@ const imdsMsi = {
         var _a, _b;
         const resource = mapScopesToResource(scopes);
         if (!resource) {
-            logger$b.info(`${msiName$2}: Unavailable. Multiple scopes are not supported.`);
+            logger$8.info(`${msiName$3}: Unavailable. Multiple scopes are not supported.`);
             return false;
         }
         const { span, updatedOptions: options } = createSpan("ManagedIdentityCredential-pingImdsEndpoint", getTokenOptions);
@@ -2367,7 +2407,7 @@ const imdsMsi = {
         if (process.env.AZURE_POD_IDENTITY_AUTHORITY_HOST) {
             return true;
         }
-        const requestOptions = prepareRequestOptions$2(resource, clientId, {
+        const requestOptions = prepareRequestOptions$3(resource, clientId, {
             skipMetadataHeader: true,
             skipQuery: true,
         });
@@ -2381,7 +2421,7 @@ const imdsMsi = {
             // This MSI uses the imdsEndpoint to get the token, which only uses http://
             request.allowInsecureConnection = true;
             try {
-                logger$b.info(`${msiName$2}: Pinging the Azure IMDS endpoint`);
+                logger$8.info(`${msiName$3}: Pinging the Azure IMDS endpoint`);
                 await identityClient.sendRequest(request);
             }
             catch (err) {
@@ -2393,7 +2433,7 @@ const imdsMsi = {
                 ) {
                     // If the request failed, or Node.js was unable to establish a connection,
                     // or the host was down, we'll assume the IMDS endpoint isn't available.
-                    logger$b.info(`${msiName$2}: The Azure IMDS endpoint is unavailable`);
+                    logger$8.info(`${msiName$3}: The Azure IMDS endpoint is unavailable`);
                     span.setStatus({
                         code: coreTracing.SpanStatusCode.ERROR,
                         message: err.message,
@@ -2402,13 +2442,13 @@ const imdsMsi = {
                 }
             }
             // If we received any response, the endpoint is available
-            logger$b.info(`${msiName$2}: The Azure IMDS endpoint is available`);
+            logger$8.info(`${msiName$3}: The Azure IMDS endpoint is available`);
             return true;
         }
         catch (err) {
             // createWebResource failed.
             // This error should bubble up to the user.
-            logger$b.info(`${msiName$2}: Error when creating the WebResource for the Azure IMDS endpoint: ${err.message}`);
+            logger$8.info(`${msiName$3}: Error when creating the WebResource for the Azure IMDS endpoint: ${err.message}`);
             span.setStatus({
                 code: coreTracing.SpanStatusCode.ERROR,
                 message: err.message,
@@ -2421,11 +2461,11 @@ const imdsMsi = {
     },
     async getToken(configuration, getTokenOptions = {}) {
         const { identityClient, scopes, clientId } = configuration;
-        logger$b.info(`${msiName$2}: Using the Azure IMDS endpoint coming from the environment variable MSI_ENDPOINT=${process.env.MSI_ENDPOINT}, and using the cloud shell to proceed with the authentication.`);
+        logger$8.info(`${msiName$3}: Using the Azure IMDS endpoint coming from the environment variable MSI_ENDPOINT=${process.env.MSI_ENDPOINT}, and using the cloud shell to proceed with the authentication.`);
         let nextDelayInMs = imdsMsiRetryConfig.startDelayInMs;
         for (let retries = 0; retries < imdsMsiRetryConfig.maxRetries; retries++) {
             try {
-                const request = coreRestPipeline.createPipelineRequest(Object.assign(Object.assign({ abortSignal: getTokenOptions.abortSignal }, prepareRequestOptions$2(scopes, clientId)), { allowInsecureConnection: true }));
+                const request = coreRestPipeline.createPipelineRequest(Object.assign(Object.assign({ abortSignal: getTokenOptions.abortSignal }, prepareRequestOptions$3(scopes, clientId)), { allowInsecureConnection: true }));
                 const tokenResponse = await identityClient.sendTokenRequest(request, expiresOnParser$1);
                 return (tokenResponse && tokenResponse.accessToken) || null;
             }
@@ -2438,20 +2478,20 @@ const imdsMsi = {
                 throw error;
             }
         }
-        throw new AuthenticationError(404, `${msiName$2}: Failed to retrieve IMDS token after ${imdsMsiRetryConfig.maxRetries} retries.`);
+        throw new AuthenticationError(404, `${msiName$3}: Failed to retrieve IMDS token after ${imdsMsiRetryConfig.maxRetries} retries.`);
     },
 };
 
 // Copyright (c) Microsoft Corporation.
-const msiName$3 = "ManagedIdentityCredential - Azure Arc MSI";
-const logger$c = credentialLogger(msiName$3);
+const msiName$2 = "ManagedIdentityCredential - Azure Arc MSI";
+const logger$7 = credentialLogger(msiName$2);
 /**
  * Generates the options used on the request for an access token.
  */
-function prepareRequestOptions$3(scopes) {
+function prepareRequestOptions$2(scopes) {
     const resource = mapScopesToResource(scopes);
     if (!resource) {
-        throw new Error(`${msiName$3}: Multiple scopes are not supported.`);
+        throw new Error(`${msiName$2}: Multiple scopes are not supported.`);
     }
     const queryParameters = {
         resource,
@@ -2460,7 +2500,7 @@ function prepareRequestOptions$3(scopes) {
     const query = new URLSearchParams(queryParameters);
     // This error should not bubble up, since we verify that this environment variable is defined in the isAvailable() method defined below.
     if (!process.env.IDENTITY_ENDPOINT) {
-        throw new Error(`${msiName$3}: Missing environment variable: IDENTITY_ENDPOINT`);
+        throw new Error(`${msiName$2}: Missing environment variable: IDENTITY_ENDPOINT`);
     }
     return coreRestPipeline.createPipelineRequest({
         // Should be similar to: http://localhost:40342/metadata/identity/oauth2/token
@@ -2494,7 +2534,7 @@ async function filePathRequest(identityClient, requestPrepareOptions) {
         if (response.bodyAsText) {
             message = ` Response: ${response.bodyAsText}`;
         }
-        throw new AuthenticationError(response.status, `${msiName$3}: To authenticate with Azure Arc MSI, status code 401 is expected on the first request. ${message}`);
+        throw new AuthenticationError(response.status, `${msiName$2}: To authenticate with Azure Arc MSI, status code 401 is expected on the first request. ${message}`);
     }
     const authHeader = response.headers.get("www-authenticate") || "";
     try {
@@ -2511,26 +2551,26 @@ const arcMsi = {
     async isAvailable(scopes) {
         const resource = mapScopesToResource(scopes);
         if (!resource) {
-            logger$c.info(`${msiName$3}: Unavailable. Multiple scopes are not supported.`);
+            logger$7.info(`${msiName$2}: Unavailable. Multiple scopes are not supported.`);
             return false;
         }
         const result = Boolean(process.env.IMDS_ENDPOINT && process.env.IDENTITY_ENDPOINT);
         if (!result) {
-            logger$c.info(`${msiName$3}: The environment variables needed are: IMDS_ENDPOINT and IDENTITY_ENDPOINT`);
+            logger$7.info(`${msiName$2}: The environment variables needed are: IMDS_ENDPOINT and IDENTITY_ENDPOINT`);
         }
         return result;
     },
     async getToken(configuration, getTokenOptions = {}) {
         var _a;
         const { identityClient, scopes, clientId } = configuration;
-        logger$c.info(`${msiName$3}: Authenticating.`);
+        logger$7.info(`${msiName$2}: Authenticating.`);
         if (clientId) {
-            throw new Error(`${msiName$3}: User assigned identity is not supported by the Azure Arc Managed Identity Endpoint. To authenticate with the system assigned identity, omit the client id when constructing the ManagedIdentityCredential, or if authenticating with the DefaultAzureCredential ensure the AZURE_CLIENT_ID environment variable is not set.`);
+            throw new Error(`${msiName$2}: User assigned identity is not supported by the Azure Arc Managed Identity Endpoint. To authenticate with the system assigned identity, omit the client id when constructing the ManagedIdentityCredential, or if authenticating with the DefaultAzureCredential ensure the AZURE_CLIENT_ID environment variable is not set.`);
         }
-        const requestOptions = Object.assign(Object.assign({ disableJsonStringifyOnBody: true, deserializationMapper: undefined, abortSignal: getTokenOptions.abortSignal }, prepareRequestOptions$3(scopes)), { allowInsecureConnection: true });
+        const requestOptions = Object.assign(Object.assign({ disableJsonStringifyOnBody: true, deserializationMapper: undefined, abortSignal: getTokenOptions.abortSignal }, prepareRequestOptions$2(scopes)), { allowInsecureConnection: true });
         const filePath = await filePathRequest(identityClient, requestOptions);
         if (!filePath) {
-            throw new Error(`${msiName$3}: Failed to find the token file.`);
+            throw new Error(`${msiName$2}: Failed to find the token file.`);
         }
         const key = await readFileAsync$1(filePath, { encoding: "utf-8" });
         (_a = requestOptions.headers) === null || _a === void 0 ? void 0 : _a.set("Authorization", `Basic ${key}`);
@@ -2543,13 +2583,13 @@ const arcMsi = {
 };
 
 // Copyright (c) Microsoft Corporation.
-const msiName$4 = "ManagedIdentityCredential - Token Exchange";
-const logger$d = credentialLogger(msiName$4);
-const readFileAsync$2 = util.promisify(fs__default.readFile);
+const msiName$1 = "ManagedIdentityCredential - Token Exchange";
+const logger$6 = credentialLogger(msiName$1);
+const readFileAsync = util.promisify(fs__default["default"].readFile);
 /**
  * Generates the options used on the request for an access token.
  */
-function prepareRequestOptions$4(scopes, clientAssertion, clientId) {
+function prepareRequestOptions$1(scopes, clientAssertion, clientId) {
     var _a;
     const bodyParams = {
         scope: Array.isArray(scopes) ? scopes.join(" ") : scopes,
@@ -2583,7 +2623,7 @@ function tokenExchangeMsi() {
             azureFederatedTokenFileContent = undefined;
         }
         if (!azureFederatedTokenFileContent) {
-            const file = await readFileAsync$2(azureFederatedTokenFilePath, "utf8");
+            const file = await readFileAsync(azureFederatedTokenFilePath, "utf8");
             const value = file.trim();
             if (!value) {
                 throw new Error(`No content on the file ${azureFederatedTokenFilePath}, indicated by the environment variable AZURE_FEDERATED_TOKEN_FILE`);
@@ -2600,21 +2640,21 @@ function tokenExchangeMsi() {
             const env = process.env;
             const result = Boolean((clientId || env.AZURE_CLIENT_ID) && env.AZURE_TENANT_ID && azureFederatedTokenFilePath);
             if (!result) {
-                logger$d.info(`${msiName$4}: Unavailable. The environment variables needed are: AZURE_CLIENT_ID (or the client ID sent through the parameters), AZURE_TENANT_ID and AZURE_FEDERATED_TOKEN_FILE`);
+                logger$6.info(`${msiName$1}: Unavailable. The environment variables needed are: AZURE_CLIENT_ID (or the client ID sent through the parameters), AZURE_TENANT_ID and AZURE_FEDERATED_TOKEN_FILE`);
             }
             return result;
         },
         async getToken(configuration, getTokenOptions = {}) {
             const { identityClient, scopes, clientId } = configuration;
-            logger$d.info(`${msiName$4}: Using the client assertion coming from environment variables.`);
+            logger$6.info(`${msiName$1}: Using the client assertion coming from environment variables.`);
             let assertion;
             try {
                 assertion = await readAssertion();
             }
             catch (err) {
-                throw new Error(`${msiName$4}: Failed to read ${azureFederatedTokenFilePath}, indicated by the environment variable AZURE_FEDERATED_TOKEN_FILE`);
+                throw new Error(`${msiName$1}: Failed to read ${azureFederatedTokenFilePath}, indicated by the environment variable AZURE_FEDERATED_TOKEN_FILE`);
             }
-            const request = coreRestPipeline.createPipelineRequest(Object.assign(Object.assign({ abortSignal: getTokenOptions.abortSignal }, prepareRequestOptions$4(scopes, assertion, clientId || process.env.AZURE_CLIENT_ID)), { 
+            const request = coreRestPipeline.createPipelineRequest(Object.assign(Object.assign({ abortSignal: getTokenOptions.abortSignal }, prepareRequestOptions$1(scopes, assertion, clientId || process.env.AZURE_CLIENT_ID)), { 
                 // Generally, MSI endpoints use the HTTP protocol, without transport layer security (TLS).
                 allowInsecureConnection: true }));
             const tokenResponse = await identityClient.sendTokenRequest(request);
@@ -2634,22 +2674,22 @@ function tokenExchangeMsi() {
 //
 //   curl --insecure $IDENTITY_ENDPOINT'?api-version=2019-07-01-preview&resource=https://vault.azure.net/' -H "Secret: $IDENTITY_HEADER"
 //
-const msiName$5 = "ManagedIdentityCredential - Fabric MSI";
-const logger$e = credentialLogger(msiName$5);
+const msiName = "ManagedIdentityCredential - Fabric MSI";
+const logger$5 = credentialLogger(msiName);
 /**
  * Formats the expiration date of the received token into the number of milliseconds between that date and midnight, January 1, 1970.
  */
-function expiresOnParser$2(requestBody) {
+function expiresOnParser(requestBody) {
     // Parses a string representation of the milliseconds since epoch into a number value
     return Number(requestBody.expires_on);
 }
 /**
  * Generates the options used on the request for an access token.
  */
-function prepareRequestOptions$5(scopes, clientId) {
+function prepareRequestOptions(scopes, clientId) {
     const resource = mapScopesToResource(scopes);
     if (!resource) {
-        throw new Error(`${msiName$5}: Multiple scopes are not supported.`);
+        throw new Error(`${msiName}: Multiple scopes are not supported.`);
     }
     const queryParameters = {
         resource,
@@ -2682,38 +2722,38 @@ const fabricMsi = {
     async isAvailable(scopes) {
         const resource = mapScopesToResource(scopes);
         if (!resource) {
-            logger$e.info(`${msiName$5}: Unavailable. Multiple scopes are not supported.`);
+            logger$5.info(`${msiName}: Unavailable. Multiple scopes are not supported.`);
             return false;
         }
         const env = process.env;
         const result = Boolean(env.IDENTITY_ENDPOINT && env.IDENTITY_HEADER && env.IDENTITY_SERVER_THUMBPRINT);
         if (!result) {
-            logger$e.info(`${msiName$5}: Unavailable. The environment variables needed are: IDENTITY_ENDPOINT, IDENTITY_HEADER and IDENTITY_SERVER_THUMBPRINT`);
+            logger$5.info(`${msiName}: Unavailable. The environment variables needed are: IDENTITY_ENDPOINT, IDENTITY_HEADER and IDENTITY_SERVER_THUMBPRINT`);
         }
         return result;
     },
     async getToken(configuration, getTokenOptions = {}) {
         const { scopes, identityClient, clientId } = configuration;
-        logger$e.info([
-            `${msiName$5}:`,
+        logger$5.info([
+            `${msiName}:`,
             "Using the endpoint and the secret coming from the environment variables:",
             `IDENTITY_ENDPOINT=${process.env.IDENTITY_ENDPOINT},`,
             "IDENTITY_HEADER=[REDACTED] and",
             "IDENTITY_SERVER_THUMBPRINT=[REDACTED].",
         ].join(" "));
-        const request = coreRestPipeline.createPipelineRequest(Object.assign({ abortSignal: getTokenOptions.abortSignal }, prepareRequestOptions$5(scopes, clientId)));
-        request.agent = new https.Agent({
+        const request = coreRestPipeline.createPipelineRequest(Object.assign({ abortSignal: getTokenOptions.abortSignal }, prepareRequestOptions(scopes, clientId)));
+        request.agent = new https__default["default"].Agent({
             // This is necessary because Service Fabric provides a self-signed certificate.
             // The alternative path is to verify the certificate using the IDENTITY_SERVER_THUMBPRINT env variable.
             rejectUnauthorized: false,
         });
-        const tokenResponse = await identityClient.sendTokenRequest(request, expiresOnParser$2);
+        const tokenResponse = await identityClient.sendTokenRequest(request, expiresOnParser);
         return (tokenResponse && tokenResponse.accessToken) || null;
     },
 };
 
 // Copyright (c) Microsoft Corporation.
-const logger$f = credentialLogger("ManagedIdentityCredential");
+const logger$4 = credentialLogger("ManagedIdentityCredential");
 /**
  * Attempts authentication using a managed identity available at the deployment environment.
  * This authentication type works in Azure VMs, App Service instances, Azure Functions applications,
@@ -2800,7 +2840,7 @@ class ManagedIdentityCredential {
                     // It also means that the endpoint answered with either 200 or 201 (see the sendTokenRequest method),
                     // yet we had no access token. For this reason, we'll throw once with a specific message:
                     const error = new CredentialUnavailableError("The managed identity endpoint was reached, yet no tokens were received.");
-                    logger$f.getToken.info(formatError(scopes, error));
+                    logger$4.getToken.info(formatError(scopes, error));
                     throw error;
                 }
                 // Since `authenticateManagedIdentity` didn't throw, and the result was not null,
@@ -2812,10 +2852,10 @@ class ManagedIdentityCredential {
                 // We've previously determined that the endpoint was unavailable,
                 // either because it was unreachable or permanently unable to authenticate.
                 const error = new CredentialUnavailableError("The managed identity endpoint is not currently available");
-                logger$f.getToken.info(formatError(scopes, error));
+                logger$4.getToken.info(formatError(scopes, error));
                 throw error;
             }
-            logger$f.getToken.info(formatSuccess(scopes));
+            logger$4.getToken.info(formatSuccess(scopes));
             return result;
         }
         catch (err) {
@@ -2837,14 +2877,14 @@ class ManagedIdentityCredential {
             // we can safely assume the credential is unavailable.
             if (err.code === "ENETUNREACH") {
                 const error = new CredentialUnavailableError(`${ManagedIdentityCredential.name}: Unavailable. Network unreachable. Message: ${err.message}`);
-                logger$f.getToken.info(formatError(scopes, error));
+                logger$4.getToken.info(formatError(scopes, error));
                 throw error;
             }
             // If either the host was unreachable,
             // we can safely assume the credential is unavailable.
             if (err.code === "EHOSTUNREACH") {
                 const error = new CredentialUnavailableError(`${ManagedIdentityCredential.name}: Unavailable. No managed identity endpoint found. Message: ${err.message}`);
-                logger$f.getToken.info(formatError(scopes, error));
+                logger$4.getToken.info(formatError(scopes, error));
                 throw error;
             }
             // If err.statusCode has a value of 400, it comes from sendTokenRequest,
@@ -2938,7 +2978,7 @@ class DefaultAzureCredential extends ChainedTokenCredential {
  * @internal
  */
 const interactiveBrowserMockable = {
-    open,
+    open: open__default["default"],
 };
 /**
  * This MSAL client sets up a web server to listen for redirect callbacks, then calls to the MSAL's public application's `acquireTokenByDeviceCode` during `doGetToken`
@@ -3020,8 +3060,8 @@ class MsalOpenBrowser extends MsalNode {
                     cleanup();
                 });
             };
-            const app = http.createServer(requestListener);
-            const server = stoppable(app);
+            const app = http__default["default"].createServer(requestListener);
+            const server = stoppable__default["default"](app);
             const listen = app.listen(this.port, this.hostname, () => this.logger.info(`InteractiveBrowserCredential listening on port ${this.port}!`));
             function cleanup() {
                 if (listen) {
@@ -3068,7 +3108,7 @@ class MsalOpenBrowser extends MsalNode {
     }
     async openAuthCodeUrl(scopeArray, options) {
         // Initialize CryptoProvider instance
-        const cryptoProvider = new msalNode.CryptoProvider();
+        const cryptoProvider = new msalNode__namespace.CryptoProvider();
         // Generate PKCE Codes before starting the authorization flow
         this.pkceCodes = await cryptoProvider.generatePkceCodes();
         const authCodeUrlParameters = {
@@ -3092,7 +3132,7 @@ class MsalOpenBrowser extends MsalNode {
 }
 
 // Copyright (c) Microsoft Corporation.
-const logger$g = credentialLogger("InteractiveBrowserCredential");
+const logger$3 = credentialLogger("InteractiveBrowserCredential");
 /**
  * Enables authentication to Azure Active Directory inside of the web browser
  * using the interactive login flow.
@@ -3114,7 +3154,7 @@ class InteractiveBrowserCredential {
         const redirectUri = typeof options.redirectUri === "function"
             ? options.redirectUri()
             : options.redirectUri || "http://localhost";
-        this.msalFlow = new MsalOpenBrowser(Object.assign(Object.assign({}, options), { tokenCredentialOptions: options, logger: logger$g,
+        this.msalFlow = new MsalOpenBrowser(Object.assign(Object.assign({}, options), { tokenCredentialOptions: options, logger: logger$3,
             redirectUri }));
         this.disableAutomaticAuthentication = options === null || options === void 0 ? void 0 : options.disableAutomaticAuthentication;
     }
@@ -3193,7 +3233,7 @@ class MsalDeviceCode extends MsalNode {
 }
 
 // Copyright (c) Microsoft Corporation.
-const logger$h = credentialLogger("DeviceCodeCredential");
+const logger$2 = credentialLogger("DeviceCodeCredential");
 /**
  * Method that logs the user code from the DeviceCodeCredential.
  * @param deviceCodeInfo - The device code.
@@ -3227,7 +3267,7 @@ class DeviceCodeCredential {
      * @param options - Options for configuring the client which makes the authentication requests.
      */
     constructor(options) {
-        this.msalFlow = new MsalDeviceCode(Object.assign(Object.assign({}, options), { logger: logger$h, userPromptCallback: (options === null || options === void 0 ? void 0 : options.userPromptCallback) || defaultDeviceCodePromptCallback, tokenCredentialOptions: options || {} }));
+        this.msalFlow = new MsalDeviceCode(Object.assign(Object.assign({}, options), { logger: logger$2, userPromptCallback: (options === null || options === void 0 ? void 0 : options.userPromptCallback) || defaultDeviceCodePromptCallback, tokenCredentialOptions: options || {} }));
         this.disableAutomaticAuthentication = options === null || options === void 0 ? void 0 : options.disableAutomaticAuthentication;
     }
     /**
@@ -3309,7 +3349,7 @@ class MsalAuthorizationCode extends MsalNode {
 }
 
 // Copyright (c) Microsoft Corporation.
-const logger$i = credentialLogger("AuthorizationCodeCredential");
+const logger$1 = credentialLogger("AuthorizationCodeCredential");
 /**
  * Enables authentication to Azure Active Directory using an authorization code
  * that was obtained through the authorization code flow, described in more detail
@@ -3323,7 +3363,7 @@ class AuthorizationCodeCredential {
      * @internal
      */
     constructor(tenantId, clientId, clientSecretOrAuthorizationCode, authorizationCodeOrRedirectUri, redirectUriOrOptions, options) {
-        checkTenantId(logger$i, tenantId);
+        checkTenantId(logger$1, tenantId);
         let clientSecret = clientSecretOrAuthorizationCode;
         if (typeof redirectUriOrOptions === "string") {
             // the clientId+clientSecret constructor
@@ -3339,7 +3379,7 @@ class AuthorizationCodeCredential {
             options = redirectUriOrOptions;
         }
         this.msalFlow = new MsalAuthorizationCode(Object.assign(Object.assign({}, options), { clientSecret,
-            clientId, tokenCredentialOptions: options || {}, logger: logger$i, redirectUri: this.redirectUri, authorizationCode: this.authorizationCode }));
+            clientId, tokenCredentialOptions: options || {}, logger: logger$1, redirectUri: this.redirectUri, authorizationCode: this.authorizationCode }));
     }
     /**
      * Authenticates with Azure Active Directory and returns an access token if successful.
@@ -3411,8 +3451,8 @@ class MsalOnBehalfOf extends MsalNode {
 }
 
 // Copyright (c) Microsoft Corporation.
-const credentialName$2 = "OnBehalfOfCredential";
-const logger$j = credentialLogger(credentialName$2);
+const credentialName = "OnBehalfOfCredential";
+const logger = credentialLogger(credentialName);
 /**
  * Enables authentication to Azure Active Directory using the [On Behalf Of flow](https://docs.microsoft.com/azure/active-directory/develop/v2-oauth2-on-behalf-of-flow).
  */
@@ -3444,9 +3484,9 @@ class OnBehalfOfCredential {
         const { certificatePath } = options;
         const { tenantId, clientId, userAssertionToken } = options;
         if (!tenantId || !clientId || !(clientSecret || certificatePath) || !userAssertionToken) {
-            throw new Error(`${credentialName$2}: tenantId, clientId, clientSecret (or certificatePath) and userAssertionToken are required parameters.`);
+            throw new Error(`${credentialName}: tenantId, clientId, clientSecret (or certificatePath) and userAssertionToken are required parameters.`);
         }
-        this.msalFlow = new MsalOnBehalfOf(Object.assign(Object.assign({}, this.options), { logger: logger$j, tokenCredentialOptions: this.options }));
+        this.msalFlow = new MsalOnBehalfOf(Object.assign(Object.assign({}, this.options), { logger, tokenCredentialOptions: this.options }));
     }
     /**
      * Authenticates with Azure Active Directory and returns an access token if successful.
@@ -3456,7 +3496,7 @@ class OnBehalfOfCredential {
      * @param options - The options used to configure the underlying network requests.
      */
     async getToken(scopes, options = {}) {
-        return trace(`${credentialName$2}.getToken`, options, async (newOptions) => {
+        return trace(`${credentialName}.getToken`, options, async (newOptions) => {
             const arrayScopes = Array.isArray(scopes) ? scopes : [scopes];
             return this.msalFlow.getToken(arrayScopes, newOptions);
         });
@@ -3494,7 +3534,7 @@ exports.UsernamePasswordCredential = UsernamePasswordCredential;
 exports.VisualStudioCodeCredential = VisualStudioCodeCredential;
 exports.deserializeAuthenticationRecord = deserializeAuthenticationRecord;
 exports.getDefaultAzureCredential = getDefaultAzureCredential;
-exports.logger = logger;
+exports.logger = logger$j;
 exports.serializeAuthenticationRecord = serializeAuthenticationRecord;
 exports.useIdentityPlugin = useIdentityPlugin;
 //# sourceMappingURL=index.js.map