@cdk8s/awscdk-resolver 0.0.562 → 0.0.563

package/node_modules/@smithy/util-retry/README.md

@@ -1,78 +0,0 @@
-# @smithy/util-retry
-
-[![NPM version](https://img.shields.io/npm/v/@smithy/util-retry/latest.svg)](https://www.npmjs.com/package/@smithy/util-retry)
-[![NPM downloads](https://img.shields.io/npm/dm/@smithy/util-retry.svg)](https://www.npmjs.com/package/@smithy/util-retry)
-
-This package provides shared utilities for retries.
-
-## Usage
-
-### Default
-
-By default, each client already has a default retry strategy. The default retry count is 3, and
-only retryable errors will be retried.
-
-[AWS Documentation: Retry behavior](https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html).
-
-```js
-import { S3Client } from "@aws-sdk/client-s3";
-
-const client = new S3Client({}); // default retry strategy included.
-```
-
-### MaxAttempts
-
-If you want to change the number of attempts, you can provide `maxAttempts` configuration during client creation.
-
-```js
-import { S3Client } from "@aws-sdk/client-s3";
-
-const client = new S3Client({ maxAttempts: 4 });
-```
-
-This is recommended because the `StandardRetryStrategy` includes backoff calculation,
-deciding whether an error should be retried, and a retry token counter.
-
-### MaxAttempts and BackoffComputation
-
-If you want to change the number of attempts and use a custom delay
-computation, you can use the `ConfiguredRetryStrategy` from `@smithy/util-retry`.
-
-```js
-import { S3Client } from "@aws-sdk/client-s3";
-import { ConfiguredRetryStrategy } from "@smithy/util-retry";
-
-const client = new S3Client({
-  retryStrategy: new ConfiguredRetryStrategy(
-    4, // max attempts.
-    (attempt: number) => 100 + attempt * 1000 // backoff function.
-  ),
-});
-```
-
-This example sets the backoff at 100ms plus 1s per attempt.
-
-### MaxAttempts and RetryStrategy
-
-If you provide both `maxAttempts` and `retryStrategy`, the `retryStrategy` will
-get precedence as it's more specific.
-
-```js
-import { S3Client } from "@aws-sdk/client-s3";
-import { ConfiguredRetryStrategy } from "@smithy/util-retry";
-
-const client = new S3Client({
-  maxAttempts: 2, // ignored.
-  retryStrategy: new ConfiguredRetryStrategy(
-    4, // used.
-    (attempt: number) => 100 + attempt * 1000 // backoff function.
-  ),
-});
-```
-
-### Further customization
-
-You can implement the `RetryStrategyV2` interface.
-
-Source: https://github.com/smithy-lang/smithy-typescript/blob/main/packages/types/src/retry.ts
-API Docs: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-smithy-types/Interface/RetryStrategyV2/

package/node_modules/@smithy/util-retry/dist-es/AdaptiveRetryStrategy.js

@@ -1,36 +0,0 @@
-import { RETRY_MODES } from "./config";
-import { DefaultRateLimiter } from "./DefaultRateLimiter";
-import { StandardRetryStrategy } from "./StandardRetryStrategy";
-export class AdaptiveRetryStrategy {
-    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();
-    }
-}

package/node_modules/@smithy/util-retry/dist-es/ConfiguredRetryStrategy.js

@@ -1,19 +0,0 @@
-import { Retry } from "./retries-2026-config";
-import { StandardRetryStrategy } from "./StandardRetryStrategy";
-export class ConfiguredRetryStrategy extends StandardRetryStrategy {
-    computeNextBackoffDelay;
-    constructor(maxAttempts, computeNextBackoffDelay = Retry.delay()) {
-        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;
-    }
-}

package/node_modules/@smithy/util-retry/dist-es/DefaultRateLimiter.js

@@ -1,111 +0,0 @@
-import { isThrottlingError } from "@smithy/service-error-classification";
-export class DefaultRateLimiter {
-    static setTimeoutFn = setTimeout;
-    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() / 1000;
-    }
-    async acquireTokenBucket(amount) {
-        if (!this.enabled) {
-            return;
-        }
-        this.refillTokenBucket();
-        while (amount > this.availableTokens) {
-            const delay = ((amount - this.availableTokens) / this.fillRate) * 1000;
-            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));
-    }
-}

package/node_modules/@smithy/util-retry/dist-es/StandardRetryStrategy.js

@@ -1,93 +0,0 @@
-import { DEFAULT_MAX_ATTEMPTS, RETRY_MODES } from "./config";
-import { INITIAL_RETRY_TOKENS, NO_RETRY_INCREMENT } from "./constants";
-import { DefaultRetryBackoffStrategy } from "./DefaultRetryBackoffStrategy";
-import { DefaultRetryToken } from "./DefaultRetryToken";
-import { Retry } from "./retries-2026-config";
-const refusal = {
-    incompatible: 1,
-    attempts: 2,
-    capacity: 3,
-};
-export class StandardRetryStrategy {
-    mode = RETRY_MODES.STANDARD;
-    capacity = INITIAL_RETRY_TOKENS;
-    retryBackoffStrategy;
-    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, undefined, 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 + 5_000));
-            }
-            if (!shouldRetry) {
-                throw Object.assign(new Error("No retry token available"), {
-                    $backoff: Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0,
-                });
-            }
-            else {
-                const capacityCost = this.getCapacityCost(errorType);
-                this.capacity -= capacityCost;
-                return new DefaultRetryToken(retryDelay, token.getRetryCount() + 1, capacityCost, token.isLongPoll?.() ?? false);
-            }
-        }
-        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 (error) {
-            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";
-    }
-}

