Add extracted source directory and README navigation

extracted-source/node_modules/@azure/msal-node/dist/retry/DefaultManagedIdentityRetryPolicy.mjs

@@ -0,0 +1,49 @@
+/*! @azure/msal-node v3.8.1 2025-10-29 */
+'use strict';
+import { HttpStatus } from '@azure/msal-common';
+import { LinearRetryStrategy } from './LinearRetryStrategy.mjs';
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+const DEFAULT_MANAGED_IDENTITY_MAX_RETRIES = 3; // referenced in unit test
+const DEFAULT_MANAGED_IDENTITY_RETRY_DELAY_MS = 1000;
+const DEFAULT_MANAGED_IDENTITY_HTTP_STATUS_CODES_TO_RETRY_ON = [
+    HttpStatus.NOT_FOUND,
+    HttpStatus.REQUEST_TIMEOUT,
+    HttpStatus.TOO_MANY_REQUESTS,
+    HttpStatus.SERVER_ERROR,
+    HttpStatus.SERVICE_UNAVAILABLE,
+    HttpStatus.GATEWAY_TIMEOUT,
+];
+class DefaultManagedIdentityRetryPolicy {
+    constructor() {
+        this.linearRetryStrategy = new LinearRetryStrategy();
+    }
+    /*
+     * this is defined here as a static variable despite being defined as a constant outside of the
+     * class because it needs to be overridden in the unit tests so that the unit tests run faster
+     */
+    static get DEFAULT_MANAGED_IDENTITY_RETRY_DELAY_MS() {
+        return DEFAULT_MANAGED_IDENTITY_RETRY_DELAY_MS;
+    }
+    async pauseForRetry(httpStatusCode, currentRetry, logger, retryAfterHeader) {
+        if (DEFAULT_MANAGED_IDENTITY_HTTP_STATUS_CODES_TO_RETRY_ON.includes(httpStatusCode) &&
+            currentRetry < DEFAULT_MANAGED_IDENTITY_MAX_RETRIES) {
+            const retryAfterDelay = this.linearRetryStrategy.calculateDelay(retryAfterHeader, DefaultManagedIdentityRetryPolicy.DEFAULT_MANAGED_IDENTITY_RETRY_DELAY_MS);
+            logger.verbose(`Retrying request in ${retryAfterDelay}ms (retry attempt: ${currentRetry + 1})`);
+            // pause execution for the calculated delay
+            await new Promise((resolve) => {
+                // retryAfterHeader value of 0 evaluates to false, and DEFAULT_MANAGED_IDENTITY_RETRY_DELAY_MS will be used
+                return setTimeout(resolve, retryAfterDelay);
+            });
+            return true;
+        }
+        // if the status code is not retriable or max retries have been reached, do not retry
+        return false;
+    }
+}
+
+export { DEFAULT_MANAGED_IDENTITY_MAX_RETRIES, DefaultManagedIdentityRetryPolicy };
+//# sourceMappingURL=DefaultManagedIdentityRetryPolicy.mjs.map

extracted-source/node_modules/@azure/msal-node/dist/retry/ExponentialRetryStrategy.mjs

@@ -0,0 +1,40 @@
+/*! @azure/msal-node v3.8.1 2025-10-29 */
+'use strict';
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class ExponentialRetryStrategy {
+    constructor(minExponentialBackoff, maxExponentialBackoff, exponentialDeltaBackoff) {
+        this.minExponentialBackoff = minExponentialBackoff;
+        this.maxExponentialBackoff = maxExponentialBackoff;
+        this.exponentialDeltaBackoff = exponentialDeltaBackoff;
+    }
+    /**
+     * Calculates the exponential delay based on the current retry attempt.
+     *
+     * @param {number} currentRetry - The current retry attempt number.
+     * @returns {number} - The calculated exponential delay in milliseconds.
+     *
+     * The delay is calculated using the formula:
+     * - If `currentRetry` is 0, it returns the minimum backoff time.
+     * - Otherwise, it calculates the delay as the minimum of:
+     *   - `(2^(currentRetry - 1)) * deltaBackoff`
+     *   - `maxBackoff`
+     *
+     * This ensures that the delay increases exponentially with each retry attempt,
+     * but does not exceed the maximum backoff time.
+     */
+    calculateDelay(currentRetry) {
+        // Attempt 1
+        if (currentRetry === 0) {
+            return this.minExponentialBackoff;
+        }
+        // Attempt 2+
+        const exponentialDelay = Math.min(Math.pow(2, currentRetry - 1) * this.exponentialDeltaBackoff, this.maxExponentialBackoff);
+        return exponentialDelay;
+    }
+}
+
+export { ExponentialRetryStrategy };
+//# sourceMappingURL=ExponentialRetryStrategy.mjs.map

extracted-source/node_modules/@azure/msal-node/dist/retry/ImdsRetryPolicy.mjs

