@stacksjs/actions 0.70.10 → 0.70.12

package/dist/chunk-q9dmga3k.js

@@ -0,0 +1,11 @@
+// @bun
+import {
+  d,
+  h
+} from "./chunk-mdqphqep.js";
+import"./chunk-qhh0v93n.js";
+import"./chunk-9v6qtbez.js";
+export {
+  d as stringifyJSONC,
+  h as parseJSONC
+};

package/dist/chunk-qhh0v93n.js

@@ -0,0 +1,73 @@
+// ../../../../node_modules/confbox/dist/shared/confbox.CiPrvALD.mjs
+var b = /^(?:( )+|\t+)/;
+var d = "space";
+var h = "tab";
+function g(e, t) {
+  const n = new Map;
+  let s = 0, o, i;
+  for (const c of e.split(/\n/g)) {
+    if (!c)
+      continue;
+    let f, a, l, p, r;
+    const y = c.match(b);
+    if (y === null)
+      s = 0, o = "";
+    else {
+      if (f = y[0].length, a = y[1] ? d : h, t && a === d && f === 1)
+        continue;
+      a !== o && (s = 0), o = a, l = 1, p = 0;
+      const u = f - s;
+      if (s = f, u === 0)
+        l = 0, p = 1;
+      else {
+        const I = u > 0 ? u : -u;
+        i = T(a, I);
+      }
+      r = n.get(i), r = r === undefined ? [1, 0] : [r[0] + l, r[1] + p], n.set(i, r);
+    }
+  }
+  return n;
+}
+function T(e, t) {
+  return (e === d ? "s" : "t") + String(t);
+}
+function w(e) {
+  const n = e[0] === "s" ? d : h, s = Number(e.slice(1));
+  return { type: n, amount: s };
+}
+function E(e) {
+  let t, n = 0, s = 0;
+  for (const [o, [i, c]] of e)
+    (i > n || i === n && c > s) && (n = i, s = c, t = o);
+  return t;
+}
+function S(e, t) {
+  return (e === d ? " " : "\t").repeat(t);
+}
+function _(e) {
+  if (typeof e != "string")
+    throw new TypeError("Expected a string");
+  let t = g(e, true);
+  t.size === 0 && (t = g(e, false));
+  const n = E(t);
+  let s, o = 0, i = "";
+  return n !== undefined && ({ type: s, amount: o } = w(n), i = S(s, o)), { amount: o, type: s, indent: i };
+}
+var m = Symbol.for("__confbox_fmt__");
+var k = /^(\s+)/;
+var v = /(\s+)$/;
+function x(e, t = {}) {
+  const n = t.indent === undefined && t.preserveIndentation !== false && e.slice(0, t?.sampleSize || 1024), s = t.preserveWhitespace === false ? undefined : { start: k.exec(e)?.[0] || "", end: v.exec(e)?.[0] || "" };
+  return { sample: n, whiteSpace: s };
+}
+function N(e, t, n) {
+  !t || typeof t != "object" || Object.defineProperty(t, m, { enumerable: false, configurable: true, writable: true, value: x(e, n) });
+}
+function C(e, t) {
+  if (!e || typeof e != "object" || !(m in e))
+    return { indent: t?.indent, whitespace: { start: "", end: "" } };
+  const n = e[m];
+  return { indent: t?.indent || _(n.sample || "").indent, whitespace: n.whiteSpace || { start: "", end: "" } };
+}
+
+export { N, C };

package/dist/chunk-qkm8e752.js

