@cdklabs/cdk-ecs-codedeploy 0.0.235 → 0.0.236

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

@@ -1,10 +1,345 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./AdaptiveRetryStrategy"), exports);
-tslib_1.__exportStar(require("./ConfiguredRetryStrategy"), exports);
-tslib_1.__exportStar(require("./DefaultRateLimiter"), exports);
-tslib_1.__exportStar(require("./StandardRetryStrategy"), exports);
-tslib_1.__exportStar(require("./config"), exports);
-tslib_1.__exportStar(require("./constants"), exports);
-tslib_1.__exportStar(require("./types"), 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,
+  ConfiguredRetryStrategy: () => ConfiguredRetryStrategy,
+  DEFAULT_MAX_ATTEMPTS: () => DEFAULT_MAX_ATTEMPTS,
+  DEFAULT_RETRY_DELAY_BASE: () => DEFAULT_RETRY_DELAY_BASE,
+  DEFAULT_RETRY_MODE: () => DEFAULT_RETRY_MODE,
+  DefaultRateLimiter: () => DefaultRateLimiter,
+  INITIAL_RETRY_TOKENS: () => INITIAL_RETRY_TOKENS,
+  INVOCATION_ID_HEADER: () => INVOCATION_ID_HEADER,
+  MAXIMUM_RETRY_DELAY: () => MAXIMUM_RETRY_DELAY,
+  NO_RETRY_INCREMENT: () => NO_RETRY_INCREMENT,
+  REQUEST_HEADER: () => REQUEST_HEADER,
+  RETRY_COST: () => RETRY_COST,
+  RETRY_MODES: () => RETRY_MODES,
+  StandardRetryStrategy: () => StandardRetryStrategy,
+  THROTTLING_RETRY_DELAY_BASE: () => THROTTLING_RETRY_DELAY_BASE,
+  TIMEOUT_RETRY_COST: () => TIMEOUT_RETRY_COST
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config.ts
+var RETRY_MODES = /* @__PURE__ */ ((RETRY_MODES2) => {
+  RETRY_MODES2["STANDARD"] = "standard";
+  RETRY_MODES2["ADAPTIVE"] = "adaptive";
+  return RETRY_MODES2;
+})(RETRY_MODES || {});
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_RETRY_MODE = "standard" /* STANDARD */;
+
+// src/DefaultRateLimiter.ts
+var import_service_error_classification = require("@smithy/service-error-classification");
+var _DefaultRateLimiter = class _DefaultRateLimiter {
+  constructor(options) {
+    // Pre-set state variables
+    this.currentCapacity = 0;
+    this.enabled = false;
+    this.lastMaxRate = 0;
+    this.measuredTxRate = 0;
+    this.requestCount = 0;
+    this.lastTimestamp = 0;
+    this.timeWindow = 0;
+    this.beta = (options == null ? void 0 : options.beta) ?? 0.7;
+    this.minCapacity = (options == null ? void 0 : options.minCapacity) ?? 1;
+    this.minFillRate = (options == null ? void 0 : options.minFillRate) ?? 0.5;
+    this.scaleConstant = (options == null ? void 0 : options.scaleConstant) ?? 0.4;
+    this.smooth = (options == null ? void 0 : options.smooth) ?? 0.8;
+    const currentTimeInSeconds = this.getCurrentTimeInSeconds();
+    this.lastThrottleTime = currentTimeInSeconds;
+    this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds());
+    this.fillRate = this.minFillRate;
+    this.maxCapacity = this.minCapacity;
+  }
+  getCurrentTimeInSeconds() {
+    return Date.now() / 1e3;
+  }
+  async getSendToken() {
+    return this.acquireTokenBucket(1);
+  }
+  async acquireTokenBucket(amount) {
+    if (!this.enabled) {
+      return;
+    }
+    this.refillTokenBucket();
+    if (amount > this.currentCapacity) {
+      const delay = (amount - this.currentCapacity) / this.fillRate * 1e3;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    this.currentCapacity = this.currentCapacity - amount;
+  }
+  refillTokenBucket() {
+    const timestamp = this.getCurrentTimeInSeconds();
+    if (!this.lastTimestamp) {
+      this.lastTimestamp = timestamp;
+      return;
+    }
+    const fillAmount = (timestamp - this.lastTimestamp) * this.fillRate;
+    this.currentCapacity = Math.min(this.maxCapacity, this.currentCapacity + fillAmount);
+    this.lastTimestamp = timestamp;
+  }
+  updateClientSendingRate(response) {
+    let calculatedRate;
+    this.updateMeasuredRate();
+    if ((0, import_service_error_classification.isThrottlingError)(response)) {
+      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);
+  }
+  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.currentCapacity = Math.min(this.currentCapacity, 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));
+  }
+};
+__name(_DefaultRateLimiter, "DefaultRateLimiter");
+var DefaultRateLimiter = _DefaultRateLimiter;
+
+// src/constants.ts
+var DEFAULT_RETRY_DELAY_BASE = 100;
+var MAXIMUM_RETRY_DELAY = 20 * 1e3;
+var THROTTLING_RETRY_DELAY_BASE = 500;
+var INITIAL_RETRY_TOKENS = 500;
+var RETRY_COST = 5;
+var TIMEOUT_RETRY_COST = 10;
+var NO_RETRY_INCREMENT = 1;
+var INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
+var REQUEST_HEADER = "amz-sdk-request";
+
+// src/defaultRetryBackoffStrategy.ts
+var getDefaultRetryBackoffStrategy = /* @__PURE__ */ __name(() => {
+  let delayBase = DEFAULT_RETRY_DELAY_BASE;
+  const computeNextBackoffDelay = /* @__PURE__ */ __name((attempts) => {
+    return Math.floor(Math.min(MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase));
+  }, "computeNextBackoffDelay");
+  const setDelayBase = /* @__PURE__ */ __name((delay) => {
+    delayBase = delay;
+  }, "setDelayBase");
+  return {
+    computeNextBackoffDelay,
+    setDelayBase
+  };
+}, "getDefaultRetryBackoffStrategy");
+
+// src/defaultRetryToken.ts
+var createDefaultRetryToken = /* @__PURE__ */ __name(({
+  retryDelay,
+  retryCount,
+  retryCost
+}) => {
+  const getRetryCount = /* @__PURE__ */ __name(() => retryCount, "getRetryCount");
+  const getRetryDelay = /* @__PURE__ */ __name(() => Math.min(MAXIMUM_RETRY_DELAY, retryDelay), "getRetryDelay");
+  const getRetryCost = /* @__PURE__ */ __name(() => retryCost, "getRetryCost");
+  return {
+    getRetryCount,
+    getRetryDelay,
+    getRetryCost
+  };
+}, "createDefaultRetryToken");
+
+// src/StandardRetryStrategy.ts
+var _StandardRetryStrategy = class _StandardRetryStrategy {
+  constructor(maxAttempts) {
+    this.maxAttempts = maxAttempts;
+    this.mode = "standard" /* STANDARD */;
+    this.capacity = INITIAL_RETRY_TOKENS;
+    this.retryBackoffStrategy = getDefaultRetryBackoffStrategy();
+    this.maxAttemptsProvider = typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts;
+  }
+  async acquireInitialRetryToken(retryTokenScope) {
+    return createDefaultRetryToken({
+      retryDelay: DEFAULT_RETRY_DELAY_BASE,
+      retryCount: 0
+    });
+  }
+  async refreshRetryTokenForRetry(token, errorInfo) {
+    const maxAttempts = await this.getMaxAttempts();
+    if (this.shouldRetry(token, errorInfo, maxAttempts)) {
+      const errorType = errorInfo.errorType;
+      this.retryBackoffStrategy.setDelayBase(
+        errorType === "THROTTLING" ? THROTTLING_RETRY_DELAY_BASE : DEFAULT_RETRY_DELAY_BASE
+      );
+      const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());
+      const retryDelay = errorInfo.retryAfterHint ? Math.max(errorInfo.retryAfterHint.getTime() - Date.now() || 0, delayFromErrorType) : delayFromErrorType;
+      const capacityCost = this.getCapacityCost(errorType);
+      this.capacity -= capacityCost;
+      return createDefaultRetryToken({
+        retryDelay,
+        retryCount: token.getRetryCount() + 1,
+        retryCost: capacityCost
+      });
+    }
+    throw new Error("No retry token available");
+  }
+  recordSuccess(token) {
+    this.capacity = Math.max(INITIAL_RETRY_TOKENS, this.capacity + (token.getRetryCost() ?? NO_RETRY_INCREMENT));
+  }
+  /**
+   * @returns the current available retry capacity.
+   *
+   * This number decreases when retries are executed and refills when requests or retries succeed.
+   */
+  getCapacity() {
+    return this.capacity;
+  }
+  async getMaxAttempts() {
+    try {
+      return await this.maxAttemptsProvider();
+    } catch (error) {
+      console.warn(`Max attempts provider could not resolve. Using default of ${DEFAULT_MAX_ATTEMPTS}`);
+      return DEFAULT_MAX_ATTEMPTS;
+    }
+  }
+  shouldRetry(tokenToRenew, errorInfo, maxAttempts) {
+    const attempts = tokenToRenew.getRetryCount() + 1;
+    return attempts < maxAttempts && this.capacity >= this.getCapacityCost(errorInfo.errorType) && this.isRetryableError(errorInfo.errorType);
+  }
+  getCapacityCost(errorType) {
+    return errorType === "TRANSIENT" ? TIMEOUT_RETRY_COST : RETRY_COST;
+  }
+  isRetryableError(errorType) {
+    return errorType === "THROTTLING" || errorType === "TRANSIENT";
+  }
+};
+__name(_StandardRetryStrategy, "StandardRetryStrategy");
+var StandardRetryStrategy = _StandardRetryStrategy;
+
+// src/AdaptiveRetryStrategy.ts
+var _AdaptiveRetryStrategy = class _AdaptiveRetryStrategy {
+  constructor(maxAttemptsProvider, options) {
+    this.maxAttemptsProvider = maxAttemptsProvider;
+    this.mode = "adaptive" /* ADAPTIVE */;
+    const { rateLimiter } = options ?? {};
+    this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
+    this.standardRetryStrategy = new StandardRetryStrategy(maxAttemptsProvider);
+  }
+  async acquireInitialRetryToken(retryTokenScope) {
+    await this.rateLimiter.getSendToken();
+    return this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
+  }
+  async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
+    this.rateLimiter.updateClientSendingRate(errorInfo);
+    return this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
+  }
+  recordSuccess(token) {
+    this.rateLimiter.updateClientSendingRate({});
+    this.standardRetryStrategy.recordSuccess(token);
+  }
+};
+__name(_AdaptiveRetryStrategy, "AdaptiveRetryStrategy");
+var AdaptiveRetryStrategy = _AdaptiveRetryStrategy;
+
+// src/ConfiguredRetryStrategy.ts
+var _ConfiguredRetryStrategy = class _ConfiguredRetryStrategy extends StandardRetryStrategy {
+  /**
+   * @param maxAttempts - the maximum number of retry attempts allowed.
+   *                      e.g., if set to 3, then 4 total requests are possible.
+   * @param computeNextBackoffDelay - a millisecond delay for each retry or a function that takes the retry attempt
+   *                                  and returns the delay.
+   *
+   * @example exponential backoff.
+   * ```js
+   * new Client({
+   *   retryStrategy: new ConfiguredRetryStrategy(3, (attempt) => attempt ** 2)
+   * });
+   * ```
+   * @example constant delay.
+   * ```js
+   * new Client({
+   *   retryStrategy: new ConfiguredRetryStrategy(3, 2000)
+   * });
+   * ```
+   */
+  constructor(maxAttempts, computeNextBackoffDelay = DEFAULT_RETRY_DELAY_BASE) {
+    super(typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts);
+    if (typeof computeNextBackoffDelay === "number") {
+      this.computeNextBackoffDelay = () => computeNextBackoffDelay;
+    } else {
+      this.computeNextBackoffDelay = computeNextBackoffDelay;
+    }
+  }
+  async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
+    const token = await super.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
+    token.getRetryDelay = () => this.computeNextBackoffDelay(token.getRetryCount());
+    return token;
+  }
+};
+__name(_ConfiguredRetryStrategy, "ConfiguredRetryStrategy");
+var ConfiguredRetryStrategy = _ConfiguredRetryStrategy;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdaptiveRetryStrategy,
+  ConfiguredRetryStrategy,
+  DEFAULT_MAX_ATTEMPTS,
+  DEFAULT_RETRY_DELAY_BASE,
+  DEFAULT_RETRY_MODE,
+  DefaultRateLimiter,
+  INITIAL_RETRY_TOKENS,
+  INVOCATION_ID_HEADER,
+  MAXIMUM_RETRY_DELAY,
+  NO_RETRY_INCREMENT,
+  REQUEST_HEADER,
+  RETRY_COST,
+  RETRY_MODES,
+  StandardRetryStrategy,
+  THROTTLING_RETRY_DELAY_BASE,
+  TIMEOUT_RETRY_COST
+});