@@ -0,0 +1,90 @@
+/*! @azure/msal-node v3.8.1 2025-10-29 */
+'use strict';
+import { HttpStatus } from '@azure/msal-common';
+import { ExponentialRetryStrategy } from './ExponentialRetryStrategy.mjs';
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+const HTTP_STATUS_400_CODES_FOR_EXPONENTIAL_STRATEGY = [
+    HttpStatus.NOT_FOUND,
+    HttpStatus.REQUEST_TIMEOUT,
+    HttpStatus.GONE,
+    HttpStatus.TOO_MANY_REQUESTS,
+];
+const EXPONENTIAL_STRATEGY_NUM_RETRIES = 3;
+const LINEAR_STRATEGY_NUM_RETRIES = 7;
+const MIN_EXPONENTIAL_BACKOFF_MS = 1000;
+const MAX_EXPONENTIAL_BACKOFF_MS = 4000;
+const EXPONENTIAL_DELTA_BACKOFF_MS = 2000;
+const HTTP_STATUS_GONE_RETRY_AFTER_MS = 10 * 1000; // 10 seconds
+class ImdsRetryPolicy {
+    constructor() {
+        this.exponentialRetryStrategy = new ExponentialRetryStrategy(ImdsRetryPolicy.MIN_EXPONENTIAL_BACKOFF_MS, ImdsRetryPolicy.MAX_EXPONENTIAL_BACKOFF_MS, ImdsRetryPolicy.EXPONENTIAL_DELTA_BACKOFF_MS);
+    }
+    /*
+     * these are defined here as static variables despite being defined as constants outside of the
+     * class because they need to be overridden in the unit tests so that the unit tests run faster
+     */
+    static get MIN_EXPONENTIAL_BACKOFF_MS() {
+        return MIN_EXPONENTIAL_BACKOFF_MS;
+    }
+    static get MAX_EXPONENTIAL_BACKOFF_MS() {
+        return MAX_EXPONENTIAL_BACKOFF_MS;
+    }
+    static get EXPONENTIAL_DELTA_BACKOFF_MS() {
+        return EXPONENTIAL_DELTA_BACKOFF_MS;
+    }
+    static get HTTP_STATUS_GONE_RETRY_AFTER_MS() {
+        return HTTP_STATUS_GONE_RETRY_AFTER_MS;
+    }
+    set isNewRequest(value) {
+        this._isNewRequest = value;
+    }
+    /**
+     * Pauses execution for a calculated delay before retrying a request.
+     *
+     * @param httpStatusCode - The HTTP status code of the response.
+     * @param currentRetry - The current retry attempt number.
+     * @param retryAfterHeader - The value of the "retry-after" header from the response.
+     * @returns A promise that resolves to a boolean indicating whether a retry should be attempted.
+     */
+    async pauseForRetry(httpStatusCode, currentRetry, logger) {
+        if (this._isNewRequest) {
+            this._isNewRequest = false;
+            // calculate the maxRetries based on the status code, once per request
+            this.maxRetries =
+                httpStatusCode === HttpStatus.GONE
+                    ? LINEAR_STRATEGY_NUM_RETRIES
+                    : EXPONENTIAL_STRATEGY_NUM_RETRIES;
+        }
+        /**
+         * (status code is one of the retriable 400 status code
+         * or
+         * status code is >= 500 and <= 599)
+         * and
+         * current count of retries is less than the max number of retries
+         */
+        if ((HTTP_STATUS_400_CODES_FOR_EXPONENTIAL_STRATEGY.includes(httpStatusCode) ||
+            (httpStatusCode >= HttpStatus.SERVER_ERROR_RANGE_START &&
+                httpStatusCode <= HttpStatus.SERVER_ERROR_RANGE_END &&
+                currentRetry < this.maxRetries)) &&
+            currentRetry < this.maxRetries) {
+            const retryAfterDelay = httpStatusCode === HttpStatus.GONE
+                ? ImdsRetryPolicy.HTTP_STATUS_GONE_RETRY_AFTER_MS
+                : this.exponentialRetryStrategy.calculateDelay(currentRetry);
+            logger.verbose(`Retrying request in ${retryAfterDelay}ms (retry attempt: ${currentRetry + 1})`);
+            // pause execution for the calculated delay
+            await new Promise((resolve) => {
+                return setTimeout(resolve, retryAfterDelay);
+            });
+            return true;
+        }
+        // if the status code is not retriable or max retries have been reached, do not retry
+        return false;
+    }
+}
+
+export { ImdsRetryPolicy };
+//# sourceMappingURL=ImdsRetryPolicy.mjs.map

extracted-source/node_modules/@azure/msal-node/dist/retry/LinearRetryStrategy.mjs

@@ -0,0 +1,36 @@
+/*! @azure/msal-node v3.8.1 2025-10-29 */
+'use strict';
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class LinearRetryStrategy {
+    /**
+     * Calculates the number of milliseconds to sleep based on the `retry-after` HTTP header.
+     *
+     * @param retryHeader - The value of the `retry-after` HTTP header. This can be either a number of seconds
+     *                      or an HTTP date string.
+     * @returns The number of milliseconds to sleep before retrying the request. If the `retry-after` header is not
+     *          present or cannot be parsed, returns 0.
+     */
+    calculateDelay(retryHeader, minimumDelay) {
+        if (!retryHeader) {
+            return minimumDelay;
+        }
+        // retry-after header is in seconds
+        let millisToSleep = Math.round(parseFloat(retryHeader) * 1000);
+        /*
+         * retry-after header is in HTTP Date format
+         * <day-name>, <day> <month> <year> <hour>:<minute>:<second> GMT
+         */
+        if (isNaN(millisToSleep)) {
+            // .valueOf() is needed to subtract dates in TypeScript
+            millisToSleep =
+                new Date(retryHeader).valueOf() - new Date().valueOf();
+        }
+        return Math.max(minimumDelay, millisToSleep);
+    }
+}
+
+export { LinearRetryStrategy };
+//# sourceMappingURL=LinearRetryStrategy.mjs.map