@larkup/cli 0.2.24 → 0.2.26

package/dist/chunk-N6IF5QLH.js

@@ -0,0 +1,1850 @@
+import {
+  NoOpLogger,
+  customEndpointFunctions,
+  isIpAddress
+} from "./chunk-ODWAFTDP.js";
+import {
+  NODE_REGION_CONFIG_FILE_OPTIONS,
+  NODE_REGION_CONFIG_OPTIONS,
+  loadConfig
+} from "./chunk-HAABLEPO.js";
+import {
+  HttpRequest,
+  HttpResponse,
+  getSmithyContext,
+  hasOwn,
+  isValidHostLabel,
+  normalizeProvider,
+  parseRfc7231DateTime,
+  v4
+} from "./chunk-MACWQEJS.js";
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/setCredentialFeature.js
+function setCredentialFeature(credentials, feature, value) {
+  if (!credentials.$source) {
+    credentials.$source = {};
+  }
+  credentials.$source[feature] = value;
+  return credentials;
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/service-error-classification/constants.js
+var THROTTLING_ERROR_CODES = [
+  "BandwidthLimitExceeded",
+  "EC2ThrottledException",
+  "LimitExceededException",
+  "PriorRequestNotComplete",
+  "ProvisionedThroughputExceededException",
+  "RequestLimitExceeded",
+  "RequestThrottled",
+  "RequestThrottledException",
+  "SlowDown",
+  "ThrottledException",
+  "Throttling",
+  "ThrottlingException",
+  "TooManyRequestsException",
+  "TransactionInProgressException"
+];
+var TRANSIENT_ERROR_CODES = ["TimeoutError", "RequestTimeout", "RequestTimeoutException"];
+var TRANSIENT_ERROR_STATUS_CODES = [500, 502, 503, 504];
+var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT"];
+var NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND", "EAI_AGAIN"];
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/service-error-classification/service-error-classification.js
+var isRetryableByTrait = (error) => error?.$retryable !== void 0;
+var isClockSkewCorrectedError = (error) => error.$metadata?.clockSkewCorrected;
+var isBrowserNetworkError = (error) => {
+  const errorMessages = /* @__PURE__ */ new Set([
+    "Failed to fetch",
+    "NetworkError when attempting to fetch resource",
+    "The Internet connection appears to be offline",
+    "Load failed",
+    "Network request failed"
+  ]);
+  const isValid = error && error instanceof TypeError;
+  if (!isValid) {
+    return false;
+  }
+  return errorMessages.has(error.message);
+};
+var isThrottlingError = (error) => error.$metadata?.httpStatusCode === 429 || THROTTLING_ERROR_CODES.includes(error.name) || error.$retryable?.throttling == true;
+var isTransientError = (error, depth = 0) => isRetryableByTrait(error) || isClockSkewCorrectedError(error) || error.name === "InvalidSignatureException" && error.message?.includes("Signature expired") || TRANSIENT_ERROR_CODES.includes(error.name) || NODEJS_TIMEOUT_ERROR_CODES.includes(error?.code || "") || NODEJS_NETWORK_ERROR_CODES.includes(error?.code || "") || TRANSIENT_ERROR_STATUS_CODES.includes(error.$metadata?.httpStatusCode || 0) || isBrowserNetworkError(error) || isNodeJsHttp2TransientError(error) || error.cause !== void 0 && depth <= 10 && isTransientError(error.cause, depth + 1);
+var isServerError = (error) => {
+  if (error.$metadata?.httpStatusCode !== void 0) {
+    const statusCode = error.$metadata.httpStatusCode;
+    if (500 <= statusCode && statusCode <= 599 && !isTransientError(error)) {
+      return true;
+    }
+    return false;
+  }
+  return false;
+};
+function isNodeJsHttp2TransientError(error) {
+  return error.code === "ERR_HTTP2_STREAM_ERROR" && error.message.includes("NGHTTP2_REFUSED_STREAM");
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/util-retry/DefaultRateLimiter.js
+var DefaultRateLimiter = class _DefaultRateLimiter {
+  static setTimeoutFn = (fn, delay) => setTimeout(fn, delay);
+  beta;
+  minCapacity;
+  minFillRate;
+  scaleConstant;
+  smooth;
+  enabled = false;
+  availableTokens = 0;
+  lastMaxRate = 0;
+  measuredTxRate = 0;
+  requestCount = 0;
+  fillRate;
+  lastThrottleTime;
+  lastTimestamp = 0;
+  lastTxRateBucket;
+  maxCapacity;
+  timeWindow = 0;
+  constructor(options) {
+    this.beta = options?.beta ?? 0.7;
+    this.minCapacity = options?.minCapacity ?? 1;
+    this.minFillRate = options?.minFillRate ?? 0.5;
+    this.scaleConstant = options?.scaleConstant ?? 0.4;
+    this.smooth = options?.smooth ?? 0.8;
+    this.lastThrottleTime = this.getCurrentTimeInSeconds();
+    this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds());
+    this.fillRate = this.minFillRate;
+    this.maxCapacity = this.minCapacity;
+  }
+  async getSendToken() {
+    return this.acquireTokenBucket(1);
+  }
+  updateClientSendingRate(response) {
+    let calculatedRate;
+    this.updateMeasuredRate();
+    const retryErrorInfo = response;
+    const isThrottling = retryErrorInfo?.errorType === "THROTTLING" || isThrottlingError(retryErrorInfo?.error ?? response);
+    if (isThrottling) {
+      const rateToUse = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate);
+      this.lastMaxRate = rateToUse;
+      this.calculateTimeWindow();
+      this.lastThrottleTime = this.getCurrentTimeInSeconds();
+      calculatedRate = this.cubicThrottle(rateToUse);
+      this.enableTokenBucket();
+    } else {
+      this.calculateTimeWindow();
+      calculatedRate = this.cubicSuccess(this.getCurrentTimeInSeconds());
+    }
+    const newRate = Math.min(calculatedRate, 2 * this.measuredTxRate);
+    this.updateTokenBucketRate(newRate);
+  }
+  getCurrentTimeInSeconds() {
+    return Date.now() / 1e3;
+  }
+  async acquireTokenBucket(amount) {
+    if (!this.enabled) {
+      return;
+    }
+    this.refillTokenBucket();
+    while (amount > this.availableTokens) {
+      const delay = (amount - this.availableTokens) / this.fillRate * 1e3;
+      await new Promise((resolve) => _DefaultRateLimiter.setTimeoutFn(resolve, delay));
+      this.refillTokenBucket();
+    }
+    this.availableTokens = this.availableTokens - amount;
+  }
+  refillTokenBucket() {
+    const timestamp = this.getCurrentTimeInSeconds();
+    if (!this.lastTimestamp) {
+      this.lastTimestamp = timestamp;
+      return;
+    }
+    const fillAmount = (timestamp - this.lastTimestamp) * this.fillRate;
+    this.availableTokens = Math.min(this.maxCapacity, this.availableTokens + fillAmount);
+    this.lastTimestamp = timestamp;
+  }
+  calculateTimeWindow() {
+    this.timeWindow = this.getPrecise(Math.pow(this.lastMaxRate * (1 - this.beta) / this.scaleConstant, 1 / 3));
+  }
+  cubicThrottle(rateToUse) {
+    return this.getPrecise(rateToUse * this.beta);
+  }
+  cubicSuccess(timestamp) {
+    return this.getPrecise(this.scaleConstant * Math.pow(timestamp - this.lastThrottleTime - this.timeWindow, 3) + this.lastMaxRate);
+  }
+  enableTokenBucket() {
+    this.enabled = true;
+  }
+  updateTokenBucketRate(newRate) {
+    this.refillTokenBucket();
+    this.fillRate = Math.max(newRate, this.minFillRate);
+    this.maxCapacity = Math.max(newRate, this.minCapacity);
+    this.availableTokens = Math.min(this.availableTokens, this.maxCapacity);
+  }
+  updateMeasuredRate() {
+    const t = this.getCurrentTimeInSeconds();
+    const timeBucket = Math.floor(t * 2) / 2;
+    this.requestCount++;
+    if (timeBucket > this.lastTxRateBucket) {
+      const currentRate = this.requestCount / (timeBucket - this.lastTxRateBucket);
+      this.measuredTxRate = this.getPrecise(currentRate * this.smooth + this.measuredTxRate * (1 - this.smooth));
+      this.requestCount = 0;
+      this.lastTxRateBucket = timeBucket;
+    }
+  }
+  getPrecise(num) {
+    return parseFloat(num.toFixed(8));
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/util-retry/constants.js
+var MAXIMUM_RETRY_DELAY = 20 * 1e3;
+var INITIAL_RETRY_TOKENS = 500;
+var NO_RETRY_INCREMENT = 1;
+var INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
+var REQUEST_HEADER = "amz-sdk-request";
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/util-retry/retries-2026-config.js
+var Retry = class _Retry {
+  static v2026 = typeof process !== "undefined" && process.env?.SMITHY_NEW_RETRIES_2026 === "true";
+  static delay() {
+    return _Retry.v2026 ? 50 : 100;
+  }
+  static throttlingDelay() {
+    return _Retry.v2026 ? 1e3 : 500;
+  }
+  static cost() {
+    return _Retry.v2026 ? 14 : 5;
+  }
+  static throttlingCost() {
+    return _Retry.v2026 ? 5 : 10;
+  }
+  static modifiedCostType() {
+    return _Retry.v2026 ? "THROTTLING" : "TRANSIENT";
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/util-retry/DefaultRetryBackoffStrategy.js
+var DefaultRetryBackoffStrategy = class {
+  x = Retry.delay();
+  computeNextBackoffDelay(i) {
+    const b = Math.random();
+    const r = 2;
+    const t_i = b * Math.min(this.x * r ** i, MAXIMUM_RETRY_DELAY);
+    return Math.floor(t_i);
+  }
+  setDelayBase(delay) {
+    this.x = delay;
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/util-retry/DefaultRetryToken.js
+var DefaultRetryToken = class {
+  delay;
+  count;
+  cost;
+  longPoll;
+  $retryLog = {
+    acquisitionDelay: 0
+  };
+  constructor(delay, count, cost, longPoll) {
+    this.delay = delay;
+    this.count = count;
+    this.cost = cost;
+    this.longPoll = longPoll;
+  }
+  getRetryCount() {
+    return this.count;
+  }
+  getRetryDelay() {
+    return Math.min(MAXIMUM_RETRY_DELAY, this.delay);
+  }
+  getRetryCost() {
+    return this.cost;
+  }
+  isLongPoll() {
+    return this.longPoll;
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/util-retry/config.js
+var RETRY_MODES;
+(function(RETRY_MODES2) {
+  RETRY_MODES2["STANDARD"] = "standard";
+  RETRY_MODES2["ADAPTIVE"] = "adaptive";
+})(RETRY_MODES || (RETRY_MODES = {}));
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/util-retry/StandardRetryStrategy.js
+var refusal = {
+  incompatible: 1,
+  attempts: 2,
+  capacity: 3
+};
+var StandardRetryStrategy = class {
+  mode = RETRY_MODES.STANDARD;
+  retryBackoffStrategy;
+  capacity = INITIAL_RETRY_TOKENS;
+  maxAttemptsProvider;
+  baseDelay;
+  constructor(arg1) {
+    if (typeof arg1 === "number") {
+      this.maxAttemptsProvider = async () => arg1;
+    } else if (typeof arg1 === "function") {
+      this.maxAttemptsProvider = arg1;
+    } else if (arg1 && typeof arg1 === "object") {
+      this.maxAttemptsProvider = async () => arg1.maxAttempts;
+      this.baseDelay = arg1.baseDelay;
+      this.retryBackoffStrategy = arg1.backoff;
+    }
+    this.maxAttemptsProvider ??= async () => DEFAULT_MAX_ATTEMPTS;
+    this.baseDelay ??= Retry.delay();
+    this.retryBackoffStrategy ??= new DefaultRetryBackoffStrategy();
+  }
+  async acquireInitialRetryToken(retryTokenScope) {
+    return new DefaultRetryToken(Retry.delay(), 0, void 0, Retry.v2026 && retryTokenScope.includes(":longpoll"));
+  }
+  async refreshRetryTokenForRetry(token, errorInfo) {
+    const maxAttempts = await this.getMaxAttempts();
+    const retryCode = this.retryCode(token, errorInfo, maxAttempts);
+    const shouldRetry = retryCode === 0;
+    const isLongPoll = token.isLongPoll?.();
+    if (shouldRetry || isLongPoll) {
+      const errorType = errorInfo.errorType;
+      this.retryBackoffStrategy.setDelayBase(errorType === "THROTTLING" ? Retry.throttlingDelay() : this.baseDelay);
+      const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());
+      let retryDelay = delayFromErrorType;
+      if (errorInfo.retryAfterHint instanceof Date) {
+        retryDelay = Math.max(delayFromErrorType, Math.min(errorInfo.retryAfterHint.getTime() - Date.now(), delayFromErrorType + 5e3));
+      }
+      if (!shouldRetry) {
+        const longPollBackoff = Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0;
+        if (longPollBackoff > 0) {
+          await new Promise((r) => setTimeout(r, longPollBackoff));
+        }
+      } else {
+        const capacityCost = this.getCapacityCost(errorType);
+        this.capacity -= capacityCost;
+        const nextToken = new DefaultRetryToken(0, token.getRetryCount() + 1, capacityCost, token.isLongPoll?.() ?? false);
+        await new Promise((r) => setTimeout(r, retryDelay));
+        nextToken.$retryLog.acquisitionDelay = retryDelay;
+        return nextToken;
+      }
+    }
+    throw new Error("No retry token available");
+  }
+  recordSuccess(token) {
+    this.capacity = Math.min(INITIAL_RETRY_TOKENS, this.capacity + (token.getRetryCost() ?? NO_RETRY_INCREMENT));
+  }
+  getCapacity() {
+    return this.capacity;
+  }
+  async maxAttempts() {
+    return this.maxAttemptsProvider();
+  }
+  async getMaxAttempts() {
+    try {
+      return await this.maxAttemptsProvider();
+    } catch (ignored) {
+      console.warn(`Max attempts provider could not resolve. Using default of ${DEFAULT_MAX_ATTEMPTS}`);
+      return DEFAULT_MAX_ATTEMPTS;
+    }
+  }
+  retryCode(tokenToRenew, errorInfo, maxAttempts) {
+    const attempts = tokenToRenew.getRetryCount() + 1;
+    const retryableStatus = this.isRetryableError(errorInfo.errorType) ? 0 : refusal.incompatible;
+    const attemptStatus = attempts < maxAttempts ? 0 : refusal.attempts;
+    const capacityStatus = this.capacity >= this.getCapacityCost(errorInfo.errorType) ? 0 : refusal.capacity;
+    return retryableStatus || attemptStatus || capacityStatus;
+  }
+  getCapacityCost(errorType) {
+    return errorType === Retry.modifiedCostType() ? Retry.throttlingCost() : Retry.cost();
+  }
+  isRetryableError(errorType) {
+    return errorType === "THROTTLING" || errorType === "TRANSIENT";
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/util-retry/AdaptiveRetryStrategy.js
+var AdaptiveRetryStrategy = class {
+  mode = RETRY_MODES.ADAPTIVE;
+  rateLimiter;
+  standardRetryStrategy;
+  constructor(maxAttemptsProvider, options) {
+    const { rateLimiter } = options ?? {};
+    this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
+    this.standardRetryStrategy = options ? new StandardRetryStrategy({
+      maxAttempts: typeof maxAttemptsProvider === "number" ? maxAttemptsProvider : 3,
+      ...options
+    }) : new StandardRetryStrategy(maxAttemptsProvider);
+  }
+  async acquireInitialRetryToken(retryTokenScope) {
+    const token = await this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
+    await this.rateLimiter.getSendToken();
+    return token;
+  }
+  async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
+    this.rateLimiter.updateClientSendingRate(errorInfo);
+    const token = await this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
+    await this.rateLimiter.getSendToken();
+    return token;
+  }
+  recordSuccess(token) {
+    this.rateLimiter.updateClientSendingRate({});
+    this.standardRetryStrategy.recordSuccess(token);
+  }
+  async maxAttemptsProvider() {
+    return this.standardRetryStrategy.maxAttempts();
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/configurations.js
+var ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
+var CONFIG_MAX_ATTEMPTS = "max_attempts";
+var NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
+  environmentVariableSelector: (env2) => {
+    const value = env2[ENV_MAX_ATTEMPTS];
+    if (!value)
+      return void 0;
+    const maxAttempt = parseInt(value);
+    if (Number.isNaN(maxAttempt)) {
+      throw new Error(`Environment variable ${ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`);
+    }
+    return maxAttempt;
+  },
+  configFileSelector: (profile) => {
+    const value = profile[CONFIG_MAX_ATTEMPTS];
+    if (!value)
+      return void 0;
+    const maxAttempt = parseInt(value);
+    if (Number.isNaN(maxAttempt)) {
+      throw new Error(`Shared config file entry ${CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`);
+    }
+    return maxAttempt;
+  },
+  default: DEFAULT_MAX_ATTEMPTS
+};
+var resolveRetryConfig = (input, defaults) => {
+  const { retryStrategy, retryMode } = input;
+  const { defaultMaxAttempts = DEFAULT_MAX_ATTEMPTS, defaultBaseDelay = Retry.delay() } = defaults ?? {};
+  const maxAttemptsProvider = normalizeProvider(input.maxAttempts ?? defaultMaxAttempts);
+  let controller = retryStrategy ? Promise.resolve(retryStrategy) : void 0;
+  const getDefault = async () => {
+    const maxAttempts = await maxAttemptsProvider();
+    const adaptive = await normalizeProvider(retryMode)() === RETRY_MODES.ADAPTIVE;
+    if (adaptive) {
+      return new AdaptiveRetryStrategy(maxAttemptsProvider, {
+        maxAttempts,
+        baseDelay: defaultBaseDelay
+      });
+    }
+    return new StandardRetryStrategy({
+      maxAttempts,
+      baseDelay: defaultBaseDelay
+    });
+  };
+  return Object.assign(input, {
+    maxAttempts: maxAttemptsProvider,
+    retryStrategy: () => controller ??= getDefault()
+  });
+};
+var ENV_RETRY_MODE = "AWS_RETRY_MODE";
+var CONFIG_RETRY_MODE = "retry_mode";
+var NODE_RETRY_MODE_CONFIG_OPTIONS = {
+  environmentVariableSelector: (env2) => env2[ENV_RETRY_MODE],
+  configFileSelector: (profile) => profile[CONFIG_RETRY_MODE],
+  default: DEFAULT_RETRY_MODE
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/isStreamingPayload/isStreamingPayload.js
+import { Readable } from "stream";
+var isStreamingPayload = (request) => request?.body instanceof Readable || typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream;
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/parseRetryAfterHeader.js
+function parseRetryAfterHeader(response, logger) {
+  if (!HttpResponse.isInstance(response)) {
+    return;
+  }
+  for (const header in response.headers) {
+    if (!hasOwn(response.headers, header))
+      continue;
+    const h = header.toLowerCase();
+    if (h === "retry-after") {
+      const retryAfter = response.headers[header];
+      let retryAfterSeconds = NaN;
+      if (retryAfter.endsWith("GMT")) {
+        try {
+          const date = parseRfc7231DateTime(retryAfter);
+          retryAfterSeconds = (date.getTime() - Date.now()) / 1e3;
+        } catch (e) {
+          logger?.trace?.("Failed to parse retry-after header");
+          logger?.trace?.(e);
+        }
+      } else if (retryAfter.match(/ GMT, ((\d+)|(\d+\.\d+))$/)) {
+        retryAfterSeconds = Number(retryAfter.match(/ GMT, ([\d.]+)$/)?.[1]);
+      } else if (retryAfter.match(/^((\d+)|(\d+\.\d+))$/)) {
+        retryAfterSeconds = Number(retryAfter);
+      } else if (Date.parse(retryAfter) >= Date.now()) {
+        retryAfterSeconds = (Date.parse(retryAfter) - Date.now()) / 1e3;
+      }
+      if (isNaN(retryAfterSeconds)) {
+        return;
+      }
+      return new Date(Date.now() + retryAfterSeconds * 1e3);
+    } else if (h === "x-amz-retry-after") {
+      const v = response.headers[header];
+      const backoffMilliseconds = Number(v);
+      if (isNaN(backoffMilliseconds)) {
+        logger?.trace?.(`Failed to parse x-amz-retry-after=${v}`);
+        return;
+      }
+      return new Date(Date.now() + backoffMilliseconds);
+    }
+  }
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/util.js
+var asSdkError = (error) => {
+  if (error instanceof Error)
+    return error;
+  if (error instanceof Object)
+    return Object.assign(new Error(), error);
+  if (typeof error === "string")
+    return new Error(error);
+  return new Error(`AWS SDK error wrapper for ${error}`);
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/retryMiddleware.js
+function bindRetryMiddleware(isStreamingPayload2) {
+  return (options) => (next, context) => async (args) => {
+    let retryStrategy = await options.retryStrategy();
+    const maxAttempts = await options.maxAttempts();
+    if (isRetryStrategyV2(retryStrategy)) {
+      retryStrategy = retryStrategy;
+      let retryToken = await retryStrategy.acquireInitialRetryToken((context["partition_id"] ?? "") + (context.__retryLongPoll ? ":longpoll" : ""));
+      let lastError = new Error();
+      let attempts = 0;
+      let totalRetryDelay = 0;
+      const { request } = args;
+      const isRequest = HttpRequest.isInstance(request);
+      if (isRequest) {
+        request.headers[INVOCATION_ID_HEADER] = v4();
+      }
+      while (true) {
+        try {
+          if (isRequest) {
+            request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
+          }
+          const { response, output } = await next(args);
+          retryStrategy.recordSuccess(retryToken);
+          output.$metadata.attempts = attempts + 1;
+          output.$metadata.totalRetryDelay = totalRetryDelay;
+          return { response, output };
+        } catch (e) {
+          const retryErrorInfo = getRetryErrorInfo(e, options.logger);
+          lastError = asSdkError(e);
+          if (isRequest && isStreamingPayload2(request)) {
+            (context.logger instanceof NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request.");
+            throw lastError;
+          }
+          try {
+            retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
+          } catch (ignoredRefreshError) {
+            if (!lastError.$metadata) {
+              lastError.$metadata = {};
+            }
+            lastError.$metadata.attempts = attempts + 1;
+            lastError.$metadata.totalRetryDelay = totalRetryDelay;
+            throw lastError;
+          }
+          attempts = retryToken.getRetryCount();
+          const delay = retryToken.getRetryDelay();
+          totalRetryDelay += (retryToken?.$retryLog?.acquisitionDelay ?? 0) + delay;
+          if (delay > 0) {
+            await cooldown(delay);
+          }
+        }
+      }
+    } else {
+      retryStrategy = retryStrategy;
+      if (retryStrategy?.mode) {
+        context.userAgent = [...context.userAgent || [], ["cfg/retry-mode", retryStrategy.mode]];
+      }
+      return retryStrategy.retry(next, args);
+    }
+  };
+}
+var cooldown = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" && typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" && typeof retryStrategy.recordSuccess !== "undefined";
+var getRetryErrorInfo = (error, logger) => {
+  const errorInfo = {
+    error,
+    errorType: getRetryErrorType(error)
+  };
+  const retryAfterHint = parseRetryAfterHeader(error.$response, logger);
+  if (retryAfterHint) {
+    errorInfo.retryAfterHint = retryAfterHint;
+  }
+  return errorInfo;
+};
+var getRetryErrorType = (error) => {
+  if (isThrottlingError(error))
+    return "THROTTLING";
+  if (isTransientError(error))
+    return "TRANSIENT";
+  if (isServerError(error))
+    return "SERVER_ERROR";
+  return "CLIENT_ERROR";
+};
+var retryMiddlewareOptions = {
+  name: "retryMiddleware",
+  tags: ["RETRY"],
+  step: "finalizeRequest",
+  priority: "high",
+  override: true
+};
+function bindGetRetryPlugin(isStreamingPayload2) {
+  const retryMiddleware2 = bindRetryMiddleware(isStreamingPayload2);
+  return (options) => ({
+    applyToStack: (clientStack) => {
+      clientStack.add(retryMiddleware2(options), retryMiddlewareOptions);
+    }
+  });
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/retry/index.js
+var retryMiddleware = bindRetryMiddleware(isStreamingPayload);
+var getRetryPlugin = bindGetRetryPlugin(isStreamingPayload);
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-host-header/hostHeaderMiddleware.js
+function resolveHostHeaderConfig(input) {
+  return input;
+}
+var hostHeaderMiddleware = (options) => (next) => async (args) => {
+  if (!HttpRequest.isInstance(args.request))
+    return next(args);
+  const { request } = args;
+  const { handlerProtocol = "" } = options.requestHandler.metadata || {};
+  if (handlerProtocol.indexOf("h2") >= 0 && !request.headers[":authority"]) {
+    delete request.headers["host"];
+    request.headers[":authority"] = request.hostname + (request.port ? ":" + request.port : "");
+  } else if (!request.headers["host"]) {
+    let host = request.hostname;
+    if (request.port != null)
+      host += `:${request.port}`;
+    request.headers["host"] = host;
+  }
+  return next(args);
+};
+var hostHeaderMiddlewareOptions = {
+  name: "hostHeaderMiddleware",
+  step: "build",
+  priority: "low",
+  tags: ["HOST"],
+  override: true
+};
+var getHostHeaderPlugin = (options) => ({
+  applyToStack: (clientStack) => {
+    clientStack.add(hostHeaderMiddleware(options), hostHeaderMiddlewareOptions);
+  }
+});
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-logger/loggerMiddleware.js
+var loggerMiddleware = () => (next, context) => async (args) => {
+  try {
+    const response = await next(args);
+    const { clientName, commandName, logger, dynamoDbDocumentClientOptions = {} } = context;
+    const { overrideInputFilterSensitiveLog, overrideOutputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
+    const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
+    const outputFilterSensitiveLog = overrideOutputFilterSensitiveLog ?? context.outputFilterSensitiveLog;
+    const { $metadata, ...outputWithoutMetadata } = response.output;
+    logger?.info?.({
+      clientName,
+      commandName,
+      input: inputFilterSensitiveLog(args.input),
+      output: outputFilterSensitiveLog(outputWithoutMetadata),
+      metadata: $metadata
+    });
+    return response;
+  } catch (error) {
+    const { clientName, commandName, logger, dynamoDbDocumentClientOptions = {} } = context;
+    const { overrideInputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
+    const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
+    logger?.error?.({
+      clientName,
+      commandName,
+      input: inputFilterSensitiveLog(args.input),
+      error,
+      metadata: error.$metadata
+    });
+    throw error;
+  }
+};
+var loggerMiddlewareOptions = {
+  name: "loggerMiddleware",
+  tags: ["LOGGER"],
+  step: "initialize",
+  override: true
+};
+var getLoggerPlugin = (options) => ({
+  applyToStack: (clientStack) => {
+    clientStack.add(loggerMiddleware(), loggerMiddlewareOptions);
+  }
+});
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-recursion-detection/configuration.js
+var recursionDetectionMiddlewareOptions = {
+  step: "build",
+  tags: ["RECURSION_DETECTION", "TRACE_CONTEXT_PROPAGATION"],
+  name: "recursionDetectionMiddleware",
+  override: true,
+  priority: "low"
+};
+
+// ../../node_modules/.pnpm/@aws+lambda-invoke-store@0.3.0/node_modules/@aws/lambda-invoke-store/dist-es/invoke-store.js
+var PROTECTED_KEYS = {
+  REQUEST_ID: Symbol.for("_AWS_LAMBDA_REQUEST_ID"),
+  X_RAY_TRACE_ID: Symbol.for("_AWS_LAMBDA_X_RAY_TRACE_ID"),
+  TENANT_ID: Symbol.for("_AWS_LAMBDA_TENANT_ID"),
+  TRACEPARENT: Symbol.for("_AWS_LAMBDA_TRACEPARENT"),
+  TRACESTATE: Symbol.for("_AWS_LAMBDA_TRACESTATE"),
+  BAGGAGE: Symbol.for("_AWS_LAMBDA_BAGGAGE")
+};
+var NO_GLOBAL_AWS_LAMBDA = ["true", "1"].includes(process.env?.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA ?? "");
+if (!NO_GLOBAL_AWS_LAMBDA) {
+  globalThis.awslambda = globalThis.awslambda || {};
+}
+var InvokeStoreBase = class {
+  static PROTECTED_KEYS = PROTECTED_KEYS;
+  isProtectedKey(key) {
+    return Object.values(PROTECTED_KEYS).includes(key);
+  }
+  getRequestId() {
+    return this.get(PROTECTED_KEYS.REQUEST_ID) ?? "-";
+  }
+  getXRayTraceId() {
+    return this.get(PROTECTED_KEYS.X_RAY_TRACE_ID);
+  }
+  getTenantId() {
+    return this.get(PROTECTED_KEYS.TENANT_ID);
+  }
+  getTraceparent() {
+    return this.get(PROTECTED_KEYS.TRACEPARENT);
+  }
+  getTracestate() {
+    return this.get(PROTECTED_KEYS.TRACESTATE);
+  }
+  getBaggage() {
+    return this.get(PROTECTED_KEYS.BAGGAGE);
+  }
+};
+var InvokeStoreSingle = class extends InvokeStoreBase {
+  currentContext;
+  getContext() {
+    return this.currentContext;
+  }
+  hasContext() {
+    return this.currentContext !== void 0;
+  }
+  get(key) {
+    return this.currentContext?.[key];
+  }
+  set(key, value) {
+    if (this.isProtectedKey(key)) {
+      throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
+    }
+    this.currentContext = this.currentContext || {};
+    this.currentContext[key] = value;
+  }
+  run(context, fn) {
+    this.currentContext = context;
+    return fn();
+  }
+};
+var InvokeStoreMulti = class _InvokeStoreMulti extends InvokeStoreBase {
+  als;
+  static async create() {
+    const instance = new _InvokeStoreMulti();
+    const asyncHooks = await import("async_hooks");
+    instance.als = new asyncHooks.AsyncLocalStorage();
+    return instance;
+  }
+  getContext() {
+    return this.als.getStore();
+  }
+  hasContext() {
+    return this.als.getStore() !== void 0;
+  }
+  get(key) {
+    return this.als.getStore()?.[key];
+  }
+  set(key, value) {
+    if (this.isProtectedKey(key)) {
+      throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
+    }
+    const store = this.als.getStore();
+    if (!store) {
+      throw new Error("No context available");
+    }
+    store[key] = value;
+  }
+  run(context, fn) {
+    return this.als.run(context, fn);
+  }
+};
+var InvokeStore;
+(function(InvokeStore2) {
+  let instance = null;
+  async function getInstanceAsync(forceInvokeStoreMulti) {
+    if (!instance) {
+      instance = (async () => {
+        const isMulti = forceInvokeStoreMulti === true || "AWS_LAMBDA_MAX_CONCURRENCY" in process.env;
+        const newInstance = isMulti ? await InvokeStoreMulti.create() : new InvokeStoreSingle();
+        if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda?.InvokeStore) {
+          return globalThis.awslambda.InvokeStore;
+        } else if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda) {
+          globalThis.awslambda.InvokeStore = newInstance;
+          return newInstance;
+        } else {
+          return newInstance;
+        }
+      })();
+    }
+    return instance;
+  }
+  InvokeStore2.getInstanceAsync = getInstanceAsync;
+  InvokeStore2._testing = process.env.AWS_LAMBDA_BENCHMARK_MODE === "1" ? {
+    reset: () => {
+      instance = null;
+      if (globalThis.awslambda?.InvokeStore) {
+        delete globalThis.awslambda.InvokeStore;
+      }
+      globalThis.awslambda = { InvokeStore: void 0 };
+    }
+  } : void 0;
+})(InvokeStore || (InvokeStore = {}));
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-recursion-detection/recursionDetectionMiddleware.js
+var AWS_LAMBDA_FUNCTION_NAME = "AWS_LAMBDA_FUNCTION_NAME";
+var _X_AMZN_TRACE_ID = "_X_AMZN_TRACE_ID";
+var X_AMZN_TRACE_ID = "X-Amzn-Trace-Id";
+var TRACEPARENT = "traceparent";
+var TRACESTATE = "tracestate";
+var BAGGAGE = "baggage";
+var recursionDetectionMiddleware = () => (next) => async (args) => {
+  const { request } = args;
+  if (!HttpRequest.isInstance(request)) {
+    return next(args);
+  }
+  let invokeStore;
+  {
+    const traceIdHeader = Object.keys(request.headers ?? {}).find((h) => h.toLowerCase() === X_AMZN_TRACE_ID.toLowerCase()) ?? X_AMZN_TRACE_ID;
+    if (!request.headers.hasOwnProperty(traceIdHeader)) {
+      const functionName = process.env[AWS_LAMBDA_FUNCTION_NAME];
+      const traceIdFromEnv = process.env[_X_AMZN_TRACE_ID];
+      invokeStore ??= await InvokeStore.getInstanceAsync();
+      const traceIdFromInvokeStore = invokeStore?.getXRayTraceId();
+      const traceId = traceIdFromInvokeStore ?? traceIdFromEnv;
+      const nonEmptyString = (str) => typeof str === "string" && str.length > 0;
+      if (nonEmptyString(functionName) && nonEmptyString(traceId)) {
+        request.headers[X_AMZN_TRACE_ID] = traceId;
+      }
+    }
+  }
+  {
+    sanitizeTraceHeaders(request.headers);
+    const existingTraceparent = request.headers[TRACEPARENT];
+    if (!existingTraceparent) {
+      const traceparent = (invokeStore ??= await InvokeStore.getInstanceAsync())?.getTraceparent?.();
+      if (traceparent) {
+        request.headers[TRACEPARENT] = traceparent;
+        const tracestate = invokeStore?.getTracestate?.();
+        if (tracestate) {
+          request.headers[TRACESTATE] = tracestate;
+        }
+        const baggage = invokeStore?.getBaggage?.();
+        if (baggage) {
+          request.headers[BAGGAGE] = baggage;
+        }
+      }
+    }
+  }
+  return next(args);
+};
+function sanitizeTraceHeaders(headers) {
+  for (const header of Object.keys(headers)) {
+    const lower = header.toLowerCase();
+    if (header !== lower && (lower === TRACEPARENT || lower === TRACESTATE || lower === BAGGAGE)) {
+      headers[lower] = headers[header];
+      delete headers[header];
+    }
+  }
+}
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-recursion-detection/getRecursionDetectionPlugin.js
+var getRecursionDetectionPlugin = (options) => ({
+  applyToStack: (clientStack) => {
+    clientStack.add(recursionDetectionMiddleware(), recursionDetectionMiddlewareOptions);
+  }
+});
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/legacy-root-exports/middleware-http-auth-scheme/resolveAuthOptions.js
+var resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => {
+  if (!authSchemePreference || authSchemePreference.length === 0) {
+    return candidateAuthOptions;
+  }
+  const preferredAuthOptions = [];
+  for (const preferredSchemeName of authSchemePreference) {
+    for (const candidateAuthOption of candidateAuthOptions) {
+      const candidateAuthSchemeName = candidateAuthOption.schemeId.split("#")[1];
+      if (candidateAuthSchemeName === preferredSchemeName) {
+        preferredAuthOptions.push(candidateAuthOption);
+      }
+    }
+  }
+  for (const candidateAuthOption of candidateAuthOptions) {
+    if (!preferredAuthOptions.find(({ schemeId }) => schemeId === candidateAuthOption.schemeId)) {
+      preferredAuthOptions.push(candidateAuthOption);
+    }
+  }
+  return preferredAuthOptions;
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/legacy-root-exports/middleware-http-auth-scheme/httpAuthSchemeMiddleware.js
+function convertHttpAuthSchemesToMap(httpAuthSchemes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const scheme of httpAuthSchemes) {
+    map.set(scheme.schemeId, scheme);
+  }
+  return map;
+}
+var httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async (args) => {
+  const options = config.httpAuthSchemeProvider(await mwOptions.httpAuthSchemeParametersProvider(config, context, args.input));
+  const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : [];
+  const resolvedOptions = resolveAuthOptions(options, authSchemePreference);
+  const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes);
+  const smithyContext = getSmithyContext(context);
+  const failureReasons = [];
+  for (const option of resolvedOptions) {
+    const scheme = authSchemes.get(option.schemeId);
+    if (!scheme) {
+      failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` was not enabled for this service.`);
+      continue;
+    }
+    const identityProvider = scheme.identityProvider(await mwOptions.identityProviderConfigProvider(config));
+    if (!identityProvider) {
+      failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` did not have an IdentityProvider configured.`);
+      continue;
+    }
+    const { identityProperties = {}, signingProperties = {} } = option.propertiesExtractor?.(config, context) || {};
+    option.identityProperties = Object.assign(option.identityProperties || {}, identityProperties);
+    option.signingProperties = Object.assign(option.signingProperties || {}, signingProperties);
+    smithyContext.selectedHttpAuthScheme = {
+      httpAuthOption: option,
+      identity: await identityProvider(option.identityProperties),
+      signer: scheme.signer
+    };
+    break;
+  }
+  if (!smithyContext.selectedHttpAuthScheme) {
+    throw new Error(failureReasons.join("\n"));
+  }
+  return next(args);
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/legacy-root-exports/middleware-http-auth-scheme/getHttpAuthSchemeEndpointRuleSetPlugin.js
+var httpAuthSchemeEndpointRuleSetMiddlewareOptions = {
+  step: "serialize",
+  tags: ["HTTP_AUTH_SCHEME"],
+  name: "httpAuthSchemeMiddleware",
+  override: true,
+  relation: "before",
+  toMiddleware: "endpointV2Middleware"
+};
+var getHttpAuthSchemeEndpointRuleSetPlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider }) => ({
+  applyToStack: (clientStack) => {
+    clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, {
+      httpAuthSchemeParametersProvider,
+      identityProviderConfigProvider
+    }), httpAuthSchemeEndpointRuleSetMiddlewareOptions);
+  }
+});
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/legacy-root-exports/middleware-http-signing/httpSigningMiddleware.js
+var defaultErrorHandler = (signingProperties) => (error) => {
+  throw error;
+};
+var defaultSuccessHandler = (httpResponse, signingProperties) => {
+};
+var httpSigningMiddleware = (config) => (next, context) => async (args) => {
+  if (!HttpRequest.isInstance(args.request)) {
+    return next(args);
+  }
+  const smithyContext = getSmithyContext(context);
+  const scheme = smithyContext.selectedHttpAuthScheme;
+  if (!scheme) {
+    throw new Error(`No HttpAuthScheme was selected: unable to sign request`);
+  }
+  const { httpAuthOption: { signingProperties = {} }, identity, signer } = scheme;
+  const output = await next({
+    ...args,
+    request: await signer.sign(args.request, identity, signingProperties)
+  }).catch((signer.errorHandler || defaultErrorHandler)(signingProperties));
+  (signer.successHandler || defaultSuccessHandler)(output.response, signingProperties);
+  return output;
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/legacy-root-exports/middleware-http-signing/getHttpSigningMiddleware.js
+var httpSigningMiddlewareOptions = {
+  step: "finalizeRequest",
+  tags: ["HTTP_SIGNING"],
+  name: "httpSigningMiddleware",
+  aliases: ["apiKeyMiddleware", "tokenMiddleware", "awsAuthMiddleware"],
+  override: true,
+  relation: "after",
+  toMiddleware: "retryMiddleware"
+};
+var getHttpSigningPlugin = (config) => ({
+  applyToStack: (clientStack) => {
+    clientStack.addRelativeTo(httpSigningMiddleware(config), httpSigningMiddlewareOptions);
+  }
+});
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/legacy-root-exports/pagination/createPaginator.js
+var makePagedClientRequest = async (CommandCtor, client, input, withCommand = (_) => _, ...args) => {
+  let command = new CommandCtor(input);
+  command = withCommand(command) ?? command;
+  return await client.send(command, ...args);
+};
+function createPaginator(ClientCtor, CommandCtor, inputTokenName, outputTokenName, pageSizeTokenName) {
+  return async function* paginateOperation(config, input, ...additionalArguments) {
+    const _input = input;
+    let token = config.startingToken ?? _input[inputTokenName];
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+      _input[inputTokenName] = token;
+      if (pageSizeTokenName) {
+        _input[pageSizeTokenName] = _input[pageSizeTokenName] ?? config.pageSize;
+      }
+      if (config.client instanceof ClientCtor) {
+        page = await makePagedClientRequest(CommandCtor, config.client, input, config.withCommand, ...additionalArguments);
+      } else {
+        throw new Error(`Invalid client, expected instance of ${ClientCtor.name}`);
+      }
+      yield page;
+      const prevToken = token;
+      token = get(page, outputTokenName);
+      hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return void 0;
+  };
+}
+var get = (fromObject, path) => {
+  let cursor = fromObject;
+  const pathComponents = path.split(".");
+  for (const step of pathComponents) {
+    if (!cursor || typeof cursor !== "object") {
+      return void 0;
+    }
+    cursor = cursor[step];
+  }
+  return cursor;
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/legacy-root-exports/util-identity-and-auth/DefaultIdentityProviderConfig.js
+var DefaultIdentityProviderConfig = class {
+  authSchemes = /* @__PURE__ */ new Map();
+  constructor(config) {
+    for (const key in config) {
+      if (!hasOwn(config, key))
+        continue;
+      const value = config[key];
+      if (value !== void 0) {
+        this.authSchemes.set(key, value);
+      }
+    }
+  }
+  getIdentityProvider(schemeId) {
+    return this.authSchemes.get(schemeId);
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/legacy-root-exports/util-identity-and-auth/httpAuthSchemes/noAuth.js
+var NoAuthSigner = class {
+  async sign(httpRequest, identity, signingProperties) {
+    return httpRequest;
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/legacy-root-exports/util-identity-and-auth/memoizeIdentityProvider.js
+var createIsIdentityExpiredFunction = (expirationMs) => function isIdentityExpired2(identity) {
+  return doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
+};
+var EXPIRATION_MS = 3e5;
+var isIdentityExpired = createIsIdentityExpiredFunction(EXPIRATION_MS);
+var doesIdentityRequireRefresh = (identity) => identity.expiration !== void 0;
+var memoizeIdentityProvider = (provider, isExpired, requiresRefresh) => {
+  if (provider === void 0) {
+    return void 0;
+  }
+  const normalizedProvider = typeof provider !== "function" ? async () => Promise.resolve(provider) : provider;
+  let resolved;
+  let pending;
+  let hasResult;
+  let isConstant = false;
+  const coalesceProvider = async (options) => {
+    if (!pending) {
+      pending = normalizedProvider(options);
+    }
+    try {
+      resolved = await pending;
+      hasResult = true;
+      isConstant = false;
+    } finally {
+      pending = void 0;
+    }
+    return resolved;
+  };
+  if (isExpired === void 0) {
+    return async (options) => {
+      if (!hasResult || options?.forceRefresh) {
+        resolved = await coalesceProvider(options);
+      }
+      return resolved;
+    };
+  }
+  return async (options) => {
+    if (!hasResult || options?.forceRefresh) {
+      resolved = await coalesceProvider(options);
+    }
+    if (isConstant) {
+      return resolved;
+    }
+    if (!requiresRefresh(resolved)) {
+      isConstant = true;
+      return resolved;
+    }
+    if (isExpired(resolved)) {
+      await coalesceProvider(options);
+      return resolved;
+    }
+    return resolved;
+  };
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/normalizeProvider.js
+var normalizeProvider2 = (input) => {
+  if (typeof input === "function")
+    return input;
+  const promisified = Promise.resolve(input);
+  return () => promisified;
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-user-agent/configurations.js
+var DEFAULT_UA_APP_ID = void 0;
+function isValidUserAgentAppId(appId) {
+  if (appId === void 0) {
+    return true;
+  }
+  return typeof appId === "string" && appId.length <= 50;
+}
+function resolveUserAgentConfig(input) {
+  const normalizedAppIdProvider = normalizeProvider2(input.userAgentAppId ?? DEFAULT_UA_APP_ID);
+  const { customUserAgent } = input;
+  return Object.assign(input, {
+    customUserAgent: typeof customUserAgent === "string" ? [[customUserAgent]] : customUserAgent,
+    userAgentAppId: async () => {
+      const appId = await normalizedAppIdProvider();
+      if (!isValidUserAgentAppId(appId)) {
+        const logger = input.logger?.constructor?.name === "NoOpLogger" || !input.logger ? console : input.logger;
+        if (typeof appId !== "string") {
+          logger?.warn("userAgentAppId must be a string or undefined.");
+        } else if (appId.length > 50) {
+          logger?.warn("The provided userAgentAppId exceeds the maximum length of 50 characters.");
+        }
+      }
+      return appId;
+    }
+  });
+}
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/util-endpoints/lib/aws/partitions.js
+var partitionsInfo = {
+  "partitions": [
+    {
+      "id": "aws",
+      "outputs": {
+        "dnsSuffix": "amazonaws.com",
+        "dualStackDnsSuffix": "api.aws",
+        "implicitGlobalRegion": "us-east-1",
+        "name": "aws",
+        "supportsDualStack": true,
+        "supportsFIPS": true
+      },
+      "regionRegex": "^(us|eu|ap|sa|ca|me|af|il|mx)\\-\\w+\\-\\d+$",
+      "regions": {
+        "af-south-1": {
+          "description": "Africa (Cape Town)"
+        },
+        "ap-east-1": {
+          "description": "Asia Pacific (Hong Kong)"
+        },
+        "ap-east-2": {
+          "description": "Asia Pacific (Taipei)"
+        },
+        "ap-northeast-1": {
+          "description": "Asia Pacific (Tokyo)"
+        },
+        "ap-northeast-2": {
+          "description": "Asia Pacific (Seoul)"
+        },
+        "ap-northeast-3": {
+          "description": "Asia Pacific (Osaka)"
+        },
+        "ap-south-1": {
+          "description": "Asia Pacific (Mumbai)"
+        },
+        "ap-south-2": {
+          "description": "Asia Pacific (Hyderabad)"
+        },
+        "ap-southeast-1": {
+          "description": "Asia Pacific (Singapore)"
+        },
+        "ap-southeast-2": {
+          "description": "Asia Pacific (Sydney)"
+        },
+        "ap-southeast-3": {
+          "description": "Asia Pacific (Jakarta)"
+        },
+        "ap-southeast-4": {
+          "description": "Asia Pacific (Melbourne)"
+        },
+        "ap-southeast-5": {
+          "description": "Asia Pacific (Malaysia)"
+        },
+        "ap-southeast-6": {
+          "description": "Asia Pacific (New Zealand)"
+        },
+        "ap-southeast-7": {
+          "description": "Asia Pacific (Thailand)"
+        },
+        "aws-global": {
+          "description": "aws global region"
+        },
+        "ca-central-1": {
+          "description": "Canada (Central)"
+        },
+        "ca-west-1": {
+          "description": "Canada West (Calgary)"
+        },
+        "eu-central-1": {
+          "description": "Europe (Frankfurt)"
+        },
+        "eu-central-2": {
+          "description": "Europe (Zurich)"
+        },
+        "eu-north-1": {
+          "description": "Europe (Stockholm)"
+        },
+        "eu-south-1": {
+          "description": "Europe (Milan)"
+        },
+        "eu-south-2": {
+          "description": "Europe (Spain)"
+        },
+        "eu-west-1": {
+          "description": "Europe (Ireland)"
+        },
+        "eu-west-2": {
+          "description": "Europe (London)"
+        },
+        "eu-west-3": {
+          "description": "Europe (Paris)"
+        },
+        "il-central-1": {
+          "description": "Israel (Tel Aviv)"
+        },
+        "me-central-1": {
+          "description": "Middle East (UAE)"
+        },
+        "me-south-1": {
+          "description": "Middle East (Bahrain)"
+        },
+        "mx-central-1": {
+          "description": "Mexico (Central)"
+        },
+        "sa-east-1": {
+          "description": "South America (Sao Paulo)"
+        },
+        "us-east-1": {
+          "description": "US East (N. Virginia)"
+        },
+        "us-east-2": {
+          "description": "US East (Ohio)"
+        },
+        "us-west-1": {
+          "description": "US West (N. California)"
+        },
+        "us-west-2": {
+          "description": "US West (Oregon)"
+        }
+      }
+    },
+    {
+      "id": "aws-cn",
+      "outputs": {
+        "dnsSuffix": "amazonaws.com.cn",
+        "dualStackDnsSuffix": "api.amazonwebservices.com.cn",
+        "implicitGlobalRegion": "cn-northwest-1",
+        "name": "aws-cn",
+        "supportsDualStack": true,
+        "supportsFIPS": true
+      },
+      "regionRegex": "^cn\\-\\w+\\-\\d+$",
+      "regions": {
+        "aws-cn-global": {
+          "description": "aws-cn global region"
+        },
+        "cn-north-1": {
+          "description": "China (Beijing)"
+        },
+        "cn-northwest-1": {
+          "description": "China (Ningxia)"
+        }
+      }
+    },
+    {
+      "id": "aws-eusc",
+      "outputs": {
+        "dnsSuffix": "amazonaws.eu",
+        "dualStackDnsSuffix": "api.amazonwebservices.eu",
+        "implicitGlobalRegion": "eusc-de-east-1",
+        "name": "aws-eusc",
+        "supportsDualStack": true,
+        "supportsFIPS": true
+      },
+      "regionRegex": "^eusc\\-(de)\\-\\w+\\-\\d+$",
+      "regions": {
+        "eusc-de-east-1": {
+          "description": "AWS European Sovereign Cloud (Germany)"
+        }
+      }
+    },
+    {
+      "id": "aws-iso",
+      "outputs": {
+        "dnsSuffix": "c2s.ic.gov",
+        "dualStackDnsSuffix": "api.aws.ic.gov",
+        "implicitGlobalRegion": "us-iso-east-1",
+        "name": "aws-iso",
+        "supportsDualStack": true,
+        "supportsFIPS": true
+      },
+      "regionRegex": "^us\\-iso\\-\\w+\\-\\d+$",
+      "regions": {
+        "aws-iso-global": {
+          "description": "aws-iso global region"
+        },
+        "us-iso-east-1": {
+          "description": "US ISO East"
+        },
+        "us-iso-west-1": {
+          "description": "US ISO WEST"
+        }
+      }
+    },
+    {
+      "id": "aws-iso-b",
+      "outputs": {
+        "dnsSuffix": "sc2s.sgov.gov",
+        "dualStackDnsSuffix": "api.aws.scloud",
+        "implicitGlobalRegion": "us-isob-east-1",
+        "name": "aws-iso-b",
+        "supportsDualStack": true,
+        "supportsFIPS": true
+      },
+      "regionRegex": "^us\\-isob\\-\\w+\\-\\d+$",
+      "regions": {
+        "aws-iso-b-global": {
+          "description": "aws-iso-b global region"
+        },
+        "us-isob-east-1": {
+          "description": "US ISOB East (Ohio)"
+        },
+        "us-isob-west-1": {
+          "description": "US ISOB West"
+        }
+      }
+    },
+    {
+      "id": "aws-iso-e",
+      "outputs": {
+        "dnsSuffix": "cloud.adc-e.uk",
+        "dualStackDnsSuffix": "api.cloud-aws.adc-e.uk",
+        "implicitGlobalRegion": "eu-isoe-west-1",
+        "name": "aws-iso-e",
+        "supportsDualStack": true,
+        "supportsFIPS": true
+      },
+      "regionRegex": "^eu\\-isoe\\-\\w+\\-\\d+$",
+      "regions": {
+        "aws-iso-e-global": {
+          "description": "aws-iso-e global region"
+        },
+        "eu-isoe-west-1": {
+          "description": "EU ISOE West"
+        }
+      }
+    },
+    {
+      "id": "aws-iso-f",
+      "outputs": {
+        "dnsSuffix": "csp.hci.ic.gov",
+        "dualStackDnsSuffix": "api.aws.hci.ic.gov",
+        "implicitGlobalRegion": "us-isof-south-1",
+        "name": "aws-iso-f",
+        "supportsDualStack": true,
+        "supportsFIPS": true
+      },
+      "regionRegex": "^us\\-isof\\-\\w+\\-\\d+$",
+      "regions": {
+        "aws-iso-f-global": {
+          "description": "aws-iso-f global region"
+        },
+        "us-isof-east-1": {
+          "description": "US ISOF EAST"
+        },
+        "us-isof-south-1": {
+          "description": "US ISOF SOUTH"
+        }
+      }
+    },
+    {
+      "id": "aws-us-gov",
+      "outputs": {
+        "dnsSuffix": "amazonaws.com",
+        "dualStackDnsSuffix": "api.aws",
+        "implicitGlobalRegion": "us-gov-west-1",
+        "name": "aws-us-gov",
+        "supportsDualStack": true,
+        "supportsFIPS": true
+      },
+      "regionRegex": "^us\\-gov\\-\\w+\\-\\d+$",
+      "regions": {
+        "aws-us-gov-global": {
+          "description": "aws-us-gov global region"
+        },
+        "us-gov-east-1": {
+          "description": "AWS GovCloud (US-East)"
+        },
+        "us-gov-west-1": {
+          "description": "AWS GovCloud (US-West)"
+        }
+      }
+    }
+  ],
+  "version": "1.1"
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/util-endpoints/lib/aws/partition.js
+var selectedPartitionsInfo = partitionsInfo;
+var selectedUserAgentPrefix = "";
+var partition = (value) => {
+  const { partitions } = selectedPartitionsInfo;
+  for (const partition2 of partitions) {
+    const { regions, outputs } = partition2;
+    for (const [region, regionData] of Object.entries(regions)) {
+      if (region === value) {
+        return {
+          ...outputs,
+          ...regionData
+        };
+      }
+    }
+  }
+  for (const partition2 of partitions) {
+    const { regionRegex, outputs } = partition2;
+    if (new RegExp(regionRegex).test(value)) {
+      return {
+        ...outputs
+      };
+    }
+  }
+  const DEFAULT_PARTITION = partitions.find((partition2) => partition2.id === "aws");
+  if (!DEFAULT_PARTITION) {
+    throw new Error("Provided region was not found in the partition array or regex, and default partition with id 'aws' doesn't exist.");
+  }
+  return {
+    ...DEFAULT_PARTITION.outputs
+  };
+};
+var getUserAgentPrefix = () => selectedUserAgentPrefix;
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/setFeature.js
+Retry.v2026 ||= typeof process === "object" && process.env?.AWS_NEW_RETRIES_2026 === "true";
+function setFeature(context, feature, value) {
+  if (!context.__aws_sdk_context) {
+    context.__aws_sdk_context = {
+      features: {}
+    };
+  } else if (!context.__aws_sdk_context.features) {
+    context.__aws_sdk_context.features = {};
+  }
+  context.__aws_sdk_context.features[feature] = value;
+}
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-user-agent/check-features.js
+var ACCOUNT_ID_ENDPOINT_REGEX = /\d{12}\.ddb/;
+async function checkFeatures(context, config, args) {
+  const request = args.request;
+  if (request?.headers?.["smithy-protocol"] === "rpc-v2-cbor") {
+    setFeature(context, "PROTOCOL_RPC_V2_CBOR", "M");
+  }
+  if (typeof config.retryStrategy === "function") {
+    const retryStrategy = await config.retryStrategy();
+    if (typeof retryStrategy.mode === "string") {
+      switch (retryStrategy.mode) {
+        case RETRY_MODES.ADAPTIVE:
+          setFeature(context, "RETRY_MODE_ADAPTIVE", "F");
+          break;
+        case RETRY_MODES.STANDARD:
+          setFeature(context, "RETRY_MODE_STANDARD", "E");
+          break;
+      }
+    }
+  }
+  if (typeof config.accountIdEndpointMode === "function") {
+    const endpointV2 = context.endpointV2;
+    if (String(endpointV2?.url?.hostname).match(ACCOUNT_ID_ENDPOINT_REGEX)) {
+      setFeature(context, "ACCOUNT_ID_ENDPOINT", "O");
+    }
+    switch (await config.accountIdEndpointMode?.()) {
+      case "disabled":
+        setFeature(context, "ACCOUNT_ID_MODE_DISABLED", "Q");
+        break;
+      case "preferred":
+        setFeature(context, "ACCOUNT_ID_MODE_PREFERRED", "P");
+        break;
+      case "required":
+        setFeature(context, "ACCOUNT_ID_MODE_REQUIRED", "R");
+        break;
+    }
+  }
+  const identity = context.__smithy_context?.selectedHttpAuthScheme?.identity;
+  if (identity?.$source) {
+    const credentials = identity;
+    if (credentials.accountId) {
+      setFeature(context, "RESOLVED_ACCOUNT_ID", "T");
+    }
+    for (const [key, value] of Object.entries(credentials.$source ?? {})) {
+      setFeature(context, key, value);
+    }
+  }
+}
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-user-agent/constants.js
+var USER_AGENT = "user-agent";
+var X_AMZ_USER_AGENT = "x-amz-user-agent";
+var SPACE = " ";
+var UA_NAME_SEPARATOR = "/";
+var UA_NAME_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w]/g;
+var UA_VALUE_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w#]/g;
+var UA_ESCAPE_CHAR = "-";
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-user-agent/encode-features.js
+var BYTE_LIMIT = 1024;
+function encodeFeatures(features) {
+  let buffer = "";
+  for (const key in features) {
+    const val = features[key];
+    if (buffer.length + val.length + 1 <= BYTE_LIMIT) {
+      if (buffer.length) {
+        buffer += "," + val;
+      } else {
+        buffer += val;
+      }
+      continue;
+    }
+    break;
+  }
+  return buffer;
+}
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-user-agent/user-agent-middleware.js
+var userAgentMiddleware = (options) => (next, context) => async (args) => {
+  const { request } = args;
+  if (!HttpRequest.isInstance(request)) {
+    return next(args);
+  }
+  const { headers } = request;
+  const userAgent = context?.userAgent?.map(escapeUserAgent) || [];
+  const defaultUserAgent2 = (await options.defaultUserAgentProvider()).map(escapeUserAgent);
+  await checkFeatures(context, options, args);
+  const awsContext = context;
+  defaultUserAgent2.push(`m/${encodeFeatures(Object.assign({}, context.__smithy_context?.features, awsContext.__aws_sdk_context?.features))}`);
+  const customUserAgent = options?.customUserAgent?.map(escapeUserAgent) || [];
+  const appId = await options.userAgentAppId();
+  if (appId) {
+    defaultUserAgent2.push(escapeUserAgent([`app`, `${appId}`]));
+  }
+  const prefix = getUserAgentPrefix();
+  const sdkUserAgentValue = (prefix ? [prefix] : []).concat([...defaultUserAgent2, ...userAgent, ...customUserAgent]).join(SPACE);
+  const normalUAValue = [
+    ...defaultUserAgent2.filter((section) => section.startsWith("aws-sdk-")),
+    ...customUserAgent
+  ].join(SPACE);
+  if (options.runtime !== "browser") {
+    if (normalUAValue) {
+      headers[X_AMZ_USER_AGENT] = headers[X_AMZ_USER_AGENT] ? `${headers[USER_AGENT]} ${normalUAValue}` : normalUAValue;
+    }
+    headers[USER_AGENT] = sdkUserAgentValue;
+  } else {
+    headers[X_AMZ_USER_AGENT] = sdkUserAgentValue;
+  }
+  return next({
+    ...args,
+    request
+  });
+};
+var escapeUserAgent = (userAgentPair) => {
+  const name = userAgentPair[0].split(UA_NAME_SEPARATOR).map((part) => part.replace(UA_NAME_ESCAPE_REGEX, UA_ESCAPE_CHAR)).join(UA_NAME_SEPARATOR);
+  const version = userAgentPair[1]?.replace(UA_VALUE_ESCAPE_REGEX, UA_ESCAPE_CHAR);
+  const prefixSeparatorIndex = name.indexOf(UA_NAME_SEPARATOR);
+  const prefix = name.substring(0, prefixSeparatorIndex);
+  let uaName = name.substring(prefixSeparatorIndex + 1);
+  if (prefix === "api") {
+    uaName = uaName.toLowerCase();
+  }
+  return [prefix, uaName, version].filter((item) => item && item.length > 0).reduce((acc, item, index) => {
+    switch (index) {
+      case 0:
+        return item;
+      case 1:
+        return `${acc}/${item}`;
+      default:
+        return `${acc}#${item}`;
+    }
+  }, "");
+};
+var getUserAgentMiddlewareOptions = {
+  name: "getUserAgentMiddleware",
+  step: "build",
+  priority: "low",
+  tags: ["SET_USER_AGENT", "USER_AGENT"],
+  override: true
+};
+var getUserAgentPlugin = (config) => ({
+  applyToStack: (clientStack) => {
+    clientStack.add(userAgentMiddleware(config), getUserAgentMiddlewareOptions);
+  }
+});
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/emitWarningIfUnsupportedVersion.js
+var state = {
+  warningEmitted: false
+};
+var emitWarningIfUnsupportedVersion = (version) => {
+  if (version && !state.warningEmitted) {
+    if (process.env.AWS_SDK_JS_NODE_VERSION_SUPPORT_WARNING_DISABLED === "true") {
+      state.warningEmitted = true;
+      return;
+    }
+    const userMajorVersion = parseInt(version.substring(1, version.indexOf(".")));
+    const vv = 22;
+    if (userMajorVersion < vv) {
+      state.warningEmitted = true;
+      process.emitWarning(`NodeVersionSupportWarning: The AWS SDK for JavaScript (v3)
+versions published after the first week of January 2027
+will require node >=${vv}. You are running node ${version}.
+
+To continue receiving updates to AWS services, bug fixes,
+and security updates please upgrade to node >=${vv}.
+
+More information can be found at: https://a.co/c895JFp`);
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/defaultUserAgent.js
+import { platform, release } from "os";
+import { env } from "process";
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getRuntimeUserAgentPair.js
+import { versions } from "process";
+var getRuntimeUserAgentPair = () => {
+  const runtimesToCheck = ["deno", "bun", "llrt"];
+  for (const runtime of runtimesToCheck) {
+    if (versions[runtime]) {
+      return [`md/${runtime}`, versions[runtime]];
+    }
+  }
+  return ["md/nodejs", versions.node];
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/crt-availability.js
+var crtAvailability = {
+  isCrtAvailable: false
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/is-crt-available.js
+var isCrtAvailable = () => {
+  if (crtAvailability.isCrtAvailable) {
+    return ["md/crt-avail"];
+  }
+  return null;
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/defaultUserAgent.js
+var createDefaultUserAgentProvider = ({ serviceId, clientVersion }) => {
+  const runtimeUserAgentPair = getRuntimeUserAgentPair();
+  return async (config) => {
+    const sections = [
+      ["aws-sdk-js", clientVersion],
+      ["ua", "2.1"],
+      [`os/${platform()}`, release()],
+      ["lang/js"],
+      runtimeUserAgentPair
+    ];
+    const crtAvailable = isCrtAvailable();
+    if (crtAvailable) {
+      sections.push(crtAvailable);
+    }
+    if (serviceId) {
+      sections.push([`api/${serviceId}`, clientVersion]);
+    }
+    if (env.AWS_EXECUTION_ENV) {
+      sections.push([`exec-env/${env.AWS_EXECUTION_ENV}`]);
+    }
+    const appId = await config?.userAgentAppId?.();
+    const resolvedUserAgent = appId ? [...sections, [`app/${appId}`]] : [...sections];
+    return resolvedUserAgent;
+  };
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/nodeAppIdConfigOptions.js
+var UA_APP_ID_ENV_NAME = "AWS_SDK_UA_APP_ID";
+var UA_APP_ID_INI_NAME = "sdk_ua_app_id";
+var UA_APP_ID_INI_NAME_DEPRECATED = "sdk-ua-app-id";
+var NODE_APP_ID_CONFIG_OPTIONS = {
+  environmentVariableSelector: (env2) => env2[UA_APP_ID_ENV_NAME],
+  configFileSelector: (profile) => profile[UA_APP_ID_INI_NAME] ?? profile[UA_APP_ID_INI_NAME_DEPRECATED],
+  default: DEFAULT_UA_APP_ID
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/util-endpoints/lib/aws/isVirtualHostableS3Bucket.js
+var isVirtualHostableS3Bucket = (value, allowSubDomains = false) => {
+  if (allowSubDomains) {
+    for (const label of value.split(".")) {
+      if (!isVirtualHostableS3Bucket(label)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (!isValidHostLabel(value)) {
+    return false;
+  }
+  if (value.length < 3 || value.length > 63) {
+    return false;
+  }
+  if (value !== value.toLowerCase()) {
+    return false;
+  }
+  if (isIpAddress(value)) {
+    return false;
+  }
+  return true;
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/util-endpoints/lib/aws/parseArn.js
+var ARN_DELIMITER = ":";
+var RESOURCE_DELIMITER = "/";
+var parseArn = (value) => {
+  const segments = value.split(ARN_DELIMITER);
+  if (segments.length < 6)
+    return null;
+  const [arn, partition2, service, region, accountId, ...resourcePath] = segments;
+  if (arn !== "arn" || partition2 === "" || service === "" || resourcePath.join(ARN_DELIMITER) === "")
+    return null;
+  const resourceId = resourcePath.map((resource) => resource.split(RESOURCE_DELIMITER)).flat();
+  return {
+    partition: partition2,
+    service,
+    region,
+    accountId,
+    resourceId
+  };
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/util-endpoints/aws.js
+var awsEndpointFunctions = {
+  isVirtualHostableS3Bucket,
+  parseArn,
+  partition
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/region-config-resolver/stsRegionDefaultResolver.js
+function stsRegionDefaultResolver(loaderConfig = {}) {
+  return loadConfig({
+    ...NODE_REGION_CONFIG_OPTIONS,
+    async default() {
+      if (!warning.silence) {
+        console.warn("@aws-sdk - WARN - default STS region of us-east-1 used. See @aws-sdk/credential-providers README and set a region explicitly.");
+      }
+      return "us-east-1";
+    }
+  }, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig });
+}
+var warning = {
+  silence: false
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-es/submodules/client/region-config-resolver/extensions.js
+var getAwsRegionExtensionConfiguration = (runtimeConfig) => {
+  return {
+    setRegion(region) {
+      runtimeConfig.region = region;
+    },
+    region() {
+      return runtimeConfig.region;
+    }
+  };
+};
+var resolveAwsRegionExtensionConfiguration = (awsRegionExtensionConfiguration) => {
+  return {
+    region: awsRegionExtensionConfiguration.region()
+  };
+};
+
+export {
+  emitWarningIfUnsupportedVersion,
+  setCredentialFeature,
+  DEFAULT_RETRY_MODE,
+  NODE_MAX_ATTEMPT_CONFIG_OPTIONS,
+  resolveRetryConfig,
+  NODE_RETRY_MODE_CONFIG_OPTIONS,
+  getRetryPlugin,
+  setFeature,
+  resolveHostHeaderConfig,
+  getHostHeaderPlugin,
+  getLoggerPlugin,
+  getRecursionDetectionPlugin,
+  getHttpAuthSchemeEndpointRuleSetPlugin,
+  httpSigningMiddlewareOptions,
+  getHttpSigningPlugin,
+  normalizeProvider2 as normalizeProvider,
+  createPaginator,
+  DefaultIdentityProviderConfig,
+  NoAuthSigner,
+  isIdentityExpired,
+  doesIdentityRequireRefresh,
+  memoizeIdentityProvider,
+  resolveUserAgentConfig,
+  getUserAgentPlugin,
+  createDefaultUserAgentProvider,
+  NODE_APP_ID_CONFIG_OPTIONS,
+  awsEndpointFunctions,
+  stsRegionDefaultResolver,
+  getAwsRegionExtensionConfiguration,
+  resolveAwsRegionExtensionConfiguration
+};