@cdk8s/awscdk-resolver 0.0.562 → 0.0.564

package/node_modules/@smithy/core/dist-es/submodules/client/smithy-client/extensions/checksum.js

@@ -0,0 +1,49 @@
+import { AlgorithmId, } from "@smithy/types";
+export { AlgorithmId };
+const knownAlgorithms = Object.values(AlgorithmId);
+export const getChecksumConfiguration = (runtimeConfig) => {
+    const checksumAlgorithms = [];
+    for (const id in AlgorithmId) {
+        const algorithmId = AlgorithmId[id];
+        if (runtimeConfig[algorithmId] === undefined) {
+            continue;
+        }
+        checksumAlgorithms.push({
+            algorithmId: () => algorithmId,
+            checksumConstructor: () => runtimeConfig[algorithmId],
+        });
+    }
+    for (const [id, ChecksumCtor] of Object.entries(runtimeConfig.checksumAlgorithms ?? {})) {
+        checksumAlgorithms.push({
+            algorithmId: () => id,
+            checksumConstructor: () => ChecksumCtor,
+        });
+    }
+    return {
+        addChecksumAlgorithm(algo) {
+            runtimeConfig.checksumAlgorithms = runtimeConfig.checksumAlgorithms ?? {};
+            const id = algo.algorithmId();
+            const ctor = algo.checksumConstructor();
+            if (knownAlgorithms.includes(id)) {
+                runtimeConfig.checksumAlgorithms[id.toUpperCase()] = ctor;
+            }
+            else {
+                runtimeConfig.checksumAlgorithms[id] = ctor;
+            }
+            checksumAlgorithms.push(algo);
+        },
+        checksumAlgorithms() {
+            return checksumAlgorithms;
+        },
+    };
+};
+export const resolveChecksumRuntimeConfig = (clientConfig) => {
+    const runtimeConfig = {};
+    clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
+        const id = checksumAlgorithm.algorithmId();
+        if (knownAlgorithms.includes(id)) {
+            runtimeConfig[id] = checksumAlgorithm.checksumConstructor();
+        }
+    });
+    return runtimeConfig;
+};

package/node_modules/@smithy/core/dist-es/submodules/client/smithy-client/extensions/defaultExtensionConfiguration.js

@@ -0,0 +1,9 @@
+import { getChecksumConfiguration, resolveChecksumRuntimeConfig, } from "./checksum";
+import { getRetryConfiguration, resolveRetryRuntimeConfig } from "./retry";
+export const getDefaultExtensionConfiguration = (runtimeConfig) => {
+    return Object.assign(getChecksumConfiguration(runtimeConfig), getRetryConfiguration(runtimeConfig));
+};
+export const getDefaultClientConfiguration = getDefaultExtensionConfiguration;
+export const resolveDefaultRuntimeConfig = (config) => {
+    return Object.assign(resolveChecksumRuntimeConfig(config), resolveRetryRuntimeConfig(config));
+};

package/node_modules/@smithy/core/dist-es/submodules/client/util-waiter/createWaiter.js

@@ -0,0 +1,48 @@
+import { runPolling } from "./poller";
+import { validateWaiterOptions } from "./utils/validate";
+import { WaiterState, waiterServiceDefaults } from "./waiter";
+const abortTimeout = (abortSignal) => {
+    let onAbort;
+    const promise = new Promise((resolve) => {
+        onAbort = () => resolve({ state: WaiterState.ABORTED });
+        if (typeof abortSignal.addEventListener === "function") {
+            abortSignal.addEventListener("abort", onAbort);
+        }
+        else {
+            abortSignal.onabort = onAbort;
+        }
+    });
+    return {
+        clearListener() {
+            if (typeof abortSignal.removeEventListener === "function") {
+                abortSignal.removeEventListener("abort", onAbort);
+            }
+        },
+        aborted: promise,
+    };
+};
+export const createWaiter = async (options, input, acceptorChecks) => {
+    const params = {
+        ...waiterServiceDefaults,
+        ...options,
+    };
+    validateWaiterOptions(params);
+    const exitConditions = [runPolling(params, input, acceptorChecks)];
+    const finalize = [];
+    if (options.abortSignal) {
+        const { aborted, clearListener } = abortTimeout(options.abortSignal);
+        finalize.push(clearListener);
+        exitConditions.push(aborted);
+    }
+    if (options.abortController?.signal) {
+        const { aborted, clearListener } = abortTimeout(options.abortController.signal);
+        finalize.push(clearListener);
+        exitConditions.push(aborted);
+    }
+    return Promise.race(exitConditions).then((result) => {
+        for (const fn of finalize) {
+            fn();
+        }
+        return result;
+    });
+};