@@ -0,0 +1,51 @@
+// @bun
+import {
+  CredentialsProviderError
+} from "./chunk-zzerxbrm.js";
+import {
+  require_client
+} from "./chunk-frw3va9v.js";
+import {
+  __toESM
+} from "./chunk-9v6qtbez.js";
+
+// ../../../../node_modules/@aws-sdk/credential-provider-env/dist-es/fromEnv.js
+var import_client = __toESM(require_client(), 1);
+var ENV_KEY = "AWS_ACCESS_KEY_ID";
+var ENV_SECRET = "AWS_SECRET_ACCESS_KEY";
+var ENV_SESSION = "AWS_SESSION_TOKEN";
+var ENV_EXPIRATION = "AWS_CREDENTIAL_EXPIRATION";
+var ENV_CREDENTIAL_SCOPE = "AWS_CREDENTIAL_SCOPE";
+var ENV_ACCOUNT_ID = "AWS_ACCOUNT_ID";
+var fromEnv = (init) => async () => {
+  init?.logger?.debug("@aws-sdk/credential-provider-env - fromEnv");
+  const accessKeyId = process.env[ENV_KEY];
+  const secretAccessKey = process.env[ENV_SECRET];
+  const sessionToken = process.env[ENV_SESSION];
+  const expiry = process.env[ENV_EXPIRATION];
+  const credentialScope = process.env[ENV_CREDENTIAL_SCOPE];
+  const accountId = process.env[ENV_ACCOUNT_ID];
+  if (accessKeyId && secretAccessKey) {
+    const credentials = {
+      accessKeyId,
+      secretAccessKey,
+      ...sessionToken && { sessionToken },
+      ...expiry && { expiration: new Date(expiry) },
+      ...credentialScope && { credentialScope },
+      ...accountId && { accountId }
+    };
+    import_client.setCredentialFeature(credentials, "CREDENTIALS_ENV_VARS", "g");
+    return credentials;
+  }
+  throw new CredentialsProviderError("Unable to find environment variable credentials.", { logger: init?.logger });
+};
+export {
+  fromEnv,
+  ENV_SESSION,
+  ENV_SECRET,
+  ENV_KEY,
+  ENV_EXPIRATION,
+  ENV_CREDENTIAL_SCOPE,
+  ENV_ACCOUNT_ID
+};
+export { ENV_KEY, ENV_SECRET, fromEnv };

package/dist/chunk-r1ednxa6.js

