/var/runtime/node_modules/@aws-sdk/core/dist-cjs/submodules/httpAuthSchemes
This explorer reads the filesystem of the server it runs on, so /workspace/user isn't present here. Browsing and the terminal still work against this server's own disk from /.
'use strict'; var protocols = require('@smithy/core/protocols');var core = require('@smithy/core');var config = require('@smithy/core/config');var client = require('@aws-sdk/core/client');var signatureV4 = require('@smithy/signature-v4'); const getDateHeader = (response) => protocols.HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : undefined; const getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset); const isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 300000; const getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => { const clockTimeInMs = Date.parse(clockTime); if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) { return clockTimeInMs - Date.now(); } return currentSystemClockOffset;}; const throwSigningPropertyError = (name, property) => { if (!property) { throw new Error(`Property \`${name}\` is not resolved for AWS SDK SigV4Auth`); } return property;};const validateSigningProperties = async (signingProperties) => { const context = throwSigningPropertyError("context", signingProperties.context); const config = throwSigningPropertyError("config", signingProperties.config); const authScheme = context.endpointV2?.properties?.authSchemes?.[0]; const signerFunction = throwSigningPropertyError("signer", config.signer); const signer = await signerFunction(authScheme); const signingRegion = signingProperties?.signingRegion; const signingRegionSet = signingProperties?.signingRegionSet; const signingName = signingProperties?.signingName; return { config, signer, signingRegion, signingRegionSet, signingName, };};class AwsSdkSigV4Signer { async sign(httpRequest, identity, signingProperties) { if (!protocols.HttpRequest.isInstance(httpRequest)) { throw new Error("The request is not an instance of `HttpRequest` and cannot be signed"); } const validatedProps = await validateSigningProperties(signingProperties); const { config, signer } = validatedProps; let { signingRegion, signingName } = validatedProps; const handlerExecutionContext = signingProperties.context; if (handlerExecutionContext?.authSchemes?.length ?? 0 > 1) { const [first, second] = handlerExecutionContext.authSchemes; if (first?.name === "sigv4a" && second?.name === "sigv4") { signingRegion = second?.signingRegion ?? signingRegion; signingName = second?.signingName ?? signingName; } } const signedRequest = await signer.sign(httpRequest, { signingDate: getSkewCorrectedDate(config.systemClockOffset), signingRegion: signingRegion, signingService: signingName, }); return signedRequest; } errorHandler(signingProperties) { return (error) => { const serverTime = error.ServerTime ?? getDateHeader(error.$response); if (serverTime) { const config = throwSigningPropertyError("config", signingProperties.config); const initialSystemClockOffset = config.systemClockOffset; config.systemClockOffset = getUpdatedSystemClockOffset(serverTime, config.systemClockOffset); const clockSkewCorrected = config.systemClockOffset !== initialSystemClockOffset; if (clockSkewCorrected && error.$metadata) { error.$metadata.clockSkewCorrected = true; } } throw error; }; } successHandler(httpResponse, signingProperties) { const dateHeader = getDateHeader(httpResponse); if (dateHeader) { const config = throwSigningPropertyError("config", signingProperties.config); config.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, config.systemClockOffset); } }}const AWSSDKSigV4Signer = AwsSdkSigV4Signer; class AwsSdkSigV4ASigner extends AwsSdkSigV4Signer { async sign(httpRequest, identity, signingProperties) { if (!protocols.HttpRequest.isInstance(httpRequest)) { throw new Error("The request is not an instance of `HttpRequest` and cannot be signed"); } const { config, signer, signingRegion, signingRegionSet, signingName } = await validateSigningProperties(signingProperties); const configResolvedSigningRegionSet = await config.sigv4aSigningRegionSet?.(); const multiRegionOverride = (configResolvedSigningRegionSet ?? signingRegionSet ?? [signingRegion]).join(","); const signedRequest = await signer.sign(httpRequest, { signingDate: getSkewCorrectedDate(config.systemClockOffset), signingRegion: multiRegionOverride, signingService: signingName, }); return signedRequest; }} const getArrayForCommaSeparatedString = (str) => typeof str === "string" && str.length > 0 ? str.split(",").map((item) => item.trim()) : []; const getBearerTokenEnvKey = (signingName) => `AWS_BEARER_TOKEN_${signingName.replace(/[\s-]/g, "_").toUpperCase()}`; const NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY = "AWS_AUTH_SCHEME_PREFERENCE";const NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY = "auth_scheme_preference";const NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = { environmentVariableSelector: (env, options) => { if (options?.signingName) { const bearerTokenKey = getBearerTokenEnvKey(options.signingName); if (bearerTokenKey in env) return ["httpBearerAuth"]; } if (!(NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY in env)) return undefined; return getArrayForCommaSeparatedString(env[NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY]); }, configFileSelector: (profile) => { if (!(NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY in profile)) return undefined; return getArrayForCommaSeparatedString(profile[NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY]); }, default: [],}; const resolveAwsSdkSigV4AConfig = (config) => { config.sigv4aSigningRegionSet = core.normalizeProvider(config.sigv4aSigningRegionSet); return config;};const NODE_SIGV4A_CONFIG_OPTIONS = { environmentVariableSelector(env) { if (env.AWS_SIGV4A_SIGNING_REGION_SET) { return env.AWS_SIGV4A_SIGNING_REGION_SET.split(",").map((_) => _.trim()); } throw new config.ProviderError("AWS_SIGV4A_SIGNING_REGION_SET not set in env.", { tryNextLink: true, }); }, configFileSelector(profile) { if (profile.sigv4a_signing_region_set) { return (profile.sigv4a_signing_region_set ?? "").split(",").map((_) => _.trim()); } throw new config.ProviderError("sigv4a_signing_region_set not set in profile.", { tryNextLink: true, }); }, default: undefined,}; const resolveAwsSdkSigV4Config = (config) => { let inputCredentials = config.credentials; let isUserSupplied = !!config.credentials; let resolvedCredentials = undefined; Object.defineProperty(config, "credentials", { set(credentials) { if (credentials && credentials !== inputCredentials && credentials !== resolvedCredentials) { isUserSupplied = true; } inputCredentials = credentials; const memoizedProvider = normalizeCredentialProvider(config, { credentials: inputCredentials, credentialDefaultProvider: config.credentialDefaultProvider, }); const boundProvider = bindCallerConfig(config, memoizedProvider); if (isUserSupplied && !boundProvider.attributed) { const isCredentialObject = typeof inputCredentials === "object" && inputCredentials !== null; resolvedCredentials = async (options) => { const creds = await boundProvider(options); const attributedCreds = creds; if (isCredentialObject && (!attributedCreds.$source || Object.keys(attributedCreds.$source).length === 0)) { return client.setCredentialFeature(attributedCreds, "CREDENTIALS_CODE", "e"); } return attributedCreds; }; resolvedCredentials.memoized = boundProvider.memoized; resolvedCredentials.configBound = boundProvider.configBound; resolvedCredentials.attributed = true; } else { resolvedCredentials = boundProvider; } }, get() { return resolvedCredentials; }, enumerable: true, configurable: true, }); config.credentials = inputCredentials; const { signingEscapePath = true, systemClockOffset = config.systemClockOffset || 0, sha256, } = config; let signer; if (config.signer) { signer = core.normalizeProvider(config.signer); } else if (config.regionInfoProvider) { signer = () => core.normalizeProvider(config.region)() .then(async (region) => [ (await config.regionInfoProvider(region, { useFipsEndpoint: await config.useFipsEndpoint(), useDualstackEndpoint: await config.useDualstackEndpoint(), })) || {}, region, ]) .then(([regionInfo, region]) => { const { signingRegion, signingService } = regionInfo; config.signingRegion = config.signingRegion || signingRegion || region; config.signingName = config.signingName || signingService || config.serviceId; const params = { ...config, credentials: config.credentials, region: config.signingRegion, service: config.signingName, sha256, uriEscapePath: signingEscapePath, }; const SignerCtor = config.signerConstructor || signatureV4.SignatureV4; return new SignerCtor(params); }); } else { signer = async (authScheme) => { authScheme = Object.assign({}, { name: "sigv4", signingName: config.signingName || config.defaultSigningName, signingRegion: await core.normalizeProvider(config.region)(), properties: {}, }, authScheme); const signingRegion = authScheme.signingRegion; const signingService = authScheme.signingName; config.signingRegion = config.signingRegion || signingRegion; config.signingName = config.signingName || signingService || config.serviceId; const params = { ...config, credentials: config.credentials, region: config.signingRegion, service: config.signingName, sha256, uriEscapePath: signingEscapePath, }; const SignerCtor = config.signerConstructor || signatureV4.SignatureV4; return new SignerCtor(params); }; } const resolvedConfig = Object.assign(config, { systemClockOffset, signingEscapePath, signer, }); return resolvedConfig;};const resolveAWSSDKSigV4Config = resolveAwsSdkSigV4Config;function normalizeCredentialProvider(config, { credentials, credentialDefaultProvider, }) { let credentialsProvider; if (credentials) { if (!credentials?.memoized) { credentialsProvider = core.memoizeIdentityProvider(credentials, core.isIdentityExpired, core.doesIdentityRequireRefresh); } else { credentialsProvider = credentials; } } else { if (credentialDefaultProvider) { credentialsProvider = core.normalizeProvider(credentialDefaultProvider(Object.assign({}, config, { parentClientConfig: config, }))); } else { credentialsProvider = async () => { throw new Error("@aws-sdk/core::resolveAwsSdkSigV4Config - `credentials` not provided and no credentialDefaultProvider was configured."); }; } } credentialsProvider.memoized = true; return credentialsProvider;}function bindCallerConfig(config, credentialsProvider) { if (credentialsProvider.configBound) { return credentialsProvider; } const fn = async (options) => credentialsProvider({ ...options, callerClientConfig: config }); fn.memoized = credentialsProvider.memoized; fn.configBound = true; return fn;} exports.AWSSDKSigV4Signer = AWSSDKSigV4Signer;exports.AwsSdkSigV4ASigner = AwsSdkSigV4ASigner;exports.AwsSdkSigV4Signer = AwsSdkSigV4Signer;exports.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = NODE_AUTH_SCHEME_PREFERENCE_OPTIONS;exports.NODE_SIGV4A_CONFIG_OPTIONS = NODE_SIGV4A_CONFIG_OPTIONS;exports.getBearerTokenEnvKey = getBearerTokenEnvKey;exports.resolveAWSSDKSigV4Config = resolveAWSSDKSigV4Config;exports.resolveAwsSdkSigV4AConfig = resolveAwsSdkSigV4AConfig;exports.resolveAwsSdkSigV4Config = resolveAwsSdkSigV4Config;exports.validateSigningProperties = validateSigningProperties;