package/node_modules/@smithy/core/dist-es/submodules/client/util-waiter/poller.js

@@ -0,0 +1,87 @@
+import { getCircularReplacer } from "./circularReplacer";
+import { sleep } from "./utils/sleep";
+import { WaiterState } from "./waiter";
+export const runPolling = async ({ minDelay, maxDelay, maxWaitTime, abortController, client, abortSignal }, input, acceptorChecks) => {
+    const observedResponses = {};
+    const [minDelayMs, maxDelayMs] = [minDelay * 1000, maxDelay * 1000];
+    let currentAttempt = 0;
+    const waitUntil = Date.now() + maxWaitTime * 1000;
+    const warn403Time = Date.now() + 60_000;
+    let didWarn403 = false;
+    while (true) {
+        if (currentAttempt > 0) {
+            const delayMs = exponentialBackoffWithJitter(minDelayMs, maxDelayMs, currentAttempt, waitUntil);
+            if (abortController?.signal?.aborted || abortSignal?.aborted) {
+                const message = "AbortController signal aborted.";
+                observedResponses[message] |= 0;
+                observedResponses[message] += 1;
+                return { state: WaiterState.ABORTED, observedResponses };
+            }
+            if (Date.now() + delayMs > waitUntil) {
+                return { state: WaiterState.TIMEOUT, observedResponses };
+            }
+            await sleep(delayMs / 1_000);
+        }
+        const { state, reason } = await acceptorChecks(client, input);
+        if (reason) {
+            const message = createMessageFromResponse(reason);
+            observedResponses[message] |= 0;
+            observedResponses[message] += 1;
+        }
+        if (state !== WaiterState.RETRY) {
+            return { state, reason, final: reason, observedResponses };
+        }
+        currentAttempt += 1;
+        if (!didWarn403 && Date.now() >= warn403Time) {
+            checkWarn403(observedResponses, client);
+            didWarn403 = true;
+        }
+    }
+};
+const checkWarn403 = (observedResponses = {}, client) => {
+    const orderedErrors = Object.keys(observedResponses);
+    let maxCount = 0;
+    let count403 = 0;
+    for (const response of orderedErrors) {
+        const n = observedResponses[response] | 0;
+        maxCount = Math.max(n, maxCount);
+        if (response.startsWith("403:")) {
+            count403 += n;
+        }
+    }
+    const clientLogger = client?.config?.logger;
+    const warningLogger = typeof clientLogger?.warn === "function" && !clientLogger.constructor?.name?.includes?.("NoOpLogger")
+        ? clientLogger
+        : console;
+    if (count403 >= 3 || orderedErrors[orderedErrors.length - 1]?.startsWith("403:")) {
+        warningLogger.warn(`@smithy/util-waiter WARN - 403 status code encountered during waiter polling.`);
+    }
+};
+const createMessageFromResponse = (reason) => {
+    const status = reason?.$response?.statusCode ?? reason?.$metadata?.httpStatusCode;
+    if (reason?.$responseBodyText) {
+        return `${status ? status + ": " : ""}Deserialization error for body: ${reason.$responseBodyText}`;
+    }
+    if (status) {
+        if (reason?.$response || reason?.message) {
+            return `${status ?? "Unknown"}: ${reason?.message}`;
+        }
+        return `${status}: OK`;
+    }
+    return String(reason?.message ?? JSON.stringify(reason, getCircularReplacer()) ?? "Unknown");
+};
+const exponentialBackoffWithJitter = (minDelayMs, maxDelayMs, attempt, waitUntil) => {
+    const attemptCountCeiling = Math.log(maxDelayMs / minDelayMs) / Math.log(2) + 1;
+    if (attempt > attemptCountCeiling) {
+        return maxDelayMs;
+    }
+    const delay = minDelayMs * 2 ** (attempt - 1);
+    const capped = Math.min(delay, maxDelayMs);
+    const waitFor = randomInRange(minDelayMs, capped);
+    if (Date.now() + waitFor > waitUntil) {
+        const timeRemaining = waitUntil - Date.now();
+        return Math.max(0, timeRemaining - 500);
+    }
+    return waitFor;
+};
+const randomInRange = (min, max) => min + Math.random() * (max - min);