@@ -0,0 +1,311 @@
+// @bun
+import {
+  getProfileName,
+  getSSOTokenFilepath,
+  getSSOTokenFromFile,
+  loadSsoSessionData,
+  parseKnownFiles
+} from "./chunk-bf8bq8pc.js";
+import {
+  CredentialsProviderError,
+  TokenProviderError
+} from "./chunk-zzerxbrm.js";
+import {
+  require_client
+} from "./chunk-frw3va9v.js";
+import"./chunk-saqpg5nd.js";
+import {
+  __require,
+  __toESM
+} from "./chunk-9v6qtbez.js";
+
+// ../../../../node_modules/@aws-sdk/credential-provider-sso/dist-es/isSsoProfile.js
+var isSsoProfile = (arg) => arg && (typeof arg.sso_start_url === "string" || typeof arg.sso_account_id === "string" || typeof arg.sso_session === "string" || typeof arg.sso_region === "string" || typeof arg.sso_role_name === "string");
+
+// ../../../../node_modules/@aws-sdk/credential-provider-sso/dist-es/resolveSSOCredentials.js
+var import_client = __toESM(require_client(), 1);
+
+// ../../../../node_modules/@aws-sdk/token-providers/dist-es/constants.js
+var EXPIRE_WINDOW_MS = 5 * 60 * 1000;
+var REFRESH_MESSAGE = `To refresh this SSO session run 'aws sso login' with the corresponding profile.`;
+
+// ../../../../node_modules/@aws-sdk/token-providers/dist-es/getSsoOidcClient.js
+var getSsoOidcClient = async (ssoRegion, init = {}) => {
+  const { SSOOIDCClient } = await import("./chunk-f6a9g4qa.js");
+  const ssoOidcClient = new SSOOIDCClient(Object.assign({}, init.clientConfig ?? {}, {
+    region: ssoRegion ?? init.clientConfig?.region,
+    logger: init.clientConfig?.logger ?? init.parentClientConfig?.logger
+  }));
+  return ssoOidcClient;
+};
+
+// ../../../../node_modules/@aws-sdk/token-providers/dist-es/getNewSsoOidcToken.js
+var getNewSsoOidcToken = async (ssoToken, ssoRegion, init = {}) => {
+  const { CreateTokenCommand } = await import("./chunk-f6a9g4qa.js");
+  const ssoOidcClient = await getSsoOidcClient(ssoRegion, init);
+  return ssoOidcClient.send(new CreateTokenCommand({
+    clientId: ssoToken.clientId,
+    clientSecret: ssoToken.clientSecret,
+    refreshToken: ssoToken.refreshToken,
+    grantType: "refresh_token"
+  }));
+};
+
+// ../../../../node_modules/@aws-sdk/token-providers/dist-es/validateTokenExpiry.js
+var validateTokenExpiry = (token) => {
+  if (token.expiration && token.expiration.getTime() < Date.now()) {
+    throw new TokenProviderError(`Token is expired. ${REFRESH_MESSAGE}`, false);
+  }
+};
+
+// ../../../../node_modules/@aws-sdk/token-providers/dist-es/validateTokenKey.js
+var validateTokenKey = (key, value, forRefresh = false) => {
+  if (typeof value === "undefined") {
+    throw new TokenProviderError(`Value not present for '${key}' in SSO Token${forRefresh ? ". Cannot refresh" : ""}. ${REFRESH_MESSAGE}`, false);
+  }
+};
+
+// ../../../../node_modules/@aws-sdk/token-providers/dist-es/writeSSOTokenToFile.js
+import { promises as fsPromises } from "node:fs";
+var { writeFile } = fsPromises;
+var writeSSOTokenToFile = (id, ssoToken) => {
+  const tokenFilepath = getSSOTokenFilepath(id);
+  const tokenString = JSON.stringify(ssoToken, null, 2);
+  return writeFile(tokenFilepath, tokenString);
+};
+
+// ../../../../node_modules/@aws-sdk/token-providers/dist-es/fromSso.js
+var lastRefreshAttemptTime = new Date(0);
+var fromSso = (_init = {}) => async ({ callerClientConfig } = {}) => {
+  const init = {
+    ..._init,
+    parentClientConfig: {
+      ...callerClientConfig,
+      ..._init.parentClientConfig
+    }
+  };
+  init.logger?.debug("@aws-sdk/token-providers - fromSso");
+  const profiles = await parseKnownFiles(init);
+  const profileName = getProfileName({
+    profile: init.profile ?? callerClientConfig?.profile
+  });
+  const profile = profiles[profileName];
+  if (!profile) {
+    throw new TokenProviderError(`Profile '${profileName}' could not be found in shared credentials file.`, false);
+  } else if (!profile["sso_session"]) {
+    throw new TokenProviderError(`Profile '${profileName}' is missing required property 'sso_session'.`);
+  }
+  const ssoSessionName = profile["sso_session"];
+  const ssoSessions = await loadSsoSessionData(init);
+  const ssoSession = ssoSessions[ssoSessionName];
+  if (!ssoSession) {
+    throw new TokenProviderError(`Sso session '${ssoSessionName}' could not be found in shared credentials file.`, false);
+  }
+  for (const ssoSessionRequiredKey of ["sso_start_url", "sso_region"]) {
+    if (!ssoSession[ssoSessionRequiredKey]) {
+      throw new TokenProviderError(`Sso session '${ssoSessionName}' is missing required property '${ssoSessionRequiredKey}'.`, false);
+    }
+  }
+  const ssoStartUrl = ssoSession["sso_start_url"];
+  const ssoRegion = ssoSession["sso_region"];
+  let ssoToken;
+  try {
+    ssoToken = await getSSOTokenFromFile(ssoSessionName);
+  } catch (e) {
+    throw new TokenProviderError(`The SSO session token associated with profile=${profileName} was not found or is invalid. ${REFRESH_MESSAGE}`, false);
+  }
+  validateTokenKey("accessToken", ssoToken.accessToken);
+  validateTokenKey("expiresAt", ssoToken.expiresAt);
+  const { accessToken, expiresAt } = ssoToken;
+  const existingToken = { token: accessToken, expiration: new Date(expiresAt) };
+  if (existingToken.expiration.getTime() - Date.now() > EXPIRE_WINDOW_MS) {
+    return existingToken;
+  }
+  if (Date.now() - lastRefreshAttemptTime.getTime() < 30 * 1000) {
+    validateTokenExpiry(existingToken);
+    return existingToken;
+  }
+  validateTokenKey("clientId", ssoToken.clientId, true);
+  validateTokenKey("clientSecret", ssoToken.clientSecret, true);
+  validateTokenKey("refreshToken", ssoToken.refreshToken, true);
+  try {
+    lastRefreshAttemptTime.setTime(Date.now());
+    const newSsoOidcToken = await getNewSsoOidcToken(ssoToken, ssoRegion, init);
+    validateTokenKey("accessToken", newSsoOidcToken.accessToken);
+    validateTokenKey("expiresIn", newSsoOidcToken.expiresIn);
+    const newTokenExpiration = new Date(Date.now() + newSsoOidcToken.expiresIn * 1000);
+    try {
+      await writeSSOTokenToFile(ssoSessionName, {
+        ...ssoToken,
+        accessToken: newSsoOidcToken.accessToken,
+        expiresAt: newTokenExpiration.toISOString(),
+        refreshToken: newSsoOidcToken.refreshToken
+      });
+    } catch (error) {}
+    return {
+      token: newSsoOidcToken.accessToken,
+      expiration: newTokenExpiration
+    };
+  } catch (error) {
+    validateTokenExpiry(existingToken);
+    return existingToken;
+  }
+};
+
+// ../../../../node_modules/@aws-sdk/credential-provider-sso/dist-es/resolveSSOCredentials.js
+var SHOULD_FAIL_CREDENTIAL_CHAIN = false;
+var resolveSSOCredentials = async ({ ssoStartUrl, ssoSession, ssoAccountId, ssoRegion, ssoRoleName, ssoClient, clientConfig, parentClientConfig, profile, logger }) => {
+  let token;
+  const refreshMessage = `To refresh this SSO session run aws sso login with the corresponding profile.`;
+  if (ssoSession) {
+    try {
+      const _token = await fromSso({ profile })();
+      token = {
+        accessToken: _token.token,
+        expiresAt: new Date(_token.expiration).toISOString()
+      };
+    } catch (e) {
+      throw new CredentialsProviderError(e.message, {
+        tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
+        logger
+      });
+    }
+  } else {
+    try {
+      token = await getSSOTokenFromFile(ssoStartUrl);
+    } catch (e) {
+      throw new CredentialsProviderError(`The SSO session associated with this profile is invalid. ${refreshMessage}`, {
+        tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
+        logger
+      });
+    }
+  }
+  if (new Date(token.expiresAt).getTime() - Date.now() <= 0) {
+    throw new CredentialsProviderError(`The SSO session associated with this profile has expired. ${refreshMessage}`, {
+      tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
+      logger
+    });
+  }
+  const { accessToken } = token;
+  const { SSOClient, GetRoleCredentialsCommand } = await import("./chunk-csa76zyn.js");
+  const sso = ssoClient || new SSOClient(Object.assign({}, clientConfig ?? {}, {
+    logger: clientConfig?.logger ?? parentClientConfig?.logger,
+    region: clientConfig?.region ?? ssoRegion
+  }));
+  let ssoResp;
+  try {
+    ssoResp = await sso.send(new GetRoleCredentialsCommand({
+      accountId: ssoAccountId,
+      roleName: ssoRoleName,
+      accessToken
+    }));
+  } catch (e) {
+    throw new CredentialsProviderError(e, {
+      tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
+      logger
+    });
+  }
+  const { roleCredentials: { accessKeyId, secretAccessKey, sessionToken, expiration, credentialScope, accountId } = {} } = ssoResp;
+  if (!accessKeyId || !secretAccessKey || !sessionToken || !expiration) {
+    throw new CredentialsProviderError("SSO returns an invalid temporary credential.", {
+      tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
+      logger
+    });
+  }
+  const credentials = {
+    accessKeyId,
+    secretAccessKey,
+    sessionToken,
+    expiration: new Date(expiration),
+    ...credentialScope && { credentialScope },
+    ...accountId && { accountId }
+  };
+  if (ssoSession) {
+    import_client.setCredentialFeature(credentials, "CREDENTIALS_SSO", "s");
+  } else {
+    import_client.setCredentialFeature(credentials, "CREDENTIALS_SSO_LEGACY", "u");
+  }
+  return credentials;
+};
+
+// ../../../../node_modules/@aws-sdk/credential-provider-sso/dist-es/validateSsoProfile.js
+var validateSsoProfile = (profile, logger) => {
+  const { sso_start_url, sso_account_id, sso_region, sso_role_name } = profile;
+  if (!sso_start_url || !sso_account_id || !sso_region || !sso_role_name) {
+    throw new CredentialsProviderError(`Profile is configured with invalid SSO credentials. Required parameters "sso_account_id", ` + `"sso_region", "sso_role_name", "sso_start_url". Got ${Object.keys(profile).join(", ")}
+Reference: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html`, { tryNextLink: false, logger });
+  }
+  return profile;
+};
+
+// ../../../../node_modules/@aws-sdk/credential-provider-sso/dist-es/fromSSO.js
+var fromSSO = (init = {}) => async ({ callerClientConfig } = {}) => {
+  init.logger?.debug("@aws-sdk/credential-provider-sso - fromSSO");
+  const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init;
+  const { ssoClient } = init;
+  const profileName = getProfileName({
+    profile: init.profile ?? callerClientConfig?.profile
+  });
+  if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) {
+    const profiles = await parseKnownFiles(init);
+    const profile = profiles[profileName];
+    if (!profile) {
+      throw new CredentialsProviderError(`Profile ${profileName} was not found.`, { logger: init.logger });
+    }
+    if (!isSsoProfile(profile)) {
+      throw new CredentialsProviderError(`Profile ${profileName} is not configured with SSO credentials.`, {
+        logger: init.logger
+      });
+    }
+    if (profile?.sso_session) {
+      const ssoSessions = await loadSsoSessionData(init);
+      const session = ssoSessions[profile.sso_session];
+      const conflictMsg = ` configurations in profile ${profileName} and sso-session ${profile.sso_session}`;
+      if (ssoRegion && ssoRegion !== session.sso_region) {
+        throw new CredentialsProviderError(`Conflicting SSO region` + conflictMsg, {
+          tryNextLink: false,
+          logger: init.logger
+        });
+      }
+      if (ssoStartUrl && ssoStartUrl !== session.sso_start_url) {
+        throw new CredentialsProviderError(`Conflicting SSO start_url` + conflictMsg, {
+          tryNextLink: false,
+          logger: init.logger
+        });
+      }
+      profile.sso_region = session.sso_region;
+      profile.sso_start_url = session.sso_start_url;
+    }
+    const { sso_start_url, sso_account_id, sso_region, sso_role_name, sso_session } = validateSsoProfile(profile, init.logger);
+    return resolveSSOCredentials({
+      ssoStartUrl: sso_start_url,
+      ssoSession: sso_session,
+      ssoAccountId: sso_account_id,
+      ssoRegion: sso_region,
+      ssoRoleName: sso_role_name,
+      ssoClient,
+      clientConfig: init.clientConfig,
+      parentClientConfig: init.parentClientConfig,
+      profile: profileName
+    });
+  } else if (!ssoStartUrl || !ssoAccountId || !ssoRegion || !ssoRoleName) {
+    throw new CredentialsProviderError("Incomplete configuration. The fromSSO() argument hash must include " + '"ssoStartUrl", "ssoAccountId", "ssoRegion", "ssoRoleName"', { tryNextLink: false, logger: init.logger });
+  } else {
+    return resolveSSOCredentials({
+      ssoStartUrl,
+      ssoSession,
+      ssoAccountId,
+      ssoRegion,
+      ssoRoleName,
+      ssoClient,
+      clientConfig: init.clientConfig,
+      parentClientConfig: init.parentClientConfig,
+      profile: profileName
+    });
+  }
+};
+export {
+  validateSsoProfile,
+  isSsoProfile,
+  fromSSO
+};