package/node_modules/@smithy/util-retry/dist-types/AdaptiveRetryStrategy.d.ts

@@ -1,38 +0,0 @@
-import type { Provider, RetryErrorInfo, RetryStrategyV2, RetryToken, StandardRetryToken } from "@smithy/types";
-import type { StandardRetryStrategyOptions } from "./StandardRetryStrategy";
-import type { RateLimiter } from "./types";
-/**
- * Strategy options to be passed to AdaptiveRetryStrategy
- *
- * @public
- */
-export interface AdaptiveRetryStrategyOptions extends Partial<StandardRetryStrategyOptions> {
-    rateLimiter?: RateLimiter;
-}
-/**
- * The AdaptiveRetryStrategy is a retry strategy for executing against a very
- * resource constrained set of resources. Care should be taken when using this
- * retry strategy. By default, it uses a dynamic backoff delay based on load
- * currently perceived against the downstream resource and performs circuit
- * breaking to disable retries in the event of high downstream failures using
- * the DefaultRateLimiter.
- *
- * @public
- *
- * @see {@link StandardRetryStrategy}
- * @see {@link DefaultRateLimiter }
- */
-export declare class AdaptiveRetryStrategy implements RetryStrategyV2 {
-    readonly mode: string;
-    private rateLimiter;
-    private standardRetryStrategy;
-    constructor(maxAttemptsProvider: number | Provider<number>, options?: AdaptiveRetryStrategyOptions);
-    acquireInitialRetryToken(retryTokenScope: string): Promise<RetryToken>;
-    refreshRetryTokenForRetry(tokenToRenew: StandardRetryToken, errorInfo: RetryErrorInfo): Promise<RetryToken>;
-    recordSuccess(token: StandardRetryToken): void;
-    /**
-     * There is an existing integration which accesses this field.
-     * @deprecated
-     */
-    maxAttemptsProvider(): Promise<number>;
-}

package/node_modules/@smithy/util-retry/dist-types/constants.d.ts