package/node_modules/@smithy/core/dist-es/submodules/config/config-resolver/endpointsConfig/NodeUseDualstackEndpointConfigOptions.js

@@ -0,0 +1,15 @@
+import { booleanSelector } from "../../util-config-provider/booleanSelector";
+import { SelectorType } from "../../util-config-provider/types";
+export const ENV_USE_DUALSTACK_ENDPOINT = "AWS_USE_DUALSTACK_ENDPOINT";
+export const CONFIG_USE_DUALSTACK_ENDPOINT = "use_dualstack_endpoint";
+export const DEFAULT_USE_DUALSTACK_ENDPOINT = false;
+export const NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_DUALSTACK_ENDPOINT, SelectorType.ENV),
+    configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, SelectorType.CONFIG),
+    default: false,
+};
+export const nodeDualstackConfigSelectors = {
+    environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_DUALSTACK_ENDPOINT, SelectorType.ENV),
+    configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, SelectorType.CONFIG),
+    default: undefined,
+};

package/node_modules/@smithy/core/dist-es/submodules/config/config-resolver/endpointsConfig/NodeUseFipsEndpointConfigOptions.js

@@ -0,0 +1,15 @@
+import { booleanSelector } from "../../util-config-provider/booleanSelector";
+import { SelectorType } from "../../util-config-provider/types";
+export const ENV_USE_FIPS_ENDPOINT = "AWS_USE_FIPS_ENDPOINT";
+export const CONFIG_USE_FIPS_ENDPOINT = "use_fips_endpoint";
+export const DEFAULT_USE_FIPS_ENDPOINT = false;
+export const NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_FIPS_ENDPOINT, SelectorType.ENV),
+    configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, SelectorType.CONFIG),
+    default: false,
+};
+export const nodeFipsConfigSelectors = {
+    environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_FIPS_ENDPOINT, SelectorType.ENV),
+    configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, SelectorType.CONFIG),
+    default: undefined,
+};

package/node_modules/@smithy/core/dist-es/submodules/config/config-resolver/endpointsConfig/resolveCustomEndpointsConfig.js

@@ -0,0 +1,10 @@
+import { normalizeProvider } from "@smithy/core/client";
+export const resolveCustomEndpointsConfig = (input) => {
+    const { tls, endpoint, urlParser, useDualstackEndpoint } = input;
+    return Object.assign(input, {
+        tls: tls ?? true,
+        endpoint: normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint),
+        isCustomEndpoint: true,
+        useDualstackEndpoint: normalizeProvider(useDualstackEndpoint ?? false),
+    });
+};

package/node_modules/@smithy/core/dist-es/submodules/config/config-resolver/endpointsConfig/resolveEndpointsConfig.js

@@ -0,0 +1,14 @@
+import { normalizeProvider } from "@smithy/core/client";
+import { getEndpointFromRegion } from "./utils/getEndpointFromRegion";
+export const resolveEndpointsConfig = (input) => {
+    const useDualstackEndpoint = normalizeProvider(input.useDualstackEndpoint ?? false);
+    const { endpoint, useFipsEndpoint, urlParser, tls } = input;
+    return Object.assign(input, {
+        tls: tls ?? true,
+        endpoint: endpoint
+            ? normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint)
+            : () => getEndpointFromRegion({ ...input, useDualstackEndpoint, useFipsEndpoint }),
+        isCustomEndpoint: !!endpoint,
+        useDualstackEndpoint,
+    });
+};

package/node_modules/@smithy/core/dist-es/submodules/config/config-resolver/regionConfig/checkRegion.js

