@gemeentenijmegen/webapp 1.1.2 → 1.1.4

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/index.js

@@ -34,7 +34,7 @@ __export(src_exports, {
   NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS: () => NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS,
   RequestChecksumCalculation: () => RequestChecksumCalculation,
   ResponseChecksumValidation: () => ResponseChecksumValidation,
-  S3_EXPRESS_DEFAULT_CHECKSUM_ALGORITHM: () => S3_EXPRESS_DEFAULT_CHECKSUM_ALGORITHM,
+  crc64NvmeCrtContainer: () => crc64NvmeCrtContainer,
   flexibleChecksumsMiddleware: () => flexibleChecksumsMiddleware,
   flexibleChecksumsMiddlewareOptions: () => flexibleChecksumsMiddlewareOptions,
   getFlexibleChecksumsPlugin: () => getFlexibleChecksumsPlugin,
@@ -81,6 +81,7 @@ var ChecksumAlgorithm = /* @__PURE__ */ ((ChecksumAlgorithm3) => {
   ChecksumAlgorithm3["MD5"] = "MD5";
   ChecksumAlgorithm3["CRC32"] = "CRC32";
   ChecksumAlgorithm3["CRC32C"] = "CRC32C";
+  ChecksumAlgorithm3["CRC64NVME"] = "CRC64NVME";
   ChecksumAlgorithm3["SHA1"] = "SHA1";
   ChecksumAlgorithm3["SHA256"] = "SHA256";
   return ChecksumAlgorithm3;
@@ -90,8 +91,7 @@ var ChecksumLocation = /* @__PURE__ */ ((ChecksumLocation2) => {
   ChecksumLocation2["TRAILER"] = "trailer";
   return ChecksumLocation2;
 })(ChecksumLocation || {});
-var DEFAULT_CHECKSUM_ALGORITHM = "MD5" /* MD5 */;
-var S3_EXPRESS_DEFAULT_CHECKSUM_ALGORITHM = "CRC32" /* CRC32 */;
+var DEFAULT_CHECKSUM_ALGORITHM = "CRC32" /* CRC32 */;
 
 // src/stringUnionSelector.ts
 var stringUnionSelector = /* @__PURE__ */ __name((obj, key, union, type) => {
@@ -122,6 +122,11 @@ var NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS = {
   default: DEFAULT_RESPONSE_CHECKSUM_VALIDATION
 };
 
+// src/crc64-nvme-crt-container.ts
+var crc64NvmeCrtContainer = {
+  CrtCrc64Nvme: null
+};
+
 // src/flexibleChecksumsMiddleware.ts
 var import_core = require("@aws-sdk/core");
 var import_protocol_http = require("@smithy/protocol-http");
@@ -130,6 +135,7 @@ var import_protocol_http = require("@smithy/protocol-http");
 var CLIENT_SUPPORTED_ALGORITHMS = [
   "CRC32" /* CRC32 */,
   "CRC32C" /* CRC32C */,
+  "CRC64NVME" /* CRC64NVME */,
   "SHA1" /* SHA1 */,
   "SHA256" /* SHA256 */
 ];
@@ -137,14 +143,17 @@ var PRIORITY_ORDER_ALGORITHMS = [
   "SHA256" /* SHA256 */,
   "SHA1" /* SHA1 */,
   "CRC32" /* CRC32 */,
-  "CRC32C" /* CRC32C */
+  "CRC32C" /* CRC32C */,
+  "CRC64NVME" /* CRC64NVME */
 ];
 
 // src/getChecksumAlgorithmForRequest.ts
-var getChecksumAlgorithmForRequest = /* @__PURE__ */ __name((input, { requestChecksumRequired, requestAlgorithmMember }, isS3Express) => {
-  const defaultAlgorithm = isS3Express ? S3_EXPRESS_DEFAULT_CHECKSUM_ALGORITHM : DEFAULT_CHECKSUM_ALGORITHM;
-  if (!requestAlgorithmMember || !input[requestAlgorithmMember]) {
-    return requestChecksumRequired ? defaultAlgorithm : void 0;
+var getChecksumAlgorithmForRequest = /* @__PURE__ */ __name((input, { requestChecksumRequired, requestAlgorithmMember, requestChecksumCalculation }) => {
+  if (!requestAlgorithmMember) {
+    return requestChecksumCalculation === RequestChecksumCalculation.WHEN_SUPPORTED || requestChecksumRequired ? DEFAULT_CHECKSUM_ALGORITHM : void 0;
+  }
+  if (!input[requestAlgorithmMember]) {
+    return void 0;
   }
   const checksumAlgorithm = input[requestAlgorithmMember];
   if (!CLIENT_SUPPORTED_ALGORITHMS.includes(checksumAlgorithm)) {
@@ -169,6 +178,17 @@ var hasHeader = /* @__PURE__ */ __name((header, headers) => {
   return false;
 }, "hasHeader");
 
+// src/hasHeaderWithPrefix.ts
+var hasHeaderWithPrefix = /* @__PURE__ */ __name((headerPrefix, headers) => {
+  const soughtHeaderPrefix = headerPrefix.toLowerCase();
+  for (const headerName of Object.keys(headers)) {
+    if (headerName.toLowerCase().startsWith(soughtHeaderPrefix)) {
+      return true;
+    }
+  }
+  return false;
+}, "hasHeaderWithPrefix");
+
 // src/isStreaming.ts
 var import_is_array_buffer = require("@smithy/is-array-buffer");
 var isStreaming = /* @__PURE__ */ __name((body) => body !== void 0 && typeof body !== "string" && !ArrayBuffer.isView(body) && !(0, import_is_array_buffer.isArrayBuffer)(body), "isStreaming");
@@ -176,13 +196,31 @@ var isStreaming = /* @__PURE__ */ __name((body) => body !== void 0 && typeof bod
 // src/selectChecksumAlgorithmFunction.ts
 var import_crc32c = require("@aws-crypto/crc32c");
 var import_getCrc32ChecksumAlgorithmFunction = require("././getCrc32ChecksumAlgorithmFunction");
-var selectChecksumAlgorithmFunction = /* @__PURE__ */ __name((checksumAlgorithm, config) => ({
-  ["MD5" /* MD5 */]: config.md5,
-  ["CRC32" /* CRC32 */]: (0, import_getCrc32ChecksumAlgorithmFunction.getCrc32ChecksumAlgorithmFunction)(),
-  ["CRC32C" /* CRC32C */]: import_crc32c.AwsCrc32c,
-  ["SHA1" /* SHA1 */]: config.sha1,
-  ["SHA256" /* SHA256 */]: config.sha256
-})[checksumAlgorithm], "selectChecksumAlgorithmFunction");
+var selectChecksumAlgorithmFunction = /* @__PURE__ */ __name((checksumAlgorithm, config) => {
+  switch (checksumAlgorithm) {
+    case "MD5" /* MD5 */:
+      return config.md5;
+    case "CRC32" /* CRC32 */:
+      return (0, import_getCrc32ChecksumAlgorithmFunction.getCrc32ChecksumAlgorithmFunction)();
+    case "CRC32C" /* CRC32C */:
+      return import_crc32c.AwsCrc32c;
+    case "CRC64NVME" /* CRC64NVME */:
+      if (typeof crc64NvmeCrtContainer.CrtCrc64Nvme !== "function") {
+        throw new Error(
+          `Please check whether you have installed the "@aws-sdk/crc64-nvme-crt" package explicitly. 
+You must also register the package by calling [require("@aws-sdk/crc64-nvme-crt");] or an ESM equivalent such as [import "@aws-sdk/crc64-nvme-crt";]. 
+For more information please go to https://github.com/aws/aws-sdk-js-v3#functionality-requiring-aws-common-runtime-crt`
+        );
+      }
+      return crc64NvmeCrtContainer.CrtCrc64Nvme;
+    case "SHA1" /* SHA1 */:
+      return config.sha1;
+    case "SHA256" /* SHA256 */:
+      return config.sha256;
+    default:
+      throw new Error(`Unsupported checksum algorithm: ${checksumAlgorithm}`);
+  }
+}, "selectChecksumAlgorithmFunction");
 
 // src/stringHasher.ts
 var import_util_utf8 = require("@smithy/util-utf8");
@@ -203,18 +241,29 @@ var flexibleChecksumsMiddleware = /* @__PURE__ */ __name((config, middlewareConf
   if (!import_protocol_http.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 checksumAlgorithm = getChecksumAlgorithmForRequest(
-    input,
-    {
-      requestChecksumRequired,
-      requestAlgorithmMember
-    },
-    !!context.isS3ExpressBucket
-  );
+  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) {
@@ -225,6 +274,9 @@ var flexibleChecksumsMiddleware = /* @__PURE__ */ __name((config, middlewareConf
       case "CRC32C" /* CRC32C */:
         (0, import_core.setFeature)(context, "FLEXIBLE_CHECKSUMS_REQ_CRC32C", "V");
         break;
+      case "CRC64NVME" /* CRC64NVME */:
+        (0, import_core.setFeature)(context, "FLEXIBLE_CHECKSUMS_REQ_CRC64", "W");
+        break;
       case "SHA1" /* SHA1 */:
         (0, import_core.setFeature)(context, "FLEXIBLE_CHECKSUMS_REQ_SHA1", "X");
         break;
@@ -271,6 +323,44 @@ var flexibleChecksumsMiddleware = /* @__PURE__ */ __name((config, middlewareConf
   return result;
 }, "flexibleChecksumsMiddleware");
 
+// src/flexibleChecksumsInputMiddleware.ts
+
+var flexibleChecksumsInputMiddlewareOptions = {
+  name: "flexibleChecksumsInputMiddleware",
+  toMiddleware: "serializerMiddleware",
+  relation: "before",
+  tags: ["BODY_CHECKSUM"],
+  override: true
+};
+var flexibleChecksumsInputMiddleware = /* @__PURE__ */ __name((config, middlewareConfig) => (next, context) => async (args) => {
+  const input = args.input;
+  const { requestValidationModeMember } = middlewareConfig;
+  const requestChecksumCalculation = await config.requestChecksumCalculation();
+  const responseChecksumValidation = await config.responseChecksumValidation();
+  switch (requestChecksumCalculation) {
+    case RequestChecksumCalculation.WHEN_REQUIRED:
+      (0, import_core.setFeature)(context, "FLEXIBLE_CHECKSUMS_REQ_WHEN_REQUIRED", "a");
+      break;
+    case RequestChecksumCalculation.WHEN_SUPPORTED:
+      (0, import_core.setFeature)(context, "FLEXIBLE_CHECKSUMS_REQ_WHEN_SUPPORTED", "Z");
+      break;
+  }
+  switch (responseChecksumValidation) {
+    case ResponseChecksumValidation.WHEN_REQUIRED:
+      (0, import_core.setFeature)(context, "FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED", "c");
+      break;
+    case ResponseChecksumValidation.WHEN_SUPPORTED:
+      (0, import_core.setFeature)(context, "FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED", "b");
+      break;
+  }
+  if (requestValidationModeMember && !input[requestValidationModeMember]) {
+    if (responseChecksumValidation === ResponseChecksumValidation.WHEN_SUPPORTED) {
+      input[requestValidationModeMember] = "ENABLED";
+    }
+  }
+  return next(args);
+}, "flexibleChecksumsInputMiddleware");
+
 // src/flexibleChecksumsResponseMiddleware.ts
 
 
@@ -301,9 +391,6 @@ var isChecksumWithPartNumber = /* @__PURE__ */ __name((checksum) => {
   return false;
 }, "isChecksumWithPartNumber");
 
-// src/flexibleChecksumsResponseMiddleware.ts
-var import_create_read_stream_on_buffer = require("./streams/create-read-stream-on-buffer");
-
 // src/validateChecksumFromResponse.ts
 var import_util_stream = require("@smithy/util-stream");
 
@@ -311,14 +398,23 @@ var import_util_stream = require("@smithy/util-stream");
 var getChecksum = /* @__PURE__ */ __name(async (body, { checksumAlgorithmFn, base64Encoder }) => base64Encoder(await stringHasher(checksumAlgorithmFn, body)), "getChecksum");
 
 // src/validateChecksumFromResponse.ts
-var validateChecksumFromResponse = /* @__PURE__ */ __name(async (response, { config, responseAlgorithms }) => {
+var validateChecksumFromResponse = /* @__PURE__ */ __name(async (response, { config, responseAlgorithms, logger }) => {
   const checksumAlgorithms = getChecksumAlgorithmListForResponse(responseAlgorithms);
   const { body: responseBody, headers: responseHeaders } = response;
   for (const algorithm of checksumAlgorithms) {
     const responseHeader = getChecksumLocationName(algorithm);
     const checksumFromResponse = responseHeaders[responseHeader];
     if (checksumFromResponse) {
-      const checksumAlgorithmFn = selectChecksumAlgorithmFunction(algorithm, config);
+      let checksumAlgorithmFn;
+      try {
+        checksumAlgorithmFn = selectChecksumAlgorithmFunction(algorithm, config);
+      } catch (error) {
+        if (algorithm === "CRC64NVME" /* CRC64NVME */) {
+          logger?.warn(`Skipping ${"CRC64NVME" /* CRC64NVME */} checksum validation: ${error.message}`);
+          continue;
+        }
+        throw error;
+      }
       const { base64Encoder } = config;
       if (isStreaming(responseBody)) {
         response.body = (0, import_util_stream.createChecksumStream)({
@@ -356,7 +452,6 @@ var flexibleChecksumsResponseMiddleware = /* @__PURE__ */ __name((config, middle
   const input = args.input;
   const result = await next(args);
   const response = result.response;
-  let collectedStream = void 0;
   const { requestValidationModeMember, responseAlgorithms } = middlewareConfig;
   if (requestValidationModeMember && input[requestValidationModeMember] === "ENABLED") {
     const { clientName, commandName } = context;
@@ -368,18 +463,11 @@ var flexibleChecksumsResponseMiddleware = /* @__PURE__ */ __name((config, middle
     if (isS3WholeObjectMultipartGetResponseChecksum) {
       return result;
     }
-    const isStreamingBody = isStreaming(response.body);
-    if (isStreamingBody) {
-      collectedStream = await config.streamCollector(response.body);
-      response.body = (0, import_create_read_stream_on_buffer.createReadStreamOnBuffer)(collectedStream);
-    }
-    await validateChecksumFromResponse(result.response, {
+    await validateChecksumFromResponse(response, {
       config,
-      responseAlgorithms
+      responseAlgorithms,
+      logger: context.logger
     });
-    if (isStreamingBody && collectedStream) {
-      response.body = (0, import_create_read_stream_on_buffer.createReadStreamOnBuffer)(collectedStream);
-    }
   }
   return result;
 }, "flexibleChecksumsResponseMiddleware");
@@ -388,6 +476,10 @@ var flexibleChecksumsResponseMiddleware = /* @__PURE__ */ __name((config, middle
 var getFlexibleChecksumsPlugin = /* @__PURE__ */ __name((config, middlewareConfig) => ({
   applyToStack: (clientStack) => {
     clientStack.add(flexibleChecksumsMiddleware(config, middlewareConfig), flexibleChecksumsMiddlewareOptions);
+    clientStack.addRelativeTo(
+      flexibleChecksumsInputMiddleware(config, middlewareConfig),
+      flexibleChecksumsInputMiddlewareOptions
+    );
     clientStack.addRelativeTo(
       flexibleChecksumsResponseMiddleware(config, middlewareConfig),
       flexibleChecksumsResponseMiddlewareOptions
@@ -422,7 +514,7 @@ var resolveFlexibleChecksumsConfig = /* @__PURE__ */ __name((input) => ({
   ChecksumAlgorithm,
   ChecksumLocation,
   DEFAULT_CHECKSUM_ALGORITHM,
-  S3_EXPRESS_DEFAULT_CHECKSUM_ALGORITHM,
+  crc64NvmeCrtContainer,
   flexibleChecksumsMiddlewareOptions,
   flexibleChecksumsMiddleware,
   getFlexibleChecksumsPlugin,

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-es/constants.js

@@ -13,6 +13,7 @@ export var ChecksumAlgorithm;
     ChecksumAlgorithm["MD5"] = "MD5";
     ChecksumAlgorithm["CRC32"] = "CRC32";
     ChecksumAlgorithm["CRC32C"] = "CRC32C";
+    ChecksumAlgorithm["CRC64NVME"] = "CRC64NVME";
     ChecksumAlgorithm["SHA1"] = "SHA1";
     ChecksumAlgorithm["SHA256"] = "SHA256";
 })(ChecksumAlgorithm || (ChecksumAlgorithm = {}));
@@ -21,5 +22,4 @@ export var ChecksumLocation;
     ChecksumLocation["HEADER"] = "header";
     ChecksumLocation["TRAILER"] = "trailer";
 })(ChecksumLocation || (ChecksumLocation = {}));
-export const DEFAULT_CHECKSUM_ALGORITHM = ChecksumAlgorithm.MD5;
-export const S3_EXPRESS_DEFAULT_CHECKSUM_ALGORITHM = ChecksumAlgorithm.CRC32;
+export const DEFAULT_CHECKSUM_ALGORITHM = ChecksumAlgorithm.CRC32;

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-es/crc64-nvme-crt-container.js

@@ -0,0 +1,3 @@
+export const crc64NvmeCrtContainer = {
+    CrtCrc64Nvme: null,
+};

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-es/flexibleChecksumsInputMiddleware.js

@@ -0,0 +1,37 @@
+import { setFeature } from "@aws-sdk/core";
+import { RequestChecksumCalculation, ResponseChecksumValidation } from "./constants";
+export const flexibleChecksumsInputMiddlewareOptions = {
+    name: "flexibleChecksumsInputMiddleware",
+    toMiddleware: "serializerMiddleware",
+    relation: "before",
+    tags: ["BODY_CHECKSUM"],
+    override: true,
+};
+export const flexibleChecksumsInputMiddleware = (config, middlewareConfig) => (next, context) => async (args) => {
+    const input = args.input;
+    const { requestValidationModeMember } = middlewareConfig;
+    const requestChecksumCalculation = await config.requestChecksumCalculation();
+    const responseChecksumValidation = await config.responseChecksumValidation();
+    switch (requestChecksumCalculation) {
+        case RequestChecksumCalculation.WHEN_REQUIRED:
+            setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_WHEN_REQUIRED", "a");
+            break;
+        case RequestChecksumCalculation.WHEN_SUPPORTED:
+            setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_WHEN_SUPPORTED", "Z");
+            break;
+    }
+    switch (responseChecksumValidation) {
+        case ResponseChecksumValidation.WHEN_REQUIRED:
+            setFeature(context, "FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED", "c");
+            break;
+        case ResponseChecksumValidation.WHEN_SUPPORTED:
+            setFeature(context, "FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED", "b");
+            break;
+    }
+    if (requestValidationModeMember && !input[requestValidationModeMember]) {
+        if (responseChecksumValidation === ResponseChecksumValidation.WHEN_SUPPORTED) {
+            input[requestValidationModeMember] = "ENABLED";
+        }
+    }
+    return next(args);
+};

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

@@ -1,9 +1,10 @@
 import { setFeature } from "@aws-sdk/core";
 import { HttpRequest } from "@smithy/protocol-http";
-import { ChecksumAlgorithm } from "./constants";
+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";
@@ -17,14 +18,29 @@ export const flexibleChecksumsMiddleware = (config, middlewareConfig) => (next,
     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,
-    }, !!context.isS3ExpressBucket);
+        requestAlgorithmMember: requestAlgorithmMember?.name,
+        requestChecksumCalculation,
+    });
     let updatedBody = requestBody;
     let updatedHeaders = headers;
     if (checksumAlgorithm) {
@@ -35,6 +51,9 @@ export const flexibleChecksumsMiddleware = (config, middlewareConfig) => (next,
             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;

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

@@ -2,8 +2,6 @@ import { HttpRequest } from "@smithy/protocol-http";
 import { getChecksumAlgorithmListForResponse } from "./getChecksumAlgorithmListForResponse";
 import { getChecksumLocationName } from "./getChecksumLocationName";
 import { isChecksumWithPartNumber } from "./isChecksumWithPartNumber";
-import { isStreaming } from "./isStreaming";
-import { createReadStreamOnBuffer } from "./streams/create-read-stream-on-buffer";
 import { validateChecksumFromResponse } from "./validateChecksumFromResponse";
 export const flexibleChecksumsResponseMiddlewareOptions = {
     name: "flexibleChecksumsResponseMiddleware",
@@ -19,7 +17,6 @@ export const flexibleChecksumsResponseMiddleware = (config, middlewareConfig) =>
     const input = args.input;
     const result = await next(args);
     const response = result.response;
-    let collectedStream = undefined;
     const { requestValidationModeMember, responseAlgorithms } = middlewareConfig;
     if (requestValidationModeMember && input[requestValidationModeMember] === "ENABLED") {
         const { clientName, commandName } = context;
@@ -33,18 +30,11 @@ export const flexibleChecksumsResponseMiddleware = (config, middlewareConfig) =>
         if (isS3WholeObjectMultipartGetResponseChecksum) {
             return result;
         }
-        const isStreamingBody = isStreaming(response.body);
-        if (isStreamingBody) {
-            collectedStream = await config.streamCollector(response.body);
-            response.body = createReadStreamOnBuffer(collectedStream);
-        }
-        await validateChecksumFromResponse(result.response, {
+        await validateChecksumFromResponse(response, {
             config,
             responseAlgorithms,
+            logger: context.logger,
         });
-        if (isStreamingBody && collectedStream) {
-            response.body = createReadStreamOnBuffer(collectedStream);
-        }
     }
     return result;
 };

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-es/getChecksumAlgorithmForRequest.js

@@ -1,9 +1,13 @@
-import { DEFAULT_CHECKSUM_ALGORITHM, S3_EXPRESS_DEFAULT_CHECKSUM_ALGORITHM } from "./constants";
+import { DEFAULT_CHECKSUM_ALGORITHM, RequestChecksumCalculation } from "./constants";
 import { CLIENT_SUPPORTED_ALGORITHMS } from "./types";
-export const getChecksumAlgorithmForRequest = (input, { requestChecksumRequired, requestAlgorithmMember }, isS3Express) => {
-    const defaultAlgorithm = isS3Express ? S3_EXPRESS_DEFAULT_CHECKSUM_ALGORITHM : DEFAULT_CHECKSUM_ALGORITHM;
-    if (!requestAlgorithmMember || !input[requestAlgorithmMember]) {
-        return requestChecksumRequired ? defaultAlgorithm : undefined;
+export const getChecksumAlgorithmForRequest = (input, { requestChecksumRequired, requestAlgorithmMember, requestChecksumCalculation }) => {
+    if (!requestAlgorithmMember) {
+        return requestChecksumCalculation === RequestChecksumCalculation.WHEN_SUPPORTED || requestChecksumRequired
+            ? DEFAULT_CHECKSUM_ALGORITHM
+            : undefined;
+    }
+    if (!input[requestAlgorithmMember]) {
+        return undefined;
     }
     const checksumAlgorithm = input[requestAlgorithmMember];
     if (!CLIENT_SUPPORTED_ALGORITHMS.includes(checksumAlgorithm)) {

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-es/getCrc32ChecksumAlgorithmFunction.js

@@ -2,9 +2,7 @@ import { AwsCrc32 } from "@aws-crypto/crc32";
 import { numToUint8 } from "@aws-crypto/util";
 import * as zlib from "zlib";
 class NodeCrc32 {
-    constructor() {
-        this.checksum = 0;
-    }
+    checksum = 0;
     update(data) {
         this.checksum = zlib.crc32(data, this.checksum);
     }

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-es/getFlexibleChecksumsPlugin.js

@@ -1,8 +1,10 @@
+import { flexibleChecksumsInputMiddleware, flexibleChecksumsInputMiddlewareOptions, } from "./flexibleChecksumsInputMiddleware";
 import { flexibleChecksumsMiddleware, flexibleChecksumsMiddlewareOptions, } from "./flexibleChecksumsMiddleware";
 import { flexibleChecksumsResponseMiddleware, flexibleChecksumsResponseMiddlewareOptions, } from "./flexibleChecksumsResponseMiddleware";
 export const getFlexibleChecksumsPlugin = (config, middlewareConfig) => ({
     applyToStack: (clientStack) => {
         clientStack.add(flexibleChecksumsMiddleware(config, middlewareConfig), flexibleChecksumsMiddlewareOptions);
+        clientStack.addRelativeTo(flexibleChecksumsInputMiddleware(config, middlewareConfig), flexibleChecksumsInputMiddlewareOptions);
         clientStack.addRelativeTo(flexibleChecksumsResponseMiddleware(config, middlewareConfig), flexibleChecksumsResponseMiddlewareOptions);
     },
 });

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-es/hasHeaderWithPrefix.js

@@ -0,0 +1,9 @@
+export const hasHeaderWithPrefix = (headerPrefix, headers) => {
+    const soughtHeaderPrefix = headerPrefix.toLowerCase();
+    for (const headerName of Object.keys(headers)) {
+        if (headerName.toLowerCase().startsWith(soughtHeaderPrefix)) {
+            return true;
+        }
+    }
+    return false;
+};

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

@@ -1,6 +1,7 @@
 export * from "./NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS";
 export * from "./NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS";
 export * from "./constants";
+export * from "./crc64-nvme-crt-container";
 export * from "./flexibleChecksumsMiddleware";
 export * from "./getFlexibleChecksumsPlugin";
 export * from "./resolveFlexibleChecksumsConfig";

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-es/selectChecksumAlgorithmFunction.js

@@ -1,10 +1,29 @@
 import { AwsCrc32c } from "@aws-crypto/crc32c";
 import { ChecksumAlgorithm } from "./constants";
+import { crc64NvmeCrtContainer } from "./crc64-nvme-crt-container";
 import { getCrc32ChecksumAlgorithmFunction } from "./getCrc32ChecksumAlgorithmFunction";
-export const selectChecksumAlgorithmFunction = (checksumAlgorithm, config) => ({
-    [ChecksumAlgorithm.MD5]: config.md5,
-    [ChecksumAlgorithm.CRC32]: getCrc32ChecksumAlgorithmFunction(),
-    [ChecksumAlgorithm.CRC32C]: AwsCrc32c,
-    [ChecksumAlgorithm.SHA1]: config.sha1,
-    [ChecksumAlgorithm.SHA256]: config.sha256,
-}[checksumAlgorithm]);
+export const selectChecksumAlgorithmFunction = (checksumAlgorithm, config) => {
+    switch (checksumAlgorithm) {
+        case ChecksumAlgorithm.MD5:
+            return config.md5;
+        case ChecksumAlgorithm.CRC32:
+            return getCrc32ChecksumAlgorithmFunction();
+        case ChecksumAlgorithm.CRC32C:
+            return AwsCrc32c;
+        case ChecksumAlgorithm.CRC64NVME:
+            if (typeof crc64NvmeCrtContainer.CrtCrc64Nvme !== "function") {
+                throw new Error(`Please check whether you have installed the "@aws-sdk/crc64-nvme-crt" package explicitly. \n` +
+                    `You must also register the package by calling [require("@aws-sdk/crc64-nvme-crt");] ` +
+                    `or an ESM equivalent such as [import "@aws-sdk/crc64-nvme-crt";]. \n` +
+                    "For more information please go to " +
+                    "https://github.com/aws/aws-sdk-js-v3#functionality-requiring-aws-common-runtime-crt");
+            }
+            return crc64NvmeCrtContainer.CrtCrc64Nvme;
+        case ChecksumAlgorithm.SHA1:
+            return config.sha1;
+        case ChecksumAlgorithm.SHA256:
+            return config.sha256;
+        default:
+            throw new Error(`Unsupported checksum algorithm: ${checksumAlgorithm}`);
+    }
+};

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-es/types.js

@@ -2,6 +2,7 @@ import { ChecksumAlgorithm } from "./constants";
 export const CLIENT_SUPPORTED_ALGORITHMS = [
     ChecksumAlgorithm.CRC32,
     ChecksumAlgorithm.CRC32C,
+    ChecksumAlgorithm.CRC64NVME,
     ChecksumAlgorithm.SHA1,
     ChecksumAlgorithm.SHA256,
 ];
@@ -10,4 +11,5 @@ export const PRIORITY_ORDER_ALGORITHMS = [
     ChecksumAlgorithm.SHA1,
     ChecksumAlgorithm.CRC32,
     ChecksumAlgorithm.CRC32C,
+    ChecksumAlgorithm.CRC64NVME,
 ];

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-es/validateChecksumFromResponse.js

@@ -1,17 +1,28 @@
 import { createChecksumStream } from "@smithy/util-stream";
+import { ChecksumAlgorithm } from "./constants";
 import { getChecksum } from "./getChecksum";
 import { getChecksumAlgorithmListForResponse } from "./getChecksumAlgorithmListForResponse";
 import { getChecksumLocationName } from "./getChecksumLocationName";
 import { isStreaming } from "./isStreaming";
 import { selectChecksumAlgorithmFunction } from "./selectChecksumAlgorithmFunction";
-export const validateChecksumFromResponse = async (response, { config, responseAlgorithms }) => {
+export const validateChecksumFromResponse = async (response, { config, responseAlgorithms, logger }) => {
     const checksumAlgorithms = getChecksumAlgorithmListForResponse(responseAlgorithms);
     const { body: responseBody, headers: responseHeaders } = response;
     for (const algorithm of checksumAlgorithms) {
         const responseHeader = getChecksumLocationName(algorithm);
         const checksumFromResponse = responseHeaders[responseHeader];
         if (checksumFromResponse) {
-            const checksumAlgorithmFn = selectChecksumAlgorithmFunction(algorithm, config);
+            let checksumAlgorithmFn;
+            try {
+                checksumAlgorithmFn = selectChecksumAlgorithmFunction(algorithm, config);
+            }
+            catch (error) {
+                if (algorithm === ChecksumAlgorithm.CRC64NVME) {
+                    logger?.warn(`Skipping ${ChecksumAlgorithm.CRC64NVME} checksum validation: ${error.message}`);
+                    continue;
+                }
+                throw error;
+            }
             const { base64Encoder } = config;
             if (isStreaming(responseBody)) {
                 response.body = createChecksumStream({

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-types/configuration.d.ts

@@ -1,4 +1,5 @@
-import { BodyLengthCalculator, ChecksumConstructor, Encoder, GetAwsChunkedEncodingStream, HashConstructor, StreamCollector, StreamHasher } from "@smithy/types";
+import { BodyLengthCalculator, ChecksumConstructor, Encoder, GetAwsChunkedEncodingStream, HashConstructor, Provider, StreamCollector, StreamHasher } from "@smithy/types";
+import { RequestChecksumCalculation, ResponseChecksumValidation } from "./constants";
 export interface PreviouslyResolved {
     /**
      * The function that will be used to convert binary data to a base64-encoded string.
@@ -18,6 +19,14 @@ export interface PreviouslyResolved {
      * @internal
      */
     md5: ChecksumConstructor | HashConstructor;
+    /**
+     * Determines when a checksum will be calculated for request payloads
+     */
+    requestChecksumCalculation: Provider<RequestChecksumCalculation>;
+    /**
+     * Determines when a checksum will be calculated for response payloads
+     */
+    responseChecksumValidation: Provider<ResponseChecksumValidation>;
     /**
      * A constructor for a class implementing the {@link Hash} interface that computes SHA1 hashes.
      * @internal

package/node_modules/@aws-sdk/middleware-flexible-checksums/dist-types/constants.d.ts

@@ -44,9 +44,13 @@ export declare const DEFAULT_RESPONSE_CHECKSUM_VALIDATION: "WHEN_SUPPORTED";
  * Checksum Algorithms supported by the SDK.
  */
 export declare enum ChecksumAlgorithm {
+    /**
+     * @deprecated Use {@link ChecksumAlgorithm.CRC32} instead.
+     */
     MD5 = "MD5",
     CRC32 = "CRC32",
     CRC32C = "CRC32C",
+    CRC64NVME = "CRC64NVME",
     SHA1 = "SHA1",
     SHA256 = "SHA256"
 }
@@ -60,8 +64,4 @@ export declare enum ChecksumLocation {
 /**
  * @internal
  */
-export declare const DEFAULT_CHECKSUM_ALGORITHM = ChecksumAlgorithm.MD5;
-/**
- * @internal
- */
-export declare const S3_EXPRESS_DEFAULT_CHECKSUM_ALGORITHM = ChecksumAlgorithm.CRC32;
+export declare const DEFAULT_CHECKSUM_ALGORITHM = ChecksumAlgorithm.CRC32;