@@ -1,60 +0,0 @@
-/**
- * @public
- *
- * The base number of milliseconds to use in calculating a suitable cool-down
- * time when a retryable error is encountered.
- */
-export declare const DEFAULT_RETRY_DELAY_BASE = 100;
-/**
- * @public
- *
- * The maximum amount of time (in milliseconds) that will be used as a delay
- * between retry attempts.
- */
-export declare const MAXIMUM_RETRY_DELAY: number;
-/**
- * The retry delay base (in milliseconds) to use when a throttling error is
- * encountered.
- *
- * @public
- */
-export declare const THROTTLING_RETRY_DELAY_BASE = 500;
-/**
- * Initial number of retry tokens in Retry Quota
- *
- * @public
- */
-export declare const INITIAL_RETRY_TOKENS = 500;
-/**
- * The total amount of retry tokens to be decremented from retry token balance.
- *
- * @public
- */
-export declare const RETRY_COST = 5;
-/**
- * The total amount of retry tokens to be decremented from retry token balance
- * when a throttling error is encountered.
- *
- * @public
- */
-export declare const TIMEOUT_RETRY_COST = 10;
-/**
- * The total amount of retry token to be incremented from retry token balance
- * if an SDK operation invocation succeeds without requiring a retry request.
- *
- * @public
- *
- */
-export declare const NO_RETRY_INCREMENT = 1;
-/**
- * Header name for SDK invocation ID
- *
- * @public
- */
-export declare const INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
-/**
- * Header name for request retry information.
- *
- * @public
- */
-export declare const REQUEST_HEADER = "amz-sdk-request";

package/node_modules/@smithy/util-retry/dist-types/retries-2026-config.d.ts

@@ -1,11 +0,0 @@
-/**
- * @internal
- */
-export declare abstract class Retry {
-    static v2026: boolean;
-    static delay(): 100 | 50;
-    static throttlingDelay(): 1000 | 500;
-    static cost(): 5 | 14;
-    static throttlingCost(): 5 | 10;
-    static modifiedCostType(): "TRANSIENT" | "THROTTLING";
-}

package/node_modules/@smithy/util-stream/README.md