@@ -0,0 +1,15 @@
+import { isValidHostLabel } from "@smithy/core/endpoints";
+const validRegions = new Set();
+export const checkRegion = (region, check = isValidHostLabel) => {
+    if (!validRegions.has(region) && !check(region)) {
+        if (region === "*") {
+            console.warn(`@smithy/config-resolver WARN - Please use the caller region instead of "*". See "sigv4a" in https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md.`);
+        }
+        else {
+            throw new Error(`Region not accepted: region="${region}" is not a valid hostname component.`);
+        }
+    }
+    else {
+        validRegions.add(region);
+    }
+};

package/node_modules/@smithy/core/dist-es/submodules/config/defaults-mode/resolveDefaultsModeConfig.browser.js

@@ -0,0 +1,30 @@
+import { memoize } from "../property-provider/memoize";
+import { DEFAULTS_MODE_OPTIONS } from "./constants";
+export const resolveDefaultsModeConfig = ({ defaultsMode, } = {}) => memoize(async () => {
+    const mode = typeof defaultsMode === "function" ? await defaultsMode() : defaultsMode;
+    switch (mode?.toLowerCase()) {
+        case "auto":
+            return Promise.resolve(useMobileConfiguration() ? "mobile" : "standard");
+        case "mobile":
+        case "in-region":
+        case "cross-region":
+        case "standard":
+        case "legacy":
+            return Promise.resolve(mode?.toLocaleLowerCase());
+        case undefined:
+            return Promise.resolve("legacy");
+        default:
+            throw new Error(`Invalid parameter for "defaultsMode", expect ${DEFAULTS_MODE_OPTIONS.join(", ")}, got ${mode}`);
+    }
+});
+const useMobileConfiguration = () => {
+    const navigator = window?.navigator;
+    if (navigator?.connection) {
+        const { effectiveType, rtt, downlink } = navigator?.connection;
+        const slow = (typeof effectiveType === "string" && effectiveType !== "4g") || Number(rtt) > 100 || Number(downlink) < 10;
+        if (slow) {
+            return true;
+        }
+    }
+    return (navigator?.userAgentData?.mobile || (typeof navigator?.maxTouchPoints === "number" && navigator?.maxTouchPoints > 1));
+};

package/node_modules/@smithy/core/dist-es/submodules/config/defaults-mode/resolveDefaultsModeConfig.js

@@ -0,0 +1,98 @@
+import { NODE_REGION_CONFIG_OPTIONS } from "../config-resolver/regionConfig/config";
+import { loadConfig } from "../node-config-provider/configLoader";
+import { memoize } from "../property-provider/memoize";
+import { AWS_DEFAULT_REGION_ENV, AWS_EXECUTION_ENV, AWS_REGION_ENV, DEFAULTS_MODE_OPTIONS, ENV_IMDS_DISABLED, IMDS_REGION_PATH, } from "./constants";
+import { NODE_DEFAULTS_MODE_CONFIG_OPTIONS } from "./defaultsModeConfig";
+export const resolveDefaultsModeConfig = ({ region = loadConfig(NODE_REGION_CONFIG_OPTIONS), defaultsMode = loadConfig(NODE_DEFAULTS_MODE_CONFIG_OPTIONS), } = {}) => memoize(async () => {
+    const mode = typeof defaultsMode === "function" ? await defaultsMode() : defaultsMode;
+    switch (mode?.toLowerCase()) {
+        case "auto":
+            return resolveNodeDefaultsModeAuto(region);
+        case "in-region":
+        case "cross-region":
+        case "mobile":
+        case "standard":
+        case "legacy":
+            return Promise.resolve(mode?.toLocaleLowerCase());
+        case undefined:
+            return Promise.resolve("legacy");
+        default:
+            throw new Error(`Invalid parameter for "defaultsMode", expect ${DEFAULTS_MODE_OPTIONS.join(", ")}, got ${mode}`);
+    }
+});
+const resolveNodeDefaultsModeAuto = async (clientRegion) => {
+    if (clientRegion) {
+        const resolvedRegion = typeof clientRegion === "function" ? await clientRegion() : clientRegion;
+        const inferredRegion = await inferPhysicalRegion();
+        if (!inferredRegion) {
+            return "standard";
+        }
+        if (resolvedRegion === inferredRegion) {
+            return "in-region";
+        }
+        else {
+            return "cross-region";
+        }
+    }
+    return "standard";
+};
+const inferPhysicalRegion = async () => {
+    if (process.env[AWS_EXECUTION_ENV] && (process.env[AWS_REGION_ENV] || process.env[AWS_DEFAULT_REGION_ENV])) {
+        return process.env[AWS_REGION_ENV] ?? process.env[AWS_DEFAULT_REGION_ENV];
+    }
+    if (!process.env[ENV_IMDS_DISABLED]) {
+        try {
+            const endpoint = await getImdsEndpoint();
+            return (await imdsHttpGet({ hostname: endpoint.hostname, path: IMDS_REGION_PATH })).toString();
+        }
+        catch (e) {
+        }
+    }
+};
+const getImdsEndpoint = async () => {
+    const envEndpoint = process.env.AWS_EC2_METADATA_SERVICE_ENDPOINT;
+    if (envEndpoint) {
+        const url = new URL(envEndpoint);
+        return { hostname: url.hostname, path: url.pathname };
+    }
+    const envMode = process.env.AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE;
+    if (envMode === "IPv6") {
+        return { hostname: "fd00:ec2::254", path: "/" };
+    }
+    return { hostname: "169.254.169.254", path: "/" };
+};
+const imdsHttpGet = async ({ hostname, path }) => {
+    const { request } = await import("node:http");
+    return new Promise((resolve, reject) => {
+        const req = request({
+            method: "GET",
+            hostname: hostname.replace(/^\[(.+)]$/, "$1"),
+            path,
+            timeout: 1000,
+            signal: AbortSignal.timeout(1000),
+        });
+        req.on("error", (err) => {
+            reject(err);
+            req.destroy();
+        });
+        req.on("timeout", () => {
+            reject(new Error("TimeoutError from instance metadata service"));
+            req.destroy();
+        });
+        req.on("response", (res) => {
+            const { statusCode = 400 } = res;
+            if (statusCode < 200 || 300 <= statusCode) {
+                reject(Object.assign(new Error("Error response received from instance metadata service"), { statusCode }));
+                req.destroy();
+                return;
+            }
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                resolve(Buffer.concat(chunks));
+                req.destroy();
+            });
+        });
+        req.end();
+    });
+};

