@cdklabs/cdk-ecs-codedeploy 0.0.235 → 0.0.236

package/node_modules/@smithy/middleware-retry/dist-cjs/index.js

@@ -1,10 +1,422 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./AdaptiveRetryStrategy"), exports);
-tslib_1.__exportStar(require("./StandardRetryStrategy"), exports);
-tslib_1.__exportStar(require("./configurations"), exports);
-tslib_1.__exportStar(require("./delayDecider"), exports);
-tslib_1.__exportStar(require("./omitRetryHeadersMiddleware"), exports);
-tslib_1.__exportStar(require("./retryDecider"), exports);
-tslib_1.__exportStar(require("./retryMiddleware"), exports);
+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);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AdaptiveRetryStrategy: () => AdaptiveRetryStrategy,
+  CONFIG_MAX_ATTEMPTS: () => CONFIG_MAX_ATTEMPTS,
+  CONFIG_RETRY_MODE: () => CONFIG_RETRY_MODE,
+  ENV_MAX_ATTEMPTS: () => ENV_MAX_ATTEMPTS,
+  ENV_RETRY_MODE: () => ENV_RETRY_MODE,
+  NODE_MAX_ATTEMPT_CONFIG_OPTIONS: () => NODE_MAX_ATTEMPT_CONFIG_OPTIONS,
+  NODE_RETRY_MODE_CONFIG_OPTIONS: () => NODE_RETRY_MODE_CONFIG_OPTIONS,
+  StandardRetryStrategy: () => StandardRetryStrategy,
+  defaultDelayDecider: () => defaultDelayDecider,
+  defaultRetryDecider: () => defaultRetryDecider,
+  getOmitRetryHeadersPlugin: () => getOmitRetryHeadersPlugin,
+  getRetryAfterHint: () => getRetryAfterHint,
+  getRetryPlugin: () => getRetryPlugin,
+  omitRetryHeadersMiddleware: () => omitRetryHeadersMiddleware,
+  omitRetryHeadersMiddlewareOptions: () => omitRetryHeadersMiddlewareOptions,
+  resolveRetryConfig: () => resolveRetryConfig,
+  retryMiddleware: () => retryMiddleware,
+  retryMiddlewareOptions: () => retryMiddlewareOptions
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/AdaptiveRetryStrategy.ts
+
+
+// src/StandardRetryStrategy.ts
+var import_protocol_http = require("@smithy/protocol-http");
+
+
+var import_uuid = require("uuid");
+
+// src/defaultRetryQuota.ts
+var import_util_retry = require("@smithy/util-retry");
+var getDefaultRetryQuota = /* @__PURE__ */ __name((initialRetryTokens, options) => {
+  const MAX_CAPACITY = initialRetryTokens;
+  const noRetryIncrement = (options == null ? void 0 : options.noRetryIncrement) ?? import_util_retry.NO_RETRY_INCREMENT;
+  const retryCost = (options == null ? void 0 : options.retryCost) ?? import_util_retry.RETRY_COST;
+  const timeoutRetryCost = (options == null ? void 0 : options.timeoutRetryCost) ?? import_util_retry.TIMEOUT_RETRY_COST;
+  let availableCapacity = initialRetryTokens;
+  const getCapacityAmount = /* @__PURE__ */ __name((error) => error.name === "TimeoutError" ? timeoutRetryCost : retryCost, "getCapacityAmount");
+  const hasRetryTokens = /* @__PURE__ */ __name((error) => getCapacityAmount(error) <= availableCapacity, "hasRetryTokens");
+  const retrieveRetryTokens = /* @__PURE__ */ __name((error) => {
+    if (!hasRetryTokens(error)) {
+      throw new Error("No retry token available");
+    }
+    const capacityAmount = getCapacityAmount(error);
+    availableCapacity -= capacityAmount;
+    return capacityAmount;
+  }, "retrieveRetryTokens");
+  const releaseRetryTokens = /* @__PURE__ */ __name((capacityReleaseAmount) => {
+    availableCapacity += capacityReleaseAmount ?? noRetryIncrement;
+    availableCapacity = Math.min(availableCapacity, MAX_CAPACITY);
+  }, "releaseRetryTokens");
+  return Object.freeze({
+    hasRetryTokens,
+    retrieveRetryTokens,
+    releaseRetryTokens
+  });
+}, "getDefaultRetryQuota");
+
+// src/delayDecider.ts
+
+var defaultDelayDecider = /* @__PURE__ */ __name((delayBase, attempts) => Math.floor(Math.min(import_util_retry.MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase)), "defaultDelayDecider");
+
+// src/retryDecider.ts
+var import_service_error_classification = require("@smithy/service-error-classification");
+var defaultRetryDecider = /* @__PURE__ */ __name((error) => {
+  if (!error) {
+    return false;
+  }
+  return (0, import_service_error_classification.isRetryableByTrait)(error) || (0, import_service_error_classification.isClockSkewError)(error) || (0, import_service_error_classification.isThrottlingError)(error) || (0, import_service_error_classification.isTransientError)(error);
+}, "defaultRetryDecider");
+
+// src/util.ts
+var asSdkError = /* @__PURE__ */ __name((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}`);
+}, "asSdkError");
+
+// src/StandardRetryStrategy.ts
+var _StandardRetryStrategy = class _StandardRetryStrategy {
+  constructor(maxAttemptsProvider, options) {
+    this.maxAttemptsProvider = maxAttemptsProvider;
+    this.mode = import_util_retry.RETRY_MODES.STANDARD;
+    this.retryDecider = (options == null ? void 0 : options.retryDecider) ?? defaultRetryDecider;
+    this.delayDecider = (options == null ? void 0 : options.delayDecider) ?? defaultDelayDecider;
+    this.retryQuota = (options == null ? void 0 : options.retryQuota) ?? getDefaultRetryQuota(import_util_retry.INITIAL_RETRY_TOKENS);
+  }
+  shouldRetry(error, attempts, maxAttempts) {
+    return attempts < maxAttempts && this.retryDecider(error) && this.retryQuota.hasRetryTokens(error);
+  }
+  async getMaxAttempts() {
+    let maxAttempts;
+    try {
+      maxAttempts = await this.maxAttemptsProvider();
+    } catch (error) {
+      maxAttempts = import_util_retry.DEFAULT_MAX_ATTEMPTS;
+    }
+    return maxAttempts;
+  }
+  async retry(next, args, options) {
+    let retryTokenAmount;
+    let attempts = 0;
+    let totalDelay = 0;
+    const maxAttempts = await this.getMaxAttempts();
+    const { request } = args;
+    if (import_protocol_http.HttpRequest.isInstance(request)) {
+      request.headers[import_util_retry.INVOCATION_ID_HEADER] = (0, import_uuid.v4)();
+    }
+    while (true) {
+      try {
+        if (import_protocol_http.HttpRequest.isInstance(request)) {
+          request.headers[import_util_retry.REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
+        }
+        if (options == null ? void 0 : options.beforeRequest) {
+          await options.beforeRequest();
+        }
+        const { response, output } = await next(args);
+        if (options == null ? void 0 : options.afterRequest) {
+          options.afterRequest(response);
+        }
+        this.retryQuota.releaseRetryTokens(retryTokenAmount);
+        output.$metadata.attempts = attempts + 1;
+        output.$metadata.totalRetryDelay = totalDelay;
+        return { response, output };
+      } catch (e) {
+        const err = asSdkError(e);
+        attempts++;
+        if (this.shouldRetry(err, attempts, maxAttempts)) {
+          retryTokenAmount = this.retryQuota.retrieveRetryTokens(err);
+          const delayFromDecider = this.delayDecider(
+            (0, import_service_error_classification.isThrottlingError)(err) ? import_util_retry.THROTTLING_RETRY_DELAY_BASE : import_util_retry.DEFAULT_RETRY_DELAY_BASE,
+            attempts
+          );
+          const delayFromResponse = getDelayFromRetryAfterHeader(err.$response);
+          const delay = Math.max(delayFromResponse || 0, delayFromDecider);
+          totalDelay += delay;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        if (!err.$metadata) {
+          err.$metadata = {};
+        }
+        err.$metadata.attempts = attempts;
+        err.$metadata.totalRetryDelay = totalDelay;
+        throw err;
+      }
+    }
+  }
+};
+__name(_StandardRetryStrategy, "StandardRetryStrategy");
+var StandardRetryStrategy = _StandardRetryStrategy;
+var getDelayFromRetryAfterHeader = /* @__PURE__ */ __name((response) => {
+  if (!import_protocol_http.HttpResponse.isInstance(response))
+    return;
+  const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
+  if (!retryAfterHeaderName)
+    return;
+  const retryAfter = response.headers[retryAfterHeaderName];
+  const retryAfterSeconds = Number(retryAfter);
+  if (!Number.isNaN(retryAfterSeconds))
+    return retryAfterSeconds * 1e3;
+  const retryAfterDate = new Date(retryAfter);
+  return retryAfterDate.getTime() - Date.now();
+}, "getDelayFromRetryAfterHeader");
+
+// src/AdaptiveRetryStrategy.ts
+var _AdaptiveRetryStrategy = class _AdaptiveRetryStrategy extends StandardRetryStrategy {
+  constructor(maxAttemptsProvider, options) {
+    const { rateLimiter, ...superOptions } = options ?? {};
+    super(maxAttemptsProvider, superOptions);
+    this.rateLimiter = rateLimiter ?? new import_util_retry.DefaultRateLimiter();
+    this.mode = import_util_retry.RETRY_MODES.ADAPTIVE;
+  }
+  async retry(next, args) {
+    return super.retry(next, args, {
+      beforeRequest: async () => {
+        return this.rateLimiter.getSendToken();
+      },
+      afterRequest: (response) => {
+        this.rateLimiter.updateClientSendingRate(response);
+      }
+    });
+  }
+};
+__name(_AdaptiveRetryStrategy, "AdaptiveRetryStrategy");
+var AdaptiveRetryStrategy = _AdaptiveRetryStrategy;
+
+// src/configurations.ts
+var import_util_middleware = require("@smithy/util-middleware");
+
+var ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
+var CONFIG_MAX_ATTEMPTS = "max_attempts";
+var NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
+  environmentVariableSelector: (env) => {
+    const value = env[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: import_util_retry.DEFAULT_MAX_ATTEMPTS
+};
+var resolveRetryConfig = /* @__PURE__ */ __name((input) => {
+  const { retryStrategy } = input;
+  const maxAttempts = (0, import_util_middleware.normalizeProvider)(input.maxAttempts ?? import_util_retry.DEFAULT_MAX_ATTEMPTS);
+  return {
+    ...input,
+    maxAttempts,
+    retryStrategy: async () => {
+      if (retryStrategy) {
+        return retryStrategy;
+      }
+      const retryMode = await (0, import_util_middleware.normalizeProvider)(input.retryMode)();
+      if (retryMode === import_util_retry.RETRY_MODES.ADAPTIVE) {
+        return new import_util_retry.AdaptiveRetryStrategy(maxAttempts);
+      }
+      return new import_util_retry.StandardRetryStrategy(maxAttempts);
+    }
+  };
+}, "resolveRetryConfig");
+var ENV_RETRY_MODE = "AWS_RETRY_MODE";
+var CONFIG_RETRY_MODE = "retry_mode";
+var NODE_RETRY_MODE_CONFIG_OPTIONS = {
+  environmentVariableSelector: (env) => env[ENV_RETRY_MODE],
+  configFileSelector: (profile) => profile[CONFIG_RETRY_MODE],
+  default: import_util_retry.DEFAULT_RETRY_MODE
+};
+
+// src/omitRetryHeadersMiddleware.ts
+
+
+var omitRetryHeadersMiddleware = /* @__PURE__ */ __name(() => (next) => async (args) => {
+  const { request } = args;
+  if (import_protocol_http.HttpRequest.isInstance(request)) {
+    delete request.headers[import_util_retry.INVOCATION_ID_HEADER];
+    delete request.headers[import_util_retry.REQUEST_HEADER];
+  }
+  return next(args);
+}, "omitRetryHeadersMiddleware");
+var omitRetryHeadersMiddlewareOptions = {
+  name: "omitRetryHeadersMiddleware",
+  tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"],
+  relation: "before",
+  toMiddleware: "awsAuthMiddleware",
+  override: true
+};
+var getOmitRetryHeadersPlugin = /* @__PURE__ */ __name((options) => ({
+  applyToStack: (clientStack) => {
+    clientStack.addRelativeTo(omitRetryHeadersMiddleware(), omitRetryHeadersMiddlewareOptions);
+  }
+}), "getOmitRetryHeadersPlugin");
+
+// src/retryMiddleware.ts
+
+
+var import_smithy_client = require("@smithy/smithy-client");
+
+
+var import_isStreamingPayload = require("./isStreamingPayload/isStreamingPayload");
+var retryMiddleware = /* @__PURE__ */ __name((options) => (next, context) => async (args) => {
+  var _a;
+  let retryStrategy = await options.retryStrategy();
+  const maxAttempts = await options.maxAttempts();
+  if (isRetryStrategyV2(retryStrategy)) {
+    retryStrategy = retryStrategy;
+    let retryToken = await retryStrategy.acquireInitialRetryToken(context["partition_id"]);
+    let lastError = new Error();
+    let attempts = 0;
+    let totalRetryDelay = 0;
+    const { request } = args;
+    const isRequest = import_protocol_http.HttpRequest.isInstance(request);
+    if (isRequest) {
+      request.headers[import_util_retry.INVOCATION_ID_HEADER] = (0, import_uuid.v4)();
+    }
+    while (true) {
+      try {
+        if (isRequest) {
+          request.headers[import_util_retry.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);
+        lastError = asSdkError(e);
+        if (isRequest && (0, import_isStreamingPayload.isStreamingPayload)(request)) {
+          (_a = context.logger instanceof import_smithy_client.NoOpLogger ? console : context.logger) == null ? void 0 : _a.warn(
+            "An error was encountered in a non-retryable streaming request."
+          );
+          throw lastError;
+        }
+        try {
+          retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
+        } catch (refreshError) {
+          if (!lastError.$metadata) {
+            lastError.$metadata = {};
+          }
+          lastError.$metadata.attempts = attempts + 1;
+          lastError.$metadata.totalRetryDelay = totalRetryDelay;
+          throw lastError;
+        }
+        attempts = retryToken.getRetryCount();
+        const delay = retryToken.getRetryDelay();
+        totalRetryDelay += delay;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  } else {
+    retryStrategy = retryStrategy;
+    if (retryStrategy == null ? void 0 : retryStrategy.mode)
+      context.userAgent = [...context.userAgent || [], ["cfg/retry-mode", retryStrategy.mode]];
+    return retryStrategy.retry(next, args);
+  }
+}, "retryMiddleware");
+var isRetryStrategyV2 = /* @__PURE__ */ __name((retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" && typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" && typeof retryStrategy.recordSuccess !== "undefined", "isRetryStrategyV2");
+var getRetryErrorInfo = /* @__PURE__ */ __name((error) => {
+  const errorInfo = {
+    errorType: getRetryErrorType(error)
+  };
+  const retryAfterHint = getRetryAfterHint(error.$response);
+  if (retryAfterHint) {
+    errorInfo.retryAfterHint = retryAfterHint;
+  }
+  return errorInfo;
+}, "getRetryErrorInfo");
+var getRetryErrorType = /* @__PURE__ */ __name((error) => {
+  if ((0, import_service_error_classification.isThrottlingError)(error))
+    return "THROTTLING";
+  if ((0, import_service_error_classification.isTransientError)(error))
+    return "TRANSIENT";
+  if ((0, import_service_error_classification.isServerError)(error))
+    return "SERVER_ERROR";
+  return "CLIENT_ERROR";
+}, "getRetryErrorType");
+var retryMiddlewareOptions = {
+  name: "retryMiddleware",
+  tags: ["RETRY"],
+  step: "finalizeRequest",
+  priority: "high",
+  override: true
+};
+var getRetryPlugin = /* @__PURE__ */ __name((options) => ({
+  applyToStack: (clientStack) => {
+    clientStack.add(retryMiddleware(options), retryMiddlewareOptions);
+  }
+}), "getRetryPlugin");
+var getRetryAfterHint = /* @__PURE__ */ __name((response) => {
+  if (!import_protocol_http.HttpResponse.isInstance(response))
+    return;
+  const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
+  if (!retryAfterHeaderName)
+    return;
+  const retryAfter = response.headers[retryAfterHeaderName];
+  const retryAfterSeconds = Number(retryAfter);
+  if (!Number.isNaN(retryAfterSeconds))
+    return new Date(retryAfterSeconds * 1e3);
+  const retryAfterDate = new Date(retryAfter);
+  return retryAfterDate;
+}, "getRetryAfterHint");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdaptiveRetryStrategy,
+  CONFIG_MAX_ATTEMPTS,
+  CONFIG_RETRY_MODE,
+  ENV_MAX_ATTEMPTS,
+  ENV_RETRY_MODE,
+  NODE_MAX_ATTEMPT_CONFIG_OPTIONS,
+  NODE_RETRY_MODE_CONFIG_OPTIONS,
+  StandardRetryStrategy,
+  defaultDelayDecider,
+  defaultRetryDecider,
+  getOmitRetryHeadersPlugin,
+  getRetryAfterHint,
+  getRetryPlugin,
+  omitRetryHeadersMiddleware,
+  omitRetryHeadersMiddlewareOptions,
+  resolveRetryConfig,
+  retryMiddleware,
+  retryMiddlewareOptions
+});

package/node_modules/@smithy/middleware-retry/dist-cjs/omitRetryHeadersMiddleware.js

@@ -1,27 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOmitRetryHeadersPlugin = exports.omitRetryHeadersMiddlewareOptions = exports.omitRetryHeadersMiddleware = void 0;
-const protocol_http_1 = require("@smithy/protocol-http");
-const util_retry_1 = require("@smithy/util-retry");
-const omitRetryHeadersMiddleware = () => (next) => async (args) => {
-    const { request } = args;
-    if (protocol_http_1.HttpRequest.isInstance(request)) {
-        delete request.headers[util_retry_1.INVOCATION_ID_HEADER];
-        delete request.headers[util_retry_1.REQUEST_HEADER];
-    }
-    return next(args);
-};
-exports.omitRetryHeadersMiddleware = omitRetryHeadersMiddleware;
-exports.omitRetryHeadersMiddlewareOptions = {
-    name: "omitRetryHeadersMiddleware",
-    tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"],
-    relation: "before",
-    toMiddleware: "awsAuthMiddleware",
-    override: true,
-};
-const getOmitRetryHeadersPlugin = (options) => ({
-    applyToStack: (clientStack) => {
-        clientStack.addRelativeTo((0, exports.omitRetryHeadersMiddleware)(), exports.omitRetryHeadersMiddlewareOptions);
-    },
-});
-exports.getOmitRetryHeadersPlugin = getOmitRetryHeadersPlugin;
+module.exports = require("./index.js");

package/node_modules/@smithy/middleware-retry/dist-cjs/retryDecider.js

@@ -1,11 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultRetryDecider = void 0;
-const service_error_classification_1 = require("@smithy/service-error-classification");
-const defaultRetryDecider = (error) => {
-    if (!error) {
-        return false;
-    }
-    return (0, service_error_classification_1.isRetryableByTrait)(error) || (0, service_error_classification_1.isClockSkewError)(error) || (0, service_error_classification_1.isThrottlingError)(error) || (0, service_error_classification_1.isTransientError)(error);
-};
-exports.defaultRetryDecider = defaultRetryDecider;
+module.exports = require("./index.js");

package/node_modules/@smithy/middleware-retry/dist-cjs/retryMiddleware.js

@@ -1,118 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRetryAfterHint = exports.getRetryPlugin = exports.retryMiddlewareOptions = exports.retryMiddleware = void 0;
-const protocol_http_1 = require("@smithy/protocol-http");
-const service_error_classification_1 = require("@smithy/service-error-classification");
-const smithy_client_1 = require("@smithy/smithy-client");
-const util_retry_1 = require("@smithy/util-retry");
-const uuid_1 = require("uuid");
-const isStreamingPayload_1 = require("./isStreamingPayload/isStreamingPayload");
-const util_1 = require("./util");
-const retryMiddleware = (options) => (next, context) => async (args) => {
-    var _a;
-    let retryStrategy = await options.retryStrategy();
-    const maxAttempts = await options.maxAttempts();
-    if (isRetryStrategyV2(retryStrategy)) {
-        retryStrategy = retryStrategy;
-        let retryToken = await retryStrategy.acquireInitialRetryToken(context["partition_id"]);
-        let lastError = new Error();
-        let attempts = 0;
-        let totalRetryDelay = 0;
-        const { request } = args;
-        const isRequest = protocol_http_1.HttpRequest.isInstance(request);
-        if (isRequest) {
-            request.headers[util_retry_1.INVOCATION_ID_HEADER] = (0, uuid_1.v4)();
-        }
-        while (true) {
-            try {
-                if (isRequest) {
-                    request.headers[util_retry_1.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);
-                lastError = (0, util_1.asSdkError)(e);
-                if (isRequest && (0, isStreamingPayload_1.isStreamingPayload)(request)) {
-                    (_a = (context.logger instanceof smithy_client_1.NoOpLogger ? console : context.logger)) === null || _a === void 0 ? void 0 : _a.warn("An error was encountered in a non-retryable streaming request.");
-                    throw lastError;
-                }
-                try {
-                    retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
-                }
-                catch (refreshError) {
-                    if (!lastError.$metadata) {
-                        lastError.$metadata = {};
-                    }
-                    lastError.$metadata.attempts = attempts + 1;
-                    lastError.$metadata.totalRetryDelay = totalRetryDelay;
-                    throw lastError;
-                }
-                attempts = retryToken.getRetryCount();
-                const delay = retryToken.getRetryDelay();
-                totalRetryDelay += delay;
-                await new Promise((resolve) => setTimeout(resolve, delay));
-            }
-        }
-    }
-    else {
-        retryStrategy = retryStrategy;
-        if (retryStrategy === null || retryStrategy === void 0 ? void 0 : retryStrategy.mode)
-            context.userAgent = [...(context.userAgent || []), ["cfg/retry-mode", retryStrategy.mode]];
-        return retryStrategy.retry(next, args);
-    }
-};
-exports.retryMiddleware = retryMiddleware;
-const isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" &&
-    typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" &&
-    typeof retryStrategy.recordSuccess !== "undefined";
-const getRetryErrorInfo = (error) => {
-    const errorInfo = {
-        errorType: getRetryErrorType(error),
-    };
-    const retryAfterHint = (0, exports.getRetryAfterHint)(error.$response);
-    if (retryAfterHint) {
-        errorInfo.retryAfterHint = retryAfterHint;
-    }
-    return errorInfo;
-};
-const getRetryErrorType = (error) => {
-    if ((0, service_error_classification_1.isThrottlingError)(error))
-        return "THROTTLING";
-    if ((0, service_error_classification_1.isTransientError)(error))
-        return "TRANSIENT";
-    if ((0, service_error_classification_1.isServerError)(error))
-        return "SERVER_ERROR";
-    return "CLIENT_ERROR";
-};
-exports.retryMiddlewareOptions = {
-    name: "retryMiddleware",
-    tags: ["RETRY"],
-    step: "finalizeRequest",
-    priority: "high",
-    override: true,
-};
-const getRetryPlugin = (options) => ({
-    applyToStack: (clientStack) => {
-        clientStack.add((0, exports.retryMiddleware)(options), exports.retryMiddlewareOptions);
-    },
-});
-exports.getRetryPlugin = getRetryPlugin;
-const getRetryAfterHint = (response) => {
-    if (!protocol_http_1.HttpResponse.isInstance(response))
-        return;
-    const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
-    if (!retryAfterHeaderName)
-        return;
-    const retryAfter = response.headers[retryAfterHeaderName];
-    const retryAfterSeconds = Number(retryAfter);
-    if (!Number.isNaN(retryAfterSeconds))
-        return new Date(retryAfterSeconds * 1000);
-    const retryAfterDate = new Date(retryAfter);
-    return retryAfterDate;
-};
-exports.getRetryAfterHint = getRetryAfterHint;
+module.exports = require("./index.js");

package/node_modules/@smithy/middleware-retry/dist-cjs/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+module.exports = require("./index.js");

package/node_modules/@smithy/middleware-retry/dist-cjs/util.js

@@ -1,13 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asSdkError = void 0;
-const 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}`);
-};
-exports.asSdkError = asSdkError;
+module.exports = require("./index.js");