package/dist/chunk-saqpg5nd.js

@@ -0,0 +1,118 @@
+import {
+  __commonJS
+} from "./chunk-9v6qtbez.js";
+
+// ../../../../node_modules/@smithy/types/dist-cjs/index.js
+var require_dist_cjs = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    AlgorithmId: () => AlgorithmId,
+    EndpointURLScheme: () => EndpointURLScheme,
+    FieldPosition: () => FieldPosition,
+    HttpApiKeyAuthLocation: () => HttpApiKeyAuthLocation,
+    HttpAuthLocation: () => HttpAuthLocation,
+    IniSectionType: () => IniSectionType,
+    RequestHandlerProtocol: () => RequestHandlerProtocol,
+    SMITHY_CONTEXT_KEY: () => SMITHY_CONTEXT_KEY,
+    getDefaultClientConfiguration: () => getDefaultClientConfiguration,
+    resolveDefaultRuntimeConfig: () => resolveDefaultRuntimeConfig
+  });
+  module.exports = __toCommonJS(src_exports);
+  var HttpAuthLocation = /* @__PURE__ */ ((HttpAuthLocation2) => {
+    HttpAuthLocation2["HEADER"] = "header";
+    HttpAuthLocation2["QUERY"] = "query";
+    return HttpAuthLocation2;
+  })(HttpAuthLocation || {});
+  var HttpApiKeyAuthLocation = /* @__PURE__ */ ((HttpApiKeyAuthLocation2) => {
+    HttpApiKeyAuthLocation2["HEADER"] = "header";
+    HttpApiKeyAuthLocation2["QUERY"] = "query";
+    return HttpApiKeyAuthLocation2;
+  })(HttpApiKeyAuthLocation || {});
+  var EndpointURLScheme = /* @__PURE__ */ ((EndpointURLScheme2) => {
+    EndpointURLScheme2["HTTP"] = "http";
+    EndpointURLScheme2["HTTPS"] = "https";
+    return EndpointURLScheme2;
+  })(EndpointURLScheme || {});
+  var AlgorithmId = /* @__PURE__ */ ((AlgorithmId2) => {
+    AlgorithmId2["MD5"] = "md5";
+    AlgorithmId2["CRC32"] = "crc32";
+    AlgorithmId2["CRC32C"] = "crc32c";
+    AlgorithmId2["SHA1"] = "sha1";
+    AlgorithmId2["SHA256"] = "sha256";
+    return AlgorithmId2;
+  })(AlgorithmId || {});
+  var getChecksumConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
+    const checksumAlgorithms = [];
+    if (runtimeConfig.sha256 !== undefined) {
+      checksumAlgorithms.push({
+        algorithmId: () => "sha256",
+        checksumConstructor: () => runtimeConfig.sha256
+      });
+    }
+    if (runtimeConfig.md5 != null) {
+      checksumAlgorithms.push({
+        algorithmId: () => "md5",
+        checksumConstructor: () => runtimeConfig.md5
+      });
+    }
+    return {
+      addChecksumAlgorithm(algo) {
+        checksumAlgorithms.push(algo);
+      },
+      checksumAlgorithms() {
+        return checksumAlgorithms;
+      }
+    };
+  }, "getChecksumConfiguration");
+  var resolveChecksumRuntimeConfig = /* @__PURE__ */ __name((clientConfig) => {
+    const runtimeConfig = {};
+    clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
+      runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor();
+    });
+    return runtimeConfig;
+  }, "resolveChecksumRuntimeConfig");
+  var getDefaultClientConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
+    return getChecksumConfiguration(runtimeConfig);
+  }, "getDefaultClientConfiguration");
+  var resolveDefaultRuntimeConfig = /* @__PURE__ */ __name((config) => {
+    return resolveChecksumRuntimeConfig(config);
+  }, "resolveDefaultRuntimeConfig");
+  var FieldPosition = /* @__PURE__ */ ((FieldPosition2) => {
+    FieldPosition2[FieldPosition2["HEADER"] = 0] = "HEADER";
+    FieldPosition2[FieldPosition2["TRAILER"] = 1] = "TRAILER";
+    return FieldPosition2;
+  })(FieldPosition || {});
+  var SMITHY_CONTEXT_KEY = "__smithy_context";
+  var IniSectionType = /* @__PURE__ */ ((IniSectionType2) => {
+    IniSectionType2["PROFILE"] = "profile";
+    IniSectionType2["SSO_SESSION"] = "sso-session";
+    IniSectionType2["SERVICES"] = "services";
+    return IniSectionType2;
+  })(IniSectionType || {});
+  var RequestHandlerProtocol = /* @__PURE__ */ ((RequestHandlerProtocol2) => {
+    RequestHandlerProtocol2["HTTP_0_9"] = "http/0.9";
+    RequestHandlerProtocol2["HTTP_1_0"] = "http/1.0";
+    RequestHandlerProtocol2["TDS_8_0"] = "tds/8.0";
+    return RequestHandlerProtocol2;
+  })(RequestHandlerProtocol || {});
+});
+
+export { require_dist_cjs };