package/node_modules/@smithy/core/dist-es/submodules/config/defaults-mode/resolveDefaultsModeConfig.native.js

@@ -0,0 +1,19 @@
+import { memoize } from "../property-provider/memoize";
+import { DEFAULTS_MODE_OPTIONS } from "./constants";
+export const resolveDefaultsModeConfig = ({ defaultsMode, } = {}) => memoize(async () => {
+    const mode = typeof defaultsMode === "function" ? await defaultsMode() : defaultsMode;
+    switch (mode?.toLowerCase()) {
+        case "auto":
+            return Promise.resolve("mobile");
+        case "mobile":
+        case "in-region":
+        case "cross-region":
+        case "standard":
+        case "legacy":
+            return Promise.resolve(mode?.toLocaleLowerCase());
+        case undefined:
+            return Promise.resolve("legacy");
+        default:
+            throw new Error(`Invalid parameter for "defaultsMode", expect ${DEFAULTS_MODE_OPTIONS.join(", ")}, got ${mode}`);
+    }
+});

package/node_modules/@smithy/core/dist-es/submodules/config/index.browser.js

@@ -0,0 +1,43 @@
+const no = Symbol.for("node-only");
+export { ProviderError } from "./property-provider/ProviderError";
+export { CredentialsProviderError } from "./property-provider/CredentialsProviderError";
+export { TokenProviderError } from "./property-provider/TokenProviderError";
+export { chain } from "./property-provider/chain";
+export { fromValue } from "./property-provider/fromValue";
+export { memoize } from "./property-provider/memoize";
+export { booleanSelector } from "./util-config-provider/booleanSelector";
+export { numberSelector } from "./util-config-provider/numberSelector";
+export { SelectorType } from "./util-config-provider/types";
+export const getHomeDir = no;
+export const ENV_PROFILE = no;
+export const DEFAULT_PROFILE = "default";
+export const getProfileName = no;
+export const getSSOTokenFilepath = no;
+export const getSSOTokenFromFile = no;
+export const CONFIG_PREFIX_SEPARATOR = no;
+export const loadSharedConfigFiles = no;
+export const loadSsoSessionData = no;
+export const parseKnownFiles = no;
+export const externalDataInterceptor = no;
+export const readFile = no;
+export const loadConfig = no;
+export const fromStatic = no;
+export const ENV_USE_DUALSTACK_ENDPOINT = no;
+export const CONFIG_USE_DUALSTACK_ENDPOINT = no;
+export const DEFAULT_USE_DUALSTACK_ENDPOINT = false;
+export const NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = no;
+export const nodeDualstackConfigSelectors = no;
+export const ENV_USE_FIPS_ENDPOINT = no;
+export const CONFIG_USE_FIPS_ENDPOINT = no;
+export const DEFAULT_USE_FIPS_ENDPOINT = false;
+export const NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = no;
+export const nodeFipsConfigSelectors = no;
+export { resolveCustomEndpointsConfig, } from "./config-resolver/endpointsConfig/resolveCustomEndpointsConfig";
+export { resolveEndpointsConfig, } from "./config-resolver/endpointsConfig/resolveEndpointsConfig";
+export const REGION_ENV_NAME = no;
+export const REGION_INI_NAME = no;
+export const NODE_REGION_CONFIG_OPTIONS = no;
+export const NODE_REGION_CONFIG_FILE_OPTIONS = no;
+export { resolveRegionConfig, } from "./config-resolver/regionConfig/resolveRegionConfig";
+export { getRegionInfo } from "./config-resolver/regionInfo/getRegionInfo";
+export { resolveDefaultsModeConfig, } from "./defaults-mode/resolveDefaultsModeConfig.browser";