package/node_modules/@smithy/middleware-retry/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@smithy/middleware-retry",
-  "version": "2.0.26",
+  "version": "2.1.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'",
-    "build:cjs": "yarn g:tsc -p tsconfig.cjs.json",
+    "build:cjs": "node ../../scripts/inline middleware-retry",
     "build:es": "yarn g:tsc -p tsconfig.es.json",
     "build:types": "yarn g:tsc -p tsconfig.types.json",
     "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
@@ -31,18 +31,18 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@smithy/node-config-provider": "^2.1.9",
-    "@smithy/protocol-http": "^3.0.12",
-    "@smithy/service-error-classification": "^2.0.9",
-    "@smithy/smithy-client": "^2.2.1",
-    "@smithy/types": "^2.8.0",
-    "@smithy/util-middleware": "^2.0.9",
-    "@smithy/util-retry": "^2.0.9",
+    "@smithy/node-config-provider": "^2.2.0",
+    "@smithy/protocol-http": "^3.1.0",
+    "@smithy/service-error-classification": "^2.1.0",
+    "@smithy/smithy-client": "^2.3.0",
+    "@smithy/types": "^2.9.0",
+    "@smithy/util-middleware": "^2.1.0",
+    "@smithy/util-retry": "^2.1.0",
     "tslib": "^2.5.0",
     "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@smithy/util-test": "^0.1.12",
+    "@smithy/util-test": "^0.1.13",
     "@tsconfig/recommended": "1.0.1",
     "@types/uuid": "^8.3.0",
     "concurrently": "7.0.0",

package/node_modules/@smithy/middleware-serde/dist-cjs/deserializerMiddleware.js

@@ -1,24 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializerMiddleware = void 0;
-const deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
-    const { response } = await next(args);
-    try {
-        const parsed = await deserializer(response, options);
-        return {
-            response,
-            output: parsed,
-        };
-    }
-    catch (error) {
-        Object.defineProperty(error, "$response", {
-            value: response,
-        });
-        if (!("$metadata" in error)) {
-            const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
-            error.message += "\n  " + hint;
-        }
-        throw error;
-    }
-};
-exports.deserializerMiddleware = deserializerMiddleware;
+module.exports = require("./index.js");