@mavogel/awscdk-rootmail 0.0.334 → 0.0.336

package/node_modules/@aws-sdk/checksums/dist-cjs/submodules/sha/index.js

@@ -0,0 +1,312 @@
+const { toUint8Array, concatBytes } = require("@smithy/core/serde");
+const { createHmac, createHash } = require("node:crypto");
+const { Sha256, Sha256Js, Sha256Node } = require("@smithy/core/checksum");
+exports.Sha256 = Sha256;
+exports.Sha256Js = Sha256Js;
+exports.Sha256Node = Sha256Node;
+
+const BLOCK = 64;
+const DIGEST_LENGTH = 20;
+const INIT = new Int32Array([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]);
+const K = new Int32Array([0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6]);
+class Sha1Js {
+    digestLength = DIGEST_LENGTH;
+    state = Int32Array.from(INIT);
+    w;
+    buffer = new Uint8Array(BLOCK);
+    bufferLength = 0;
+    bytesHashed = 0;
+    finished = false;
+    inner;
+    outer;
+    constructor(secret) {
+        if (secret) {
+            const key = Sha1Js.normalizeKey(secret);
+            this.inner = new Sha1Js();
+            this.outer = new Sha1Js();
+            const pad = new Uint8Array(BLOCK * 2);
+            for (let i = 0; i < BLOCK; ++i) {
+                pad[i] = 0x36 ^ key[i];
+                pad[i + BLOCK] = 0x5c ^ key[i];
+            }
+            this.inner.update(pad.subarray(0, BLOCK));
+            this.outer.update(pad.subarray(BLOCK));
+        }
+    }
+    update(data) {
+        if (this.finished) {
+            throw new Error("Attempted to update an already finished HMAC.");
+        }
+        if (this.inner) {
+            this.inner.update(data);
+            return;
+        }
+        let pos = 0;
+        let { length } = data;
+        this.bytesHashed += length;
+        if (this.bufferLength > 0) {
+            while (length > 0 && this.bufferLength < BLOCK) {
+                this.buffer[this.bufferLength++] = data[pos++];
+                --length;
+            }
+            if (this.bufferLength === BLOCK) {
+                this.hashBuffer(this.buffer, 0);
+                this.bufferLength = 0;
+            }
+        }
+        while (length >= BLOCK) {
+            this.hashBuffer(data, pos);
+            pos += BLOCK;
+            length -= BLOCK;
+        }
+        while (length > 0) {
+            this.buffer[this.bufferLength++] = data[pos++];
+            --length;
+        }
+    }
+    async digest() {
+        if (this.inner && this.outer) {
+            if (this.finished) {
+                throw new Error("Attempted to digest an already finished HMAC.");
+            }
+            this.finished = true;
+            const innerDigest = this.inner.digestSync();
+            this.outer.update(innerDigest);
+            return this.outer.digestSync();
+        }
+        return this.digestSync();
+    }
+    reset() {
+        this.state = Int32Array.from(INIT);
+        this.buffer = new Uint8Array(BLOCK);
+        this.bufferLength = 0;
+        this.bytesHashed = 0;
+    }
+    digestSync() {
+        const state = this.state.slice();
+        const buffer = this.buffer.slice();
+        let bufferLength = this.bufferLength;
+        const bitsHi = (this.bytesHashed / 0x20000000) | 0;
+        const bitsLo = this.bytesHashed << 3;
+        buffer[bufferLength++] = 0x80;
+        if (bufferLength > BLOCK - 8) {
+            for (let i = bufferLength; i < BLOCK; ++i) {
+                buffer[i] = 0;
+            }
+            this.hashBufferWith(state, buffer, 0);
+            bufferLength = 0;
+        }
+        for (let i = bufferLength; i < BLOCK - 8; ++i) {
+            buffer[i] = 0;
+        }
+        const v = new DataView(buffer.buffer, buffer.byteOffset, BLOCK);
+        v.setUint32(BLOCK - 8, bitsHi, false);
+        v.setUint32(BLOCK - 4, bitsLo, false);
+        this.hashBufferWith(state, buffer, 0);
+        const out = new Uint8Array(DIGEST_LENGTH);
+        out[0] = (state[0] >>> 24) & 0xff;
+        out[1] = (state[0] >>> 16) & 0xff;
+        out[2] = (state[0] >>> 8) & 0xff;
+        out[3] = state[0] & 0xff;
+        out[4] = (state[1] >>> 24) & 0xff;
+        out[5] = (state[1] >>> 16) & 0xff;
+        out[6] = (state[1] >>> 8) & 0xff;
+        out[7] = state[1] & 0xff;
+        out[8] = (state[2] >>> 24) & 0xff;
+        out[9] = (state[2] >>> 16) & 0xff;
+        out[10] = (state[2] >>> 8) & 0xff;
+        out[11] = state[2] & 0xff;
+        out[12] = (state[3] >>> 24) & 0xff;
+        out[13] = (state[3] >>> 16) & 0xff;
+        out[14] = (state[3] >>> 8) & 0xff;
+        out[15] = state[3] & 0xff;
+        out[16] = (state[4] >>> 24) & 0xff;
+        out[17] = (state[4] >>> 16) & 0xff;
+        out[18] = (state[4] >>> 8) & 0xff;
+        out[19] = state[4] & 0xff;
+        return out;
+    }
+    static normalizeKey(secret) {
+        const key = toUint8Array(secret);
+        if (key.byteLength > BLOCK) {
+            const h = new Sha1Js();
+            h.update(key);
+            const digest = h.digestSync();
+            const padded = new Uint8Array(BLOCK);
+            padded.set(digest);
+            return padded;
+        }
+        const padded = new Uint8Array(BLOCK);
+        padded.set(key);
+        return padded;
+    }
+    hashBuffer(data, offset) {
+        this.hashBufferWith(this.state, data, offset);
+    }
+    hashBufferWith(state, data, offset) {
+        const w = (this.w ??= new Int32Array(80));
+        let s0 = state[0], s1 = state[1], s2 = state[2], s3 = state[3], s4 = state[4];
+        for (let t = 0; t < 16; ++t) {
+            w[t] =
+                ((data[offset + t * 4] & 0xff) << 24) |
+                    ((data[offset + t * 4 + 1] & 0xff) << 16) |
+                    ((data[offset + t * 4 + 2] & 0xff) << 8) |
+                    (data[offset + t * 4 + 3] & 0xff);
+        }
+        for (let t = 16; t < 80; ++t) {
+            const x = w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16];
+            w[t] = (x << 1) | (x >>> 31);
+        }
+        for (let t = 0; t < 80; ++t) {
+            const r = t < 20 ? 0 : t < 40 ? 1 : t < 60 ? 2 : 3;
+            const temp = (((((s0 << 5) | (s0 >>> 27)) +
+                (r === 0 ? (s1 & s2) ^ (~s1 & s3) : r === 2 ? (s1 & s2) ^ (s1 & s3) ^ (s2 & s3) : s1 ^ s2 ^ s3)) |
+                0) +
+                ((s4 + ((K[r] + w[t]) | 0)) | 0)) |
+                0;
+            s4 = s3;
+            s3 = s2;
+            s2 = (s1 << 30) | (s1 >>> 2);
+            s1 = s0;
+            s0 = temp;
+        }
+        state[0] = (state[0] + s0) | 0;
+        state[1] = (state[1] + s1) | 0;
+        state[2] = (state[2] + s2) | 0;
+        state[3] = (state[3] + s3) | 0;
+        state[4] = (state[4] + s4) | 0;
+    }
+}
+
+const hasNativeCrypto = (() => {
+    try {
+        createHash("sha1");
+        return true;
+    }
+    catch {
+        return false;
+    }
+})();
+const Sha1Node = hasNativeCrypto ? buildNativeClass() : Sha1Js;
+function buildNativeClass() {
+    return class Sha1Node {
+        digestLength = 20;
+        secret;
+        hash;
+        isHmac;
+        finished = false;
+        constructor(secret) {
+            this.secret = secret;
+            this.isHmac = !!secret;
+            this.hash = this.createHash();
+        }
+        update(data) {
+            if (this.finished) {
+                throw new Error("Attempted to update an already finished hash.");
+            }
+            this.hash.update(data);
+        }
+        async digest() {
+            let buf;
+            if (this.isHmac) {
+                this.finished = true;
+                buf = this.hash.digest();
+            }
+            else {
+                buf = this.hash.copy().digest();
+            }
+            return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+        }
+        reset() {
+            this.hash = this.createHash();
+            this.finished = false;
+        }
+        createHash() {
+            return this.secret ? createHmac("sha1", toBuffer(this.secret)) : createHash("sha1");
+        }
+    };
+}
+function toBuffer(data) {
+    if (typeof data === "string") {
+        return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+        return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return Buffer.from(data);
+}
+
+const { digest, sign, importKey } = globalThis?.crypto?.subtle ?? {};
+const subtle = typeof digest === "function" && typeof sign === "function" && typeof importKey === "function"
+    ? globalThis.crypto.subtle
+    : undefined;
+const MAX_PENDING_BYTES = 8 * 1024 * 1024;
+class Sha1WebCrypto {
+    digestLength = 20;
+    secret;
+    pending = [];
+    pendingBytes = 0;
+    fallback;
+    finished = false;
+    constructor(secret) {
+        if (secret) {
+            this.secret = toUint8Array(secret);
+        }
+    }
+    update(data) {
+        if (this.finished) {
+            throw new Error("Attempted to update an already finished HMAC.");
+        }
+        if (this.fallback) {
+            this.fallback.update(data);
+            return;
+        }
+        this.pending.push(data.slice());
+        this.pendingBytes += data.byteLength;
+        if (this.pendingBytes >= MAX_PENDING_BYTES) {
+            this.switchToFallback();
+        }
+    }
+    async digest() {
+        if (this.fallback) {
+            return this.fallback.digest();
+        }
+        if (this.secret && this.finished) {
+            throw new Error("Attempted to digest an already finished HMAC.");
+        }
+        const data = concatBytes(this.pending);
+        if (subtle) {
+            if (this.secret) {
+                this.finished = true;
+                const key = await subtle.importKey("raw", this.secret, { name: "HMAC", hash: "SHA-1" }, false, ["sign"]);
+                const sig = await subtle.sign("HMAC", key, data);
+                return new Uint8Array(sig);
+            }
+            const hash = await subtle.digest("SHA-1", data);
+            return new Uint8Array(hash);
+        }
+        const sha1 = new Sha1Js(this.secret);
+        sha1.update(data);
+        return sha1.digest();
+    }
+    reset() {
+        this.pending = [];
+        this.pendingBytes = 0;
+        this.fallback = undefined;
+        this.finished = false;
+    }
+    switchToFallback() {
+        const sha1Js = new Sha1Js(this.secret);
+        for (const chunk of this.pending) {
+            sha1Js.update(chunk);
+        }
+        this.fallback = sha1Js;
+        this.pending = [];
+        this.pendingBytes = 0;
+    }
+}
+
+exports.Sha1 = Sha1Node;
+exports.Sha1Js = Sha1Js;
+exports.Sha1Node = Sha1Node;
+exports.Sha1WebCrypto = Sha1WebCrypto;

package/node_modules/@aws-sdk/checksums/dist-es/index.js

@@ -0,0 +1,2 @@
+export { Crc64Nvme, Crc64NvmeJs, crc64NvmeCrtContainer } from "@aws-sdk/checksums/crc";
+export { ENV_REQUEST_CHECKSUM_CALCULATION, CONFIG_REQUEST_CHECKSUM_CALCULATION, NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS, ENV_RESPONSE_CHECKSUM_VALIDATION, CONFIG_RESPONSE_CHECKSUM_VALIDATION, NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS, RequestChecksumCalculation, DEFAULT_REQUEST_CHECKSUM_CALCULATION, ResponseChecksumValidation, DEFAULT_RESPONSE_CHECKSUM_VALIDATION, ChecksumAlgorithm, ChecksumLocation, DEFAULT_CHECKSUM_ALGORITHM, flexibleChecksumsMiddlewareOptions, flexibleChecksumsMiddleware, getFlexibleChecksumsPlugin, resolveFlexibleChecksumsConfig, } from "@aws-sdk/checksums/flexible-checksums";

package/node_modules/@aws-sdk/checksums/dist-es/submodules/crc/crc32c/Crc32cJs.js

@@ -0,0 +1,31 @@
+const T = new Uint32Array(256);
+for (let i = 0; i < 256; ++i) {
+    let c = i;
+    for (let j = 0; j < 8; ++j) {
+        c = c & 1 ? 0x82f63b78 ^ (c >>> 1) : c >>> 1;
+    }
+    T[i] = c >>> 0;
+}
+export class Crc32cJs {
+    digestLength = 4;
+    crc = 0xffff_ffff;
+    update(data) {
+        let crc = this.crc;
+        for (let i = 0; i < data.length; ++i) {
+            crc = (crc >>> 8) ^ T[(crc ^ data[i]) & 0xff];
+        }
+        this.crc = crc;
+    }
+    async digest() {
+        const value = (this.crc ^ 0xffff_ffff) >>> 0;
+        const out = new Uint8Array(4);
+        out[0] = value >>> 24;
+        out[1] = (value >>> 16) & 0xff;
+        out[2] = (value >>> 8) & 0xff;
+        out[3] = value & 0xff;
+        return out;
+    }
+    reset() {
+        this.crc = 0xffff_ffff;
+    }
+}

package/node_modules/@aws-sdk/checksums/dist-es/submodules/crc/crc32c/Crc32cNode.js

@@ -0,0 +1,2 @@
+import { Crc32cJs } from "./Crc32cJs";
+export const Crc32cNode = Crc32cJs;

package/node_modules/@aws-sdk/checksums/dist-es/submodules/crc/crc64-nvme/Crc64Nvme.js

@@ -0,0 +1,18 @@
+import { crc64NvmeCrtContainer } from "./crc64-nvme-crt-container";
+import { Crc64NvmeJs } from "./Crc64NvmeJs";
+export class Crc64Nvme {
+    impl;
+    constructor() {
+        const Crt = crc64NvmeCrtContainer.CrtCrc64Nvme;
+        this.impl = Crt ? new Crt() : new Crc64NvmeJs();
+    }
+    update(data) {
+        this.impl.update(data);
+    }
+    async digest() {
+        return this.impl.digest();
+    }
+    reset() {
+        this.impl.reset();
+    }
+}

package/node_modules/@aws-sdk/checksums/dist-es/submodules/crc/crc64-nvme/Crc64NvmeJs.js

@@ -0,0 +1,92 @@
+const generateCRC64NVMETable = () => {
+    const sliceLength = 8;
+    const tables = new Array(sliceLength);
+    for (let slice = 0; slice < sliceLength; slice++) {
+        const table = new Array(512);
+        for (let i = 0; i < 256; i++) {
+            let crc = BigInt(i);
+            for (let j = 0; j < 8 * (slice + 1); j++) {
+                if (crc & 1n) {
+                    crc = (crc >> 1n) ^ 0x9a6c9329ac4bc9b5n;
+                }
+                else {
+                    crc = crc >> 1n;
+                }
+            }
+            table[i * 2] = Number((crc >> 32n) & 0xffffffffn);
+            table[i * 2 + 1] = Number(crc & 0xffffffffn);
+        }
+        tables[slice] = new Uint32Array(table);
+    }
+    return tables;
+};
+let CRC64_NVME_REVERSED_TABLE;
+let t0, t1, t2, t3;
+let t4, t5, t6, t7;
+const ensureTablesInitialized = () => {
+    if (!CRC64_NVME_REVERSED_TABLE) {
+        CRC64_NVME_REVERSED_TABLE = generateCRC64NVMETable();
+        [t0, t1, t2, t3, t4, t5, t6, t7] = CRC64_NVME_REVERSED_TABLE;
+    }
+};
+export class Crc64NvmeJs {
+    c1 = 0;
+    c2 = 0;
+    constructor() {
+        ensureTablesInitialized();
+        this.reset();
+    }
+    update(data) {
+        const len = data.length;
+        let i = 0;
+        let crc1 = this.c1;
+        let crc2 = this.c2;
+        while (i + 8 <= len) {
+            const idx0 = ((crc2 ^ data[i++]) & 255) << 1;
+            const idx1 = (((crc2 >>> 8) ^ data[i++]) & 255) << 1;
+            const idx2 = (((crc2 >>> 16) ^ data[i++]) & 255) << 1;
+            const idx3 = (((crc2 >>> 24) ^ data[i++]) & 255) << 1;
+            const idx4 = ((crc1 ^ data[i++]) & 255) << 1;
+            const idx5 = (((crc1 >>> 8) ^ data[i++]) & 255) << 1;
+            const idx6 = (((crc1 >>> 16) ^ data[i++]) & 255) << 1;
+            const idx7 = (((crc1 >>> 24) ^ data[i++]) & 255) << 1;
+            crc1 = t7[idx0] ^ t6[idx1] ^ t5[idx2] ^ t4[idx3] ^ t3[idx4] ^ t2[idx5] ^ t1[idx6] ^ t0[idx7];
+            crc2 =
+                t7[idx0 + 1] ^
+                    t6[idx1 + 1] ^
+                    t5[idx2 + 1] ^
+                    t4[idx3 + 1] ^
+                    t3[idx4 + 1] ^
+                    t2[idx5 + 1] ^
+                    t1[idx6 + 1] ^
+                    t0[idx7 + 1];
+        }
+        while (i < len) {
+            const idx = ((crc2 ^ data[i]) & 255) << 1;
+            crc2 = ((crc2 >>> 8) | ((crc1 & 255) << 24)) >>> 0;
+            crc1 = (crc1 >>> 8) ^ t0[idx];
+            crc2 ^= t0[idx + 1];
+            ++i;
+        }
+        this.c1 = crc1;
+        this.c2 = crc2;
+    }
+    async digest() {
+        const c1 = this.c1 ^ 4294967295;
+        const c2 = this.c2 ^ 4294967295;
+        return new Uint8Array([
+            c1 >>> 24,
+            (c1 >>> 16) & 255,
+            (c1 >>> 8) & 255,
+            c1 & 255,
+            c2 >>> 24,
+            (c2 >>> 16) & 255,
+            (c2 >>> 8) & 255,
+            c2 & 255,
+        ]);
+    }
+    reset() {
+        this.c1 = 4294967295;
+        this.c2 = 4294967295;
+    }
+}

package/node_modules/@aws-sdk/checksums/dist-es/submodules/crc/index.browser.js

@@ -0,0 +1,6 @@
+const no = Symbol.for("node-only");
+export { Crc32cJs, Crc32cJs as Crc32c } from "./crc32c/Crc32cJs";
+export const Crc32cNode = no;
+export { Crc64NvmeJs, Crc64NvmeJs as Crc64Nvme } from "./crc64-nvme/Crc64NvmeJs";
+export { crc64NvmeCrtContainer } from "./crc64-nvme/crc64-nvme-crt-container";
+export { Crc32, Crc32Js, Crc32Node } from "@smithy/core/checksum";

package/node_modules/@aws-sdk/checksums/dist-es/submodules/crc/index.js

@@ -0,0 +1,6 @@
+export { Crc32cJs } from "./crc32c/Crc32cJs";
+export { Crc32cNode, Crc32cNode as Crc32c } from "./crc32c/Crc32cNode";
+export { Crc64Nvme } from "./crc64-nvme/Crc64Nvme";
+export { Crc64NvmeJs } from "./crc64-nvme/Crc64NvmeJs";
+export { crc64NvmeCrtContainer } from "./crc64-nvme/crc64-nvme-crt-container";
+export { Crc32, Crc32Js, Crc32Node } from "@smithy/core/checksum";

package/node_modules/@aws-sdk/checksums/dist-es/submodules/flexible-checksums/flexibleChecksumsMiddleware.js

@@ -0,0 +1,123 @@
+import { setFeature } from "@aws-sdk/core/client";
+import { HttpRequest } from "@smithy/core/protocols";
+import { createBufferedReadable } from "@smithy/core/serde";
+import { ChecksumAlgorithm, DEFAULT_CHECKSUM_ALGORITHM, RequestChecksumCalculation } from "./constants";
+import { getChecksumAlgorithmForRequest } from "./getChecksumAlgorithmForRequest";
+import { getChecksumLocationName } from "./getChecksumLocationName";
+import { hasHeader } from "./hasHeader";
+import { hasHeaderWithPrefix } from "./hasHeaderWithPrefix";
+import { isStreaming } from "./isStreaming";
+import { selectChecksumAlgorithmFunction } from "./selectChecksumAlgorithmFunction";
+import { stringHasher } from "./stringHasher";
+export const flexibleChecksumsMiddlewareOptions = {
+    name: "flexibleChecksumsMiddleware",
+    step: "build",
+    tags: ["BODY_CHECKSUM"],
+    override: true,
+};
+export const flexibleChecksumsMiddleware = (config, middlewareConfig) => (next, context) => async (args) => {
+    if (!HttpRequest.isInstance(args.request)) {
+        return next(args);
+    }
+    if (hasHeaderWithPrefix("x-amz-checksum-", args.request.headers)) {
+        return next(args);
+    }
+    const { request, input } = args;
+    const { body: requestBody, headers } = request;
+    const { base64Encoder, streamHasher } = config;
+    const { requestChecksumRequired, requestAlgorithmMember } = middlewareConfig;
+    const requestChecksumCalculation = await config.requestChecksumCalculation();
+    const requestAlgorithmMemberName = requestAlgorithmMember?.name;
+    const requestAlgorithmMemberHttpHeader = requestAlgorithmMember?.httpHeader;
+    if (requestAlgorithmMemberName && !input[requestAlgorithmMemberName]) {
+        if (requestChecksumCalculation === RequestChecksumCalculation.WHEN_SUPPORTED || requestChecksumRequired) {
+            input[requestAlgorithmMemberName] = DEFAULT_CHECKSUM_ALGORITHM;
+            if (requestAlgorithmMemberHttpHeader) {
+                headers[requestAlgorithmMemberHttpHeader] = DEFAULT_CHECKSUM_ALGORITHM;
+            }
+        }
+    }
+    const checksumAlgorithm = getChecksumAlgorithmForRequest(input, {
+        requestChecksumRequired,
+        requestAlgorithmMember: requestAlgorithmMember?.name,
+        requestChecksumCalculation,
+    });
+    let updatedBody = requestBody;
+    let updatedHeaders = headers;
+    if (checksumAlgorithm) {
+        switch (checksumAlgorithm) {
+            case ChecksumAlgorithm.CRC32:
+                setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_CRC32", "U");
+                break;
+            case ChecksumAlgorithm.CRC32C:
+                setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_CRC32C", "V");
+                break;
+            case ChecksumAlgorithm.CRC64NVME:
+                setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_CRC64", "W");
+                break;
+            case ChecksumAlgorithm.SHA1:
+                setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_SHA1", "X");
+                break;
+            case ChecksumAlgorithm.SHA256:
+                setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_SHA256", "Y");
+                break;
+        }
+        const checksumLocationName = getChecksumLocationName(checksumAlgorithm);
+        const checksumAlgorithmFn = selectChecksumAlgorithmFunction(checksumAlgorithm, config);
+        if (isStreaming(requestBody)) {
+            const { getAwsChunkedEncodingStream, bodyLengthChecker } = config;
+            updatedBody = getAwsChunkedEncodingStream(typeof config.requestStreamBufferSize === "number" && config.requestStreamBufferSize >= 8 * 1024
+                ? createBufferedReadable(requestBody, config.requestStreamBufferSize, context.logger)
+                : requestBody, {
+                base64Encoder,
+                bodyLengthChecker,
+                checksumLocationName,
+                checksumAlgorithmFn,
+                streamHasher,
+            });
+            updatedHeaders = {
+                ...headers,
+                "content-encoding": headers["content-encoding"]
+                    ? `${headers["content-encoding"]},aws-chunked`
+                    : "aws-chunked",
+                "transfer-encoding": "chunked",
+                "x-amz-decoded-content-length": headers["content-length"],
+                "x-amz-content-sha256": "STREAMING-UNSIGNED-PAYLOAD-TRAILER",
+                "x-amz-trailer": checksumLocationName,
+            };
+            delete updatedHeaders["content-length"];
+        }
+        else if (!hasHeader(checksumLocationName, headers)) {
+            const rawChecksum = await stringHasher(checksumAlgorithmFn, requestBody);
+            updatedHeaders = {
+                ...headers,
+                [checksumLocationName]: base64Encoder(rawChecksum),
+            };
+        }
+    }
+    try {
+        const result = await next({
+            ...args,
+            request: {
+                ...request,
+                headers: updatedHeaders,
+                body: updatedBody,
+            },
+        });
+        return result;
+    }
+    catch (e) {
+        if (e instanceof Error && e.name === "InvalidChunkSizeError") {
+            try {
+                if (!e.message.endsWith(".")) {
+                    e.message += ".";
+                }
+                e.message +=
+                    " Set [requestStreamBufferSize=number e.g. 65_536] in client constructor to instruct AWS SDK to buffer your input stream.";
+            }
+            catch (ignored) {
+            }
+        }
+        throw e;
+    }
+};

package/node_modules/@aws-sdk/checksums/dist-es/submodules/flexible-checksums/flexibleChecksumsResponseMiddleware.js

@@ -0,0 +1,48 @@
+import { HttpRequest } from "@smithy/core/protocols";
+import { getChecksumAlgorithmListForResponse } from "./getChecksumAlgorithmListForResponse";
+import { getChecksumLocationName } from "./getChecksumLocationName";
+import { isChecksumWithPartNumber } from "./isChecksumWithPartNumber";
+import { validateChecksumFromResponse } from "./validateChecksumFromResponse";
+export const flexibleChecksumsResponseMiddlewareOptions = {
+    name: "flexibleChecksumsResponseMiddleware",
+    toMiddleware: "deserializerMiddleware",
+    relation: "after",
+    tags: ["BODY_CHECKSUM"],
+    override: true,
+};
+export const flexibleChecksumsResponseMiddleware = (config, middlewareConfig) => (next, context) => async (args) => {
+    if (!HttpRequest.isInstance(args.request)) {
+        return next(args);
+    }
+    const input = args.input;
+    const result = await next(args);
+    const response = result.response;
+    const { requestValidationModeMember, responseAlgorithms } = middlewareConfig;
+    if (requestValidationModeMember && input[requestValidationModeMember] === "ENABLED") {
+        const { clientName, commandName } = context;
+        const customChecksumAlgorithms = Object.keys(config.checksumAlgorithms ?? {}).filter((algorithm) => {
+            const responseHeader = getChecksumLocationName(algorithm);
+            return response.headers[responseHeader] !== undefined;
+        });
+        const algoList = getChecksumAlgorithmListForResponse([
+            ...(responseAlgorithms ?? []),
+            ...customChecksumAlgorithms,
+        ]);
+        const isS3WholeObjectMultipartGetResponseChecksum = clientName === "S3Client" &&
+            commandName === "GetObjectCommand" &&
+            algoList.every((algorithm) => {
+                const responseHeader = getChecksumLocationName(algorithm);
+                const checksumFromResponse = response.headers[responseHeader];
+                return !checksumFromResponse || isChecksumWithPartNumber(checksumFromResponse);
+            });
+        if (isS3WholeObjectMultipartGetResponseChecksum) {
+            return result;
+        }
+        await validateChecksumFromResponse(response, {
+            config,
+            responseAlgorithms: algoList,
+            logger: context.logger,
+        });
+    }
+    return result;
+};

package/node_modules/@aws-sdk/checksums/dist-es/submodules/flexible-checksums/index.js

@@ -0,0 +1,6 @@
+export { ENV_REQUEST_CHECKSUM_CALCULATION, CONFIG_REQUEST_CHECKSUM_CALCULATION, NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS, } from "./NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS";
+export { ENV_RESPONSE_CHECKSUM_VALIDATION, CONFIG_RESPONSE_CHECKSUM_VALIDATION, NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS, } from "./NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS";
+export { RequestChecksumCalculation, DEFAULT_REQUEST_CHECKSUM_CALCULATION, ResponseChecksumValidation, DEFAULT_RESPONSE_CHECKSUM_VALIDATION, ChecksumAlgorithm, ChecksumLocation, DEFAULT_CHECKSUM_ALGORITHM, } from "./constants";
+export { flexibleChecksumsMiddlewareOptions, flexibleChecksumsMiddleware } from "./flexibleChecksumsMiddleware";
+export { getFlexibleChecksumsPlugin } from "./getFlexibleChecksumsPlugin";
+export { resolveFlexibleChecksumsConfig } from "./resolveFlexibleChecksumsConfig";

package/node_modules/@aws-sdk/checksums/dist-es/submodules/flexible-checksums/isStreaming.js

@@ -0,0 +1,2 @@
+import { isArrayBuffer } from "@smithy/core/serde";
+export const isStreaming = (body) => body !== undefined && typeof body !== "string" && !ArrayBuffer.isView(body) && !isArrayBuffer(body);

package/node_modules/@aws-sdk/checksums/dist-es/submodules/flexible-checksums/resolveFlexibleChecksumsConfig.js

@@ -0,0 +1,11 @@
+import { normalizeProvider } from "@smithy/core/client";
+import { DEFAULT_REQUEST_CHECKSUM_CALCULATION, DEFAULT_RESPONSE_CHECKSUM_VALIDATION } from "./constants";
+export const resolveFlexibleChecksumsConfig = (input) => {
+    const { requestChecksumCalculation, responseChecksumValidation, requestStreamBufferSize } = input;
+    return Object.assign(input, {
+        requestChecksumCalculation: normalizeProvider(requestChecksumCalculation ?? DEFAULT_REQUEST_CHECKSUM_CALCULATION),
+        responseChecksumValidation: normalizeProvider(responseChecksumValidation ?? DEFAULT_RESPONSE_CHECKSUM_VALIDATION),
+        requestStreamBufferSize: Number(requestStreamBufferSize ?? 0),
+        checksumAlgorithms: input.checksumAlgorithms ?? {},
+    });
+};