package/node_modules/@smithy/core/dist-es/submodules/config/index.js

@@ -0,0 +1,29 @@
+export { ProviderError } from "./property-provider/ProviderError";
+export { CredentialsProviderError } from "./property-provider/CredentialsProviderError";
+export { TokenProviderError } from "./property-provider/TokenProviderError";
+export { chain } from "./property-provider/chain";
+export { fromValue } from "./property-provider/fromValue";
+export { memoize } from "./property-provider/memoize";
+export { booleanSelector } from "./util-config-provider/booleanSelector";
+export { numberSelector } from "./util-config-provider/numberSelector";
+export { SelectorType } from "./util-config-provider/types";
+export { getHomeDir } from "./shared-ini-file-loader/getHomeDir";
+export { ENV_PROFILE, DEFAULT_PROFILE, getProfileName } from "./shared-ini-file-loader/getProfileName";
+export { getSSOTokenFilepath } from "./shared-ini-file-loader/getSSOTokenFilepath";
+export { getSSOTokenFromFile } from "./shared-ini-file-loader/getSSOTokenFromFile";
+export { CONFIG_PREFIX_SEPARATOR } from "./shared-ini-file-loader/constants";
+export { loadSharedConfigFiles } from "./shared-ini-file-loader/loadSharedConfigFiles";
+export { loadSsoSessionData } from "./shared-ini-file-loader/loadSsoSessionData";
+export { parseKnownFiles } from "./shared-ini-file-loader/parseKnownFiles";
+export { externalDataInterceptor } from "./shared-ini-file-loader/externalDataInterceptor";
+export { readFile } from "./shared-ini-file-loader/readFile";
+export { loadConfig } from "./node-config-provider/configLoader";
+export { fromStatic } from "./node-config-provider/fromStatic";
+export { ENV_USE_DUALSTACK_ENDPOINT, CONFIG_USE_DUALSTACK_ENDPOINT, DEFAULT_USE_DUALSTACK_ENDPOINT, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, nodeDualstackConfigSelectors, } from "./config-resolver/endpointsConfig/NodeUseDualstackEndpointConfigOptions";
+export { ENV_USE_FIPS_ENDPOINT, CONFIG_USE_FIPS_ENDPOINT, DEFAULT_USE_FIPS_ENDPOINT, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, nodeFipsConfigSelectors, } from "./config-resolver/endpointsConfig/NodeUseFipsEndpointConfigOptions";
+export { resolveCustomEndpointsConfig, } from "./config-resolver/endpointsConfig/resolveCustomEndpointsConfig";
+export { resolveEndpointsConfig, } from "./config-resolver/endpointsConfig/resolveEndpointsConfig";
+export { REGION_ENV_NAME, REGION_INI_NAME, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, } from "./config-resolver/regionConfig/config";
+export { resolveRegionConfig, } from "./config-resolver/regionConfig/resolveRegionConfig";
+export { getRegionInfo } from "./config-resolver/regionInfo/getRegionInfo";
+export { resolveDefaultsModeConfig, } from "./defaults-mode/resolveDefaultsModeConfig";