package/node_modules/@smithy/util-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/util-retry/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@smithy/util-retry",
-  "version": "2.0.9",
+  "version": "2.1.0",
   "description": "Shared retry utilities to be used in middleware packages.",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
   "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 util-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",
@@ -27,8 +27,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@smithy/service-error-classification": "^2.0.9",
-    "@smithy/types": "^2.8.0",
+    "@smithy/service-error-classification": "^2.1.0",
+    "@smithy/types": "^2.9.0",
     "tslib": "^2.5.0"
   },
   "devDependencies": {

package/node_modules/@smithy/util-stream/dist-cjs/blob/Uint8ArrayBlobAdapter.js

@@ -1,22 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Uint8ArrayBlobAdapter = void 0;
-const transforms_1 = require("./transforms");
-class Uint8ArrayBlobAdapter extends Uint8Array {
-    static fromString(source, encoding = "utf-8") {
-        switch (typeof source) {
-            case "string":
-                return (0, transforms_1.transformFromString)(source, encoding);
-            default:
-                throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
-        }
-    }
-    static mutate(source) {
-        Object.setPrototypeOf(source, Uint8ArrayBlobAdapter.prototype);
-        return source;
-    }
-    transformToString(encoding = "utf-8") {
-        return (0, transforms_1.transformToString)(this, encoding);
-    }
-}
-exports.Uint8ArrayBlobAdapter = Uint8ArrayBlobAdapter;
+module.exports = require("../index.js");

package/node_modules/@smithy/util-stream/dist-cjs/blob/transforms.js

@@ -1,20 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFromString = exports.transformToString = void 0;
-const util_base64_1 = require("@smithy/util-base64");
-const util_utf8_1 = require("@smithy/util-utf8");
-const Uint8ArrayBlobAdapter_1 = require("./Uint8ArrayBlobAdapter");
-function transformToString(payload, encoding = "utf-8") {
-    if (encoding === "base64") {
-        return (0, util_base64_1.toBase64)(payload);
-    }
-    return (0, util_utf8_1.toUtf8)(payload);
-}
-exports.transformToString = transformToString;
-function transformFromString(str, encoding) {
-    if (encoding === "base64") {
-        return Uint8ArrayBlobAdapter_1.Uint8ArrayBlobAdapter.mutate((0, util_base64_1.fromBase64)(str));
-    }
-    return Uint8ArrayBlobAdapter_1.Uint8ArrayBlobAdapter.mutate((0, util_utf8_1.fromUtf8)(str));
-}
-exports.transformFromString = transformFromString;
+module.exports = require("../index.js");

package/node_modules/@smithy/util-stream/dist-cjs/index.js

@@ -1,6 +1,87 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./blob/Uint8ArrayBlobAdapter"), exports);
-tslib_1.__exportStar(require("./getAwsChunkedEncodingStream"), exports);
-tslib_1.__exportStar(require("./sdk-stream-mixin"), 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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Uint8ArrayBlobAdapter: () => Uint8ArrayBlobAdapter
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/blob/transforms.ts
+var import_util_base64 = require("@smithy/util-base64");
+var import_util_utf8 = require("@smithy/util-utf8");
+function transformToString(payload, encoding = "utf-8") {
+  if (encoding === "base64") {
+    return (0, import_util_base64.toBase64)(payload);
+  }
+  return (0, import_util_utf8.toUtf8)(payload);
+}
+__name(transformToString, "transformToString");
+function transformFromString(str, encoding) {
+  if (encoding === "base64") {
+    return Uint8ArrayBlobAdapter.mutate((0, import_util_base64.fromBase64)(str));
+  }
+  return Uint8ArrayBlobAdapter.mutate((0, import_util_utf8.fromUtf8)(str));
+}
+__name(transformFromString, "transformFromString");
+
+// src/blob/Uint8ArrayBlobAdapter.ts
+var _Uint8ArrayBlobAdapter = class _Uint8ArrayBlobAdapter extends Uint8Array {
+  /**
+   * @param source - such as a string or Stream.
+   * @returns a new Uint8ArrayBlobAdapter extending Uint8Array.
+   */
+  static fromString(source, encoding = "utf-8") {
+    switch (typeof source) {
+      case "string":
+        return transformFromString(source, encoding);
+      default:
+        throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
+    }
+  }
+  /**
+   * @param source - Uint8Array to be mutated.
+   * @returns the same Uint8Array but with prototype switched to Uint8ArrayBlobAdapter.
+   */
+  static mutate(source) {
+    Object.setPrototypeOf(source, _Uint8ArrayBlobAdapter.prototype);
+    return source;
+  }
+  /**
+   * @param encoding - default 'utf-8'.
+   * @returns the blob as string.
+   */
+  transformToString(encoding = "utf-8") {
+    return transformToString(this, encoding);
+  }
+};
+__name(_Uint8ArrayBlobAdapter, "Uint8ArrayBlobAdapter");
+var Uint8ArrayBlobAdapter = _Uint8ArrayBlobAdapter;
+
+// src/index.ts
+__reExport(src_exports, require("././getAwsChunkedEncodingStream"), module.exports);
+__reExport(src_exports, require("././sdk-stream-mixin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Uint8ArrayBlobAdapter,
+  ...require("././getAwsChunkedEncodingStream"),
+  ...require("././sdk-stream-mixin")
+});

package/node_modules/@smithy/util-stream/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@smithy/util-stream",
-  "version": "2.0.24",
+  "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 util-stream",
     "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",
@@ -24,17 +24,17 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@smithy/fetch-http-handler": "^2.3.2",
-    "@smithy/node-http-handler": "^2.2.2",
-    "@smithy/types": "^2.8.0",
-    "@smithy/util-base64": "^2.0.1",
-    "@smithy/util-buffer-from": "^2.0.0",
-    "@smithy/util-hex-encoding": "^2.0.0",
-    "@smithy/util-utf8": "^2.0.2",
+    "@smithy/fetch-http-handler": "^2.4.0",
+    "@smithy/node-http-handler": "^2.3.0",
+    "@smithy/types": "^2.9.0",
+    "@smithy/util-base64": "^2.1.0",
+    "@smithy/util-buffer-from": "^2.1.0",
+    "@smithy/util-hex-encoding": "^2.1.0",
+    "@smithy/util-utf8": "^2.1.0",
     "tslib": "^2.5.0"
   },
   "devDependencies": {
-    "@smithy/util-test": "^0.1.12",
+    "@smithy/util-test": "^0.1.13",
     "@types/chai-as-promised": "^7.1.2",
     "@types/node": "^14.14.31",
     "chai": "^4.2.0",

package/node_modules/@smithy/util-uri-escape/dist-cjs/escape-uri-path.js

@@ -1,6 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeUriPath = void 0;
-const escape_uri_1 = require("./escape-uri");
-const escapeUriPath = (uri) => uri.split("/").map(escape_uri_1.escapeUri).join("/");
-exports.escapeUriPath = escapeUriPath;
+module.exports = require("./index.js");

package/node_modules/@smithy/util-uri-escape/dist-cjs/escape-uri.js

@@ -1,6 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeUri = void 0;
-const escapeUri = (uri) => encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode);
-exports.escapeUri = escapeUri;
-const hexEncode = (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
+module.exports = require("./index.js");

package/node_modules/@smithy/util-uri-escape/dist-cjs/index.js

@@ -1,5 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./escape-uri"), exports);
-tslib_1.__exportStar(require("./escape-uri-path"), 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, {
+  escapeUri: () => escapeUri,
+  escapeUriPath: () => escapeUriPath
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/escape-uri.ts
+var escapeUri = /* @__PURE__ */ __name((uri) => (
+  // AWS percent-encodes some extra non-standard characters in a URI
+  encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode)
+), "escapeUri");
+var hexEncode = /* @__PURE__ */ __name((c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`, "hexEncode");
+
+// src/escape-uri-path.ts
+var escapeUriPath = /* @__PURE__ */ __name((uri) => uri.split("/").map(escapeUri).join("/"), "escapeUriPath");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  escapeUri,
+  escapeUriPath
+});

package/node_modules/@smithy/util-uri-escape/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@smithy/util-uri-escape",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build:es": "tsc -p tsconfig.es.json",
-    "build:types": "tsc -p tsconfig.types.json",
+    "build:cjs": "node ../../scripts/inline util-uri-escape",
+    "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",
     "stage-release": "rimraf ./.release && yarn pack && mkdir ./.release && tar zxvf ./package.tgz --directory ./.release && rm ./package.tgz",
-    "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo",
+    "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo || exit 0",
     "lint": "eslint -c ../../.eslintrc.js \"src/**/*.ts\"",
     "format": "prettier --config ../../prettier.config.js --ignore-path ../.prettierignore --write \"**/*.{ts,md,json}\"",
-    "test": "jest"
+    "test": "yarn g:jest"
   },
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -47,10 +47,8 @@
     "@tsconfig/recommended": "1.0.1",
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",
-    "jest": "28.1.1",
     "rimraf": "3.0.2",
-    "typedoc": "0.23.23",
-    "typescript": "~4.9.5"
+    "typedoc": "0.23.23"
   },
   "typedoc": {
     "entryPoint": "src/index.ts"