@@ -1,6 +0,0 @@
-# @smithy/util-stream
-
-[![NPM version](https://img.shields.io/npm/v/@smithy/util-stream/latest.svg)](https://www.npmjs.com/package/@smithy/util-stream)
-[![NPM downloads](https://img.shields.io/npm/dm/@smithy/util-stream.svg)](https://www.npmjs.com/package/@smithy/util-stream)
-
-Package with utilities to operate on streams.

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

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ByteArrayCollector = void 0;
-class ByteArrayCollector {
-    allocByteArray;
-    byteLength = 0;
-    byteArrays = [];
-    constructor(allocByteArray) {
-        this.allocByteArray = allocByteArray;
-    }
-    push(byteArray) {
-        this.byteArrays.push(byteArray);
-        this.byteLength += byteArray.byteLength;
-    }
-    flush() {
-        if (this.byteArrays.length === 1) {
-            const bytes = this.byteArrays[0];
-            this.reset();
-            return bytes;
-        }
-        const aggregation = this.allocByteArray(this.byteLength);
-        let cursor = 0;
-        for (let i = 0; i < this.byteArrays.length; ++i) {
-            const bytes = this.byteArrays[i];
-            aggregation.set(bytes, cursor);
-            cursor += bytes.byteLength;
-        }
-        this.reset();
-        return aggregation;
-    }
-    reset() {
-        this.byteArrays = [];
-        this.byteLength = 0;
-    }
-}
-exports.ByteArrayCollector = ByteArrayCollector;

package/node_modules/@smithy/util-stream/dist-cjs/checksum/ChecksumStream.browser.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChecksumStream = void 0;
-const ReadableStreamRef = typeof ReadableStream === "function" ? ReadableStream : function () { };
-class ChecksumStream extends ReadableStreamRef {
-}
-exports.ChecksumStream = ChecksumStream;

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

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChecksumStream = void 0;
-const util_base64_1 = require("@smithy/util-base64");
-const stream_1 = require("stream");
-class ChecksumStream extends stream_1.Duplex {
-    expectedChecksum;
-    checksumSourceLocation;
-    checksum;
-    source;
-    base64Encoder;
-    pendingCallback = null;
-    constructor({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }) {
-        super();
-        if (typeof source.pipe === "function") {
-            this.source = source;
-        }
-        else {
-            throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);
-        }
-        this.base64Encoder = base64Encoder ?? util_base64_1.toBase64;
-        this.expectedChecksum = expectedChecksum;
-        this.checksum = checksum;
-        this.checksumSourceLocation = checksumSourceLocation;
-        this.source.pipe(this);
-    }
-    _read(size) {
-        if (this.pendingCallback) {
-            const callback = this.pendingCallback;
-            this.pendingCallback = null;
-            callback();
-        }
-    }
-    _write(chunk, encoding, callback) {
-        try {
-            this.checksum.update(chunk);
-            const canPushMore = this.push(chunk);
-            if (!canPushMore) {
-                this.pendingCallback = callback;
-                return;
-            }
-        }
-        catch (e) {
-            return callback(e);
-        }
-        return callback();
-    }
-    async _final(callback) {
-        try {
-            const digest = await this.checksum.digest();
-            const received = this.base64Encoder(digest);
-            if (this.expectedChecksum !== received) {
-                return callback(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${received}"` +
-                    ` in response header "${this.checksumSourceLocation}".`));
-            }
-        }
-        catch (e) {
-            return callback(e);
-        }
-        this.push(null);
-        return callback();
-    }
-}
-exports.ChecksumStream = ChecksumStream;

package/node_modules/@smithy/util-stream/dist-cjs/checksum/createChecksumStream.browser.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createChecksumStream = void 0;
-const util_base64_1 = require("@smithy/util-base64");
-const stream_type_check_1 = require("../stream-type-check");
-const ChecksumStream_browser_1 = require("./ChecksumStream.browser");
-const createChecksumStream = ({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }) => {
-    if (!(0, stream_type_check_1.isReadableStream)(source)) {
-        throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);
-    }
-    const encoder = base64Encoder ?? util_base64_1.toBase64;
-    if (typeof TransformStream !== "function") {
-        throw new Error("@smithy/util-stream: unable to instantiate ChecksumStream because API unavailable: ReadableStream/TransformStream.");
-    }
-    const transform = new TransformStream({
-        start() { },
-        async transform(chunk, controller) {
-            checksum.update(chunk);
-            controller.enqueue(chunk);
-        },
-        async flush(controller) {
-            const digest = await checksum.digest();
-            const received = encoder(digest);
-            if (expectedChecksum !== received) {
-                const error = new Error(`Checksum mismatch: expected "${expectedChecksum}" but received "${received}"` +
-                    ` in response header "${checksumSourceLocation}".`);
-                controller.error(error);
-            }
-            else {
-                controller.terminate();
-            }
-        },
-    });
-    source.pipeThrough(transform);
-    const readable = transform.readable;
-    Object.setPrototypeOf(readable, ChecksumStream_browser_1.ChecksumStream.prototype);
-    return readable;
-};
-exports.createChecksumStream = createChecksumStream;

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

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createChecksumStream = createChecksumStream;
-const stream_type_check_1 = require("../stream-type-check");
-const ChecksumStream_1 = require("./ChecksumStream");
-const createChecksumStream_browser_1 = require("./createChecksumStream.browser");
-function createChecksumStream(init) {
-    if (typeof ReadableStream === "function" && (0, stream_type_check_1.isReadableStream)(init.source)) {
-        return (0, createChecksumStream_browser_1.createChecksumStream)(init);
-    }
-    return new ChecksumStream_1.ChecksumStream(init);
-}