package/node_modules/@smithy/core/dist-es/submodules/config/index.native.js

@@ -0,0 +1,43 @@
+const no = Symbol.for("node-only");
+export { ProviderError } from "./property-provider/ProviderError";
+export { CredentialsProviderError } from "./property-provider/CredentialsProviderError";
+export { TokenProviderError } from "./property-provider/TokenProviderError";
+export { chain } from "./property-provider/chain";
+export { fromValue } from "./property-provider/fromValue";
+export { memoize } from "./property-provider/memoize";
+export { booleanSelector } from "./util-config-provider/booleanSelector";
+export { numberSelector } from "./util-config-provider/numberSelector";
+export { SelectorType } from "./util-config-provider/types";
+export const getHomeDir = no;
+export const ENV_PROFILE = no;
+export const DEFAULT_PROFILE = "default";
+export const getProfileName = no;
+export const getSSOTokenFilepath = no;
+export const getSSOTokenFromFile = no;
+export const CONFIG_PREFIX_SEPARATOR = no;
+export const loadSharedConfigFiles = no;
+export const loadSsoSessionData = no;
+export const parseKnownFiles = no;
+export const externalDataInterceptor = no;
+export const readFile = no;
+export const loadConfig = no;
+export const fromStatic = no;
+export const ENV_USE_DUALSTACK_ENDPOINT = no;
+export const CONFIG_USE_DUALSTACK_ENDPOINT = no;
+export const DEFAULT_USE_DUALSTACK_ENDPOINT = false;
+export const NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = no;
+export const nodeDualstackConfigSelectors = no;
+export const ENV_USE_FIPS_ENDPOINT = no;
+export const CONFIG_USE_FIPS_ENDPOINT = no;
+export const DEFAULT_USE_FIPS_ENDPOINT = false;
+export const NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = no;
+export const nodeFipsConfigSelectors = no;
+export { resolveCustomEndpointsConfig, } from "./config-resolver/endpointsConfig/resolveCustomEndpointsConfig";
+export { resolveEndpointsConfig, } from "./config-resolver/endpointsConfig/resolveEndpointsConfig";
+export const REGION_ENV_NAME = no;
+export const REGION_INI_NAME = no;
+export const NODE_REGION_CONFIG_OPTIONS = no;
+export const NODE_REGION_CONFIG_FILE_OPTIONS = no;
+export { resolveRegionConfig, } from "./config-resolver/regionConfig/resolveRegionConfig";
+export { getRegionInfo } from "./config-resolver/regionInfo/getRegionInfo";
+export { resolveDefaultsModeConfig, } from "./defaults-mode/resolveDefaultsModeConfig.native";

package/node_modules/@smithy/core/dist-es/submodules/config/node-config-provider/configLoader.js

@@ -0,0 +1,10 @@
+import { chain } from "../property-provider/chain";
+import { memoize } from "../property-provider/memoize";
+import { fromEnv } from "./fromEnv";
+import { fromSharedConfigFiles } from "./fromSharedConfigFiles";
+import { fromStatic } from "./fromStatic";
+export const loadConfig = ({ environmentVariableSelector, configFileSelector, default: defaultValue }, configuration = {}) => {
+    const { signingName, logger } = configuration;
+    const envOptions = { signingName, logger };
+    return memoize(chain(fromEnv(environmentVariableSelector, envOptions), fromSharedConfigFiles(configFileSelector, configuration), fromStatic(defaultValue)));
+};

package/node_modules/@smithy/core/dist-es/submodules/config/node-config-provider/fromEnv.js

@@ -0,0 +1,14 @@
+import { CredentialsProviderError } from "../property-provider/CredentialsProviderError";
+import { getSelectorName } from "./getSelectorName";
+export const fromEnv = (envVarSelector, options) => async () => {
+    try {
+        const config = envVarSelector(process.env, options);
+        if (config === undefined) {
+            throw new Error();
+        }
+        return config;
+    }
+    catch (e) {
+        throw new CredentialsProviderError(e.message || `Not found in ENV: ${getSelectorName(envVarSelector.toString())}`, { logger: options?.logger });
+    }
+};

package/node_modules/@smithy/core/dist-es/submodules/config/node-config-provider/fromSharedConfigFiles.js

@@ -0,0 +1,24 @@
+import { CredentialsProviderError } from "../property-provider/CredentialsProviderError";
+import { getProfileName } from "../shared-ini-file-loader/getProfileName";
+import { loadSharedConfigFiles } from "../shared-ini-file-loader/loadSharedConfigFiles";
+import { getSelectorName } from "./getSelectorName";
+export const fromSharedConfigFiles = (configSelector, { preferredFile = "config", ...init } = {}) => async () => {
+    const profile = getProfileName(init);
+    const { configFile, credentialsFile } = await loadSharedConfigFiles(init);
+    const profileFromCredentials = credentialsFile[profile] || {};
+    const profileFromConfig = configFile[profile] || {};
+    const mergedProfile = preferredFile === "config"
+        ? { ...profileFromCredentials, ...profileFromConfig }
+        : { ...profileFromConfig, ...profileFromCredentials };
+    try {
+        const cfgFile = preferredFile === "config" ? configFile : credentialsFile;
+        const configValue = configSelector(mergedProfile, cfgFile);
+        if (configValue === undefined) {
+            throw new Error();
+        }
+        return configValue;
+    }
+    catch (e) {
+        throw new CredentialsProviderError(e.message || `Not found in config files w/ profile [${profile}]: ${getSelectorName(configSelector.toString())}`, { logger: init.logger });
+    }
+};

package/node_modules/@smithy/core/dist-es/submodules/config/node-config-provider/fromStatic.js

@@ -0,0 +1,3 @@
+import { fromValue } from "../property-provider/fromValue";
+const isFunction = (func) => typeof func === "function";
+export const fromStatic = (defaultValue) => isFunction(defaultValue) ? async () => await defaultValue() : fromValue(defaultValue);

package/node_modules/@smithy/core/dist-es/submodules/config/property-provider/fromValue.js

@@ -0,0 +1 @@
+export const fromValue = (staticValue) => () => Promise.resolve(staticValue);

package/node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/getConfigFilepath.js

@@ -0,0 +1,4 @@
+import { join } from "node:path";
+import { getHomeDir } from "./getHomeDir";
+export const ENV_CONFIG_PATH = "AWS_CONFIG_FILE";
+export const getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || join(getHomeDir(), ".aws", "config");

package/node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/getCredentialsFilepath.js

@@ -0,0 +1,4 @@
+import { join } from "node:path";
+import { getHomeDir } from "./getHomeDir";
+export const ENV_CREDENTIALS_PATH = "AWS_SHARED_CREDENTIALS_FILE";
+export const getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || join(getHomeDir(), ".aws", "credentials");

package/node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/getHomeDir.js

@@ -0,0 +1,22 @@
+import { homedir } from "node:os";
+import { sep } from "node:path";
+const homeDirCache = {};
+const getHomeDirCacheKey = () => {
+    if (process && process.geteuid) {
+        return `${process.geteuid()}`;
+    }
+    return "DEFAULT";
+};
+export const getHomeDir = () => {
+    const { HOME, USERPROFILE, HOMEPATH, HOMEDRIVE = `C:${sep}` } = process.env;
+    if (HOME)
+        return HOME;
+    if (USERPROFILE)
+        return USERPROFILE;
+    if (HOMEPATH)
+        return `${HOMEDRIVE}${HOMEPATH}`;
+    const homeDirCacheKey = getHomeDirCacheKey();
+    if (!homeDirCache[homeDirCacheKey])
+        homeDirCache[homeDirCacheKey] = homedir();
+    return homeDirCache[homeDirCacheKey];
+};

package/node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/getSSOTokenFilepath.js

@@ -0,0 +1,8 @@
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { getHomeDir } from "./getHomeDir";
+export const getSSOTokenFilepath = (id) => {
+    const hasher = createHash("sha1");
+    const cacheName = hasher.update(id).digest("hex");
+    return join(getHomeDir(), ".aws", "sso", "cache", `${cacheName}.json`);
+};