@cdk8s/awscdk-resolver 0.0.613 → 0.0.615

package/node_modules/@smithy/core/dist-es/submodules/config/config-resolver/regionConfig/getInstanceMetadataRegion.js

@@ -0,0 +1,92 @@
+import { ENV_IMDS_DISABLED, IMDS_REGION_PATH, IMDS_TOKEN_PATH, X_AWS_EC2_METADATA_TOKEN, X_AWS_EC2_METADATA_TOKEN_TTL, } from "../../defaults-mode/constants";
+const TIMEOUT_MS = 1000;
+const NEG_CACHE_TTL_MS = 60_000;
+let negativeCacheUntil = 0;
+export const getInstanceMetadataRegion = async () => {
+    if (process.env[ENV_IMDS_DISABLED]) {
+        return undefined;
+    }
+    if (Date.now() < negativeCacheUntil) {
+        return undefined;
+    }
+    try {
+        const endpoint = resolveImdsEndpoint();
+        const token = (await imdsRequest({
+            ...endpoint,
+            path: IMDS_TOKEN_PATH,
+            method: "PUT",
+            headers: {
+                [X_AWS_EC2_METADATA_TOKEN_TTL]: "21600",
+            },
+        })).toString();
+        const region = (await imdsRequest({
+            ...endpoint,
+            path: IMDS_REGION_PATH,
+            method: "GET",
+            headers: {
+                [X_AWS_EC2_METADATA_TOKEN]: token,
+            },
+        }))
+            .toString()
+            .trim();
+        return region || cacheNegativeAndReturnUndefined();
+    }
+    catch {
+        return cacheNegativeAndReturnUndefined();
+    }
+};
+const cacheNegativeAndReturnUndefined = () => {
+    negativeCacheUntil = Date.now() + NEG_CACHE_TTL_MS;
+    return undefined;
+};
+const resolveImdsEndpoint = () => {
+    const envEndpoint = process.env.AWS_EC2_METADATA_SERVICE_ENDPOINT;
+    if (envEndpoint) {
+        const url = new URL(envEndpoint);
+        return {
+            hostname: url.hostname.replace(/^\[(.+)]$/, "$1"),
+            port: url.port ? Number(url.port) : undefined,
+        };
+    }
+    if (process.env.AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE === "IPv6") {
+        return { hostname: "fd00:ec2::254" };
+    }
+    return { hostname: "169.254.169.254" };
+};
+const imdsRequest = async (options) => {
+    const { request } = await import("node:http");
+    return new Promise((resolve, reject) => {
+        const req = request({
+            hostname: options.hostname,
+            port: options.port,
+            path: options.path,
+            method: options.method,
+            headers: options.headers,
+            timeout: TIMEOUT_MS,
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+        req.on("error", (err) => {
+            reject(err);
+            req.destroy();
+        });
+        req.on("timeout", () => {
+            reject(new Error("TimeoutError from instance metadata service"));
+            req.destroy();
+        });
+        req.on("response", (res) => {
+            const { statusCode = 400 } = res;
+            if (statusCode < 200 || statusCode >= 300) {
+                reject(Object.assign(new Error("Error response received from instance metadata service"), { statusCode }));
+                req.destroy();
+                return;
+            }
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                resolve(Buffer.concat(chunks));
+                req.destroy();
+            });
+        });
+        req.end();
+    });
+};

package/node_modules/@smithy/core/dist-es/submodules/config/defaults-mode/constants.js

@@ -4,3 +4,6 @@ export const AWS_DEFAULT_REGION_ENV = "AWS_DEFAULT_REGION";
 export const ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED";
 export const DEFAULTS_MODE_OPTIONS = ["in-region", "cross-region", "mobile", "standard", "legacy"];
 export const IMDS_REGION_PATH = "/latest/meta-data/placement/region";
+export const IMDS_TOKEN_PATH = "/latest/api/token";
+export const X_AWS_EC2_METADATA_TOKEN = "x-aws-ec2-metadata-token";
+export const X_AWS_EC2_METADATA_TOKEN_TTL = "x-aws-ec2-metadata-token-ttl-seconds";

package/node_modules/@smithy/core/dist-es/submodules/config/defaults-mode/resolveDefaultsModeConfig.js

@@ -1,7 +1,8 @@
 import { NODE_REGION_CONFIG_OPTIONS } from "../config-resolver/regionConfig/config";
+import { getInstanceMetadataRegion } from "../config-resolver/regionConfig/getInstanceMetadataRegion";
 import { loadConfig } from "../node-config-provider/configLoader";
 import { memoize } from "../property-provider/memoize";
-import { AWS_DEFAULT_REGION_ENV, AWS_EXECUTION_ENV, AWS_REGION_ENV, DEFAULTS_MODE_OPTIONS, ENV_IMDS_DISABLED, IMDS_REGION_PATH, } from "./constants";
+import { AWS_DEFAULT_REGION_ENV, AWS_EXECUTION_ENV, AWS_REGION_ENV, DEFAULTS_MODE_OPTIONS } from "./constants";
 import { NODE_DEFAULTS_MODE_CONFIG_OPTIONS } from "./defaultsModeConfig";
 export const resolveDefaultsModeConfig = ({ region = loadConfig(NODE_REGION_CONFIG_OPTIONS), defaultsMode = loadConfig(NODE_DEFAULTS_MODE_CONFIG_OPTIONS), } = {}) => memoize(async () => {
     const mode = typeof defaultsMode === "function" ? await defaultsMode() : defaultsMode;
@@ -40,59 +41,5 @@ const inferPhysicalRegion = async () => {
     if (process.env[AWS_EXECUTION_ENV] && (process.env[AWS_REGION_ENV] || process.env[AWS_DEFAULT_REGION_ENV])) {
         return process.env[AWS_REGION_ENV] ?? process.env[AWS_DEFAULT_REGION_ENV];
     }
-    if (!process.env[ENV_IMDS_DISABLED]) {
-        try {
-            const endpoint = await getImdsEndpoint();
-            return (await imdsHttpGet({ hostname: endpoint.hostname, path: IMDS_REGION_PATH })).toString();
-        }
-        catch (e) {
-        }
-    }
-};
-const getImdsEndpoint = async () => {
-    const envEndpoint = process.env.AWS_EC2_METADATA_SERVICE_ENDPOINT;
-    if (envEndpoint) {
-        const url = new URL(envEndpoint);
-        return { hostname: url.hostname, path: url.pathname };
-    }
-    const envMode = process.env.AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE;
-    if (envMode === "IPv6") {
-        return { hostname: "fd00:ec2::254", path: "/" };
-    }
-    return { hostname: "169.254.169.254", path: "/" };
-};
-const imdsHttpGet = async ({ hostname, path }) => {
-    const { request } = await import("node:http");
-    return new Promise((resolve, reject) => {
-        const req = request({
-            method: "GET",
-            hostname: hostname.replace(/^\[(.+)]$/, "$1"),
-            path,
-            timeout: 1000,
-            signal: AbortSignal.timeout(1000),
-        });
-        req.on("error", (err) => {
-            reject(err);
-            req.destroy();
-        });
-        req.on("timeout", () => {
-            reject(new Error("TimeoutError from instance metadata service"));
-            req.destroy();
-        });
-        req.on("response", (res) => {
-            const { statusCode = 400 } = res;
-            if (statusCode < 200 || 300 <= statusCode) {
-                reject(Object.assign(new Error("Error response received from instance metadata service"), { statusCode }));
-                req.destroy();
-                return;
-            }
-            const chunks = [];
-            res.on("data", (chunk) => chunks.push(chunk));
-            res.on("end", () => {
-                resolve(Buffer.concat(chunks));
-                req.destroy();
-            });
-        });
-        req.end();
-    });
+    return getInstanceMetadataRegion();
 };

package/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/EventStreamCodec.js

@@ -1,4 +1,4 @@
-import { Crc32 } from "@aws-crypto/crc32";
+import { Crc32 } from "@smithy/core/checksum";
 import { HeaderMarshaller } from "./HeaderMarshaller";
 import { splitMessage } from "./splitMessage";
 export class EventStreamCodec {
@@ -49,10 +49,12 @@ export class EventStreamCodec {
         const checksum = new Crc32();
         view.setUint32(0, length, false);
         view.setUint32(4, headers.byteLength, false);
-        view.setUint32(8, checksum.update(out.subarray(0, 8)).digest(), false);
+        checksum.update(out.subarray(0, 8));
+        view.setUint32(8, checksum.digestSync(), false);
         out.set(headers, 12);
         out.set(body, headers.byteLength + 12);
-        view.setUint32(length - 4, checksum.update(out.subarray(8, length - 4)).digest(), false);
+        checksum.update(out.subarray(8, length - 4));
+        view.setUint32(length - 4, checksum.digestSync(), false);
         return out;
     }
     decode(message) {

package/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/splitMessage.js

@@ -1,4 +1,4 @@
-import { Crc32 } from "@aws-crypto/crc32";
+import { Crc32 } from "@smithy/core/checksum";
 const PRELUDE_MEMBER_LENGTH = 4;
 const PRELUDE_LENGTH = PRELUDE_MEMBER_LENGTH * 2;
 const CHECKSUM_LENGTH = 4;
@@ -15,13 +15,14 @@ export function splitMessage({ byteLength, byteOffset, buffer }) {
     const headerLength = view.getUint32(PRELUDE_MEMBER_LENGTH, false);
     const expectedPreludeChecksum = view.getUint32(PRELUDE_LENGTH, false);
     const expectedMessageChecksum = view.getUint32(byteLength - CHECKSUM_LENGTH, false);
-    const checksummer = new Crc32().update(new Uint8Array(buffer, byteOffset, PRELUDE_LENGTH));
-    if (expectedPreludeChecksum !== checksummer.digest()) {
-        throw new Error(`The prelude checksum specified in the message (${expectedPreludeChecksum}) does not match the calculated CRC32 checksum (${checksummer.digest()})`);
+    const checksummer = new Crc32();
+    checksummer.update(new Uint8Array(buffer, byteOffset, PRELUDE_LENGTH));
+    if (expectedPreludeChecksum !== checksummer.digestSync()) {
+        throw new Error(`The prelude checksum specified in the message (${expectedPreludeChecksum}) does not match the calculated CRC32 checksum (${checksummer.digestSync()})`);
     }
     checksummer.update(new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH, byteLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH)));
-    if (expectedMessageChecksum !== checksummer.digest()) {
-        throw new Error(`The message checksum (${checksummer.digest()}) did not match the expected value of ${expectedMessageChecksum}`);
+    if (expectedMessageChecksum !== checksummer.digestSync()) {
+        throw new Error(`The message checksum (${checksummer.digestSync()}) did not match the expected value of ${expectedMessageChecksum}`);
     }
     return {
         headers: new DataView(buffer, byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH, headerLength),

package/node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js

@@ -1,5 +1,5 @@
 import { NormalizedSchema, TypeRegistry, translateTraits } from "@smithy/core/schema";
-import { HttpRequest, HttpResponse } from "@smithy/core/transport";
+import { HttpRequest, HttpResponse, isValidHostname } from "@smithy/core/transport";
 import { SerdeContext } from "./SerdeContext";
 export class HttpProtocol extends SerdeContext {
     options;
@@ -84,6 +84,9 @@ export class HttpProtocol extends SerdeContext {
                     hostPrefix = hostPrefix.replace(`{${name}}`, replacement);
                 }
                 request.hostname = hostPrefix + request.hostname;
+                if (!isValidHostname(request.hostname)) {
+                    throw new Error(`[${request.hostname}] is not a valid hostname.`);
+                }
             }
         }
     }

package/node_modules/@smithy/core/dist-es/submodules/serde/concatBytes.js

@@ -0,0 +1,15 @@
+export function concatBytes(arrays, length) {
+    if (length === undefined) {
+        length = 0;
+        for (const bytes of arrays) {
+            length += bytes.byteLength;
+        }
+    }
+    const result = new Uint8Array(length);
+    let offset = 0;
+    for (const buf of arrays) {
+        result.set(buf, offset);
+        offset += buf.byteLength;
+    }
+    return result;
+}

package/node_modules/@smithy/core/dist-es/submodules/serde/index.browser.js

@@ -19,6 +19,7 @@ export { toBase64, fromBase64 };
 export { calculateBodyLength } from "./util-body-length/calculateBodyLength.browser";
 export { toUint8Array } from "./util-utf8/toUint8Array.browser";
 export { toUtf8, fromUtf8 };
+export { concatBytes } from "./concatBytes";
 export const fromArrayBuffer = no;
 export const fromString = no;
 export { isArrayBuffer } from "./is-array-buffer/is-array-buffer";
@@ -36,6 +37,7 @@ export { headStream } from "./util-stream/headStream.browser";
 export { sdkStreamMixin } from "./util-stream/sdk-stream-mixin.browser";
 export { splitStream } from "./util-stream/splitStream.browser";
 export { isReadableStream, isBlob } from "./util-stream/stream-type-check";
+export { streamCollector } from "./util-stream/stream-collector.browser";
 const _getRandomValues = (array) => crypto.getRandomValues(array);
 export const v4 = bindV4(_getRandomValues);
 export const generateIdempotencyToken = v4;

package/node_modules/@smithy/core/dist-es/submodules/serde/index.js

@@ -19,6 +19,7 @@ export { toBase64, fromBase64 };
 export { calculateBodyLength } from "./util-body-length/calculateBodyLength";
 export { toUint8Array } from "./util-utf8/toUint8Array";
 export { toUtf8, fromUtf8 };
+export { concatBytes } from "./concatBytes";
 export { fromArrayBuffer, fromString } from "./util-buffer-from/buffer-from";
 export { isArrayBuffer } from "./is-array-buffer/is-array-buffer";
 export { deserializerMiddleware } from "./middleware-serde/deserializerMiddleware";
@@ -35,6 +36,7 @@ export { headStream } from "./util-stream/headStream";
 export { sdkStreamMixin } from "./util-stream/sdk-stream-mixin";
 export { splitStream } from "./util-stream/splitStream";
 export { isReadableStream, isBlob } from "./util-stream/stream-type-check";
+export { streamCollector } from "./util-stream/stream-collector";
 const _getRandomValues = getRandomValues;
 export const v4 = bindV4(_getRandomValues);
 export const generateIdempotencyToken = v4;

package/node_modules/@smithy/core/dist-es/submodules/serde/index.native.js

@@ -21,6 +21,7 @@ export { calculateBodyLength } from "./util-body-length/calculateBodyLength.brow
 export { fromUtf8 } from "./util-utf8/fromUtf8.browser";
 export { toUint8Array } from "./util-utf8/toUint8Array.browser";
 export { toUtf8 } from "./util-utf8/toUtf8.browser";
+export { concatBytes } from "./concatBytes";
 export const fromArrayBuffer = no;
 export const fromString = no;
 export { isArrayBuffer } from "./is-array-buffer/is-array-buffer";
@@ -38,6 +39,7 @@ export { headStream } from "./util-stream/headStream.browser";
 export { sdkStreamMixin } from "./util-stream/sdk-stream-mixin.browser";
 export { splitStream } from "./util-stream/splitStream.browser";
 export { isReadableStream, isBlob } from "./util-stream/stream-type-check";
+export { streamCollector } from "./util-stream/stream-collector.browser";
 const _getRandomValues = (array) => crypto.getRandomValues(array);
 export const v4 = bindV4(_getRandomValues);
 export const generateIdempotencyToken = v4;

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/ChecksumStream.js

@@ -57,4 +57,8 @@ export class ChecksumStream extends Duplex {
         this.push(null);
         return callback();
     }
+    _destroy(error, callback) {
+        this.source?.destroy();
+        callback(error);
+    }
 }

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/headStream.js

@@ -1,4 +1,5 @@
 import { Writable } from "node:stream";
+import { concatBytes } from "../concatBytes";
 import { headStream as headWebStream } from "./headStream.browser";
 import { isReadableStream } from "./stream-type-check";
 export const headStream = (stream, bytes) => {
@@ -15,7 +16,7 @@ export const headStream = (stream, bytes) => {
         });
         collector.on("error", reject);
         collector.on("finish", function () {
-            const bytes = new Uint8Array(Buffer.concat(this.buffers));
+            const bytes = concatBytes(this.buffers);
             resolve(bytes);
         });
     });

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-collector.browser.js

@@ -1,53 +1,27 @@
-import { fromBase64 } from "../util-base64/fromBase64.browser";
+import { concatBytes } from "../concatBytes";
+import { isBlob } from "./stream-type-check";
 export const streamCollector = async (stream) => {
-    if ((typeof Blob === "function" && stream instanceof Blob) || stream.constructor?.name === "Blob") {
-        if (Blob.prototype.arrayBuffer !== undefined) {
-            return new Uint8Array(await stream.arrayBuffer());
-        }
+    if (isBlob(stream)) {
         return collectBlob(stream);
     }
-    return collectStream(stream);
+    return collectReadableStream(stream);
 };
-async function collectBlob(blob) {
-    const base64 = await readToBase64(blob);
-    const arrayBuffer = fromBase64(base64);
-    return new Uint8Array(arrayBuffer);
+export async function collectBlob(blob) {
+    return blob.arrayBuffer().then((ab) => new Uint8Array(ab));
 }
-async function collectStream(stream) {
+export async function collectReadableStream(stream) {
     const chunks = [];
     const reader = stream.getReader();
-    let isDone = false;
     let length = 0;
-    while (!isDone) {
+    while (true) {
         const { done, value } = await reader.read();
         if (value) {
             chunks.push(value);
             length += value.length;
         }
-        isDone = done;
-    }
-    const collected = new Uint8Array(length);
-    let offset = 0;
-    for (const chunk of chunks) {
-        collected.set(chunk, offset);
-        offset += chunk.length;
+        if (done) {
+            break;
+        }
     }
-    return collected;
-}
-function readToBase64(blob) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onloadend = () => {
-            if (reader.readyState !== 2) {
-                return reject(new Error("Reader aborted too early"));
-            }
-            const result = (reader.result ?? "");
-            const commaIndex = result.indexOf(",");
-            const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
-            resolve(result.substring(dataOffset));
-        };
-        reader.onabort = () => reject(new Error("Read aborted"));
-        reader.onerror = () => reject(reader.error);
-        reader.readAsDataURL(blob);
-    });
+    return concatBytes(chunks, length);
 }

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-collector.js

@@ -1,48 +1,33 @@
 import { Writable } from "node:stream";
-class Collector extends Writable {
-    bufferedBytes = [];
-    _write(chunk, encoding, callback) {
-        this.bufferedBytes.push(chunk);
-        callback();
-    }
-}
-const isReadableStreamInstance = (stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream;
-async function collectReadableStream(stream) {
-    const chunks = [];
-    const reader = stream.getReader();
-    let isDone = false;
-    let length = 0;
-    while (!isDone) {
-        const { done, value } = await reader.read();
-        if (value) {
-            chunks.push(value);
-            length += value.length;
-        }
-        isDone = done;
-    }
-    const collected = new Uint8Array(length);
-    let offset = 0;
-    for (const chunk of chunks) {
-        collected.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return collected;
-}
+import { concatBytes } from "../concatBytes";
+import { collectBlob, collectReadableStream } from "./stream-collector.browser";
+import { isBlob, isReadableStream } from "./stream-type-check";
 export const streamCollector = (stream) => {
-    if (isReadableStreamInstance(stream)) {
+    if (isBlob(stream)) {
+        return collectBlob(stream);
+    }
+    if (isReadableStream(stream)) {
         return collectReadableStream(stream);
     }
     return new Promise((resolve, reject) => {
         const collector = new Collector();
-        stream.pipe(collector);
-        stream.on("error", (err) => {
+        const nodeStream = stream;
+        nodeStream.pipe(collector);
+        nodeStream.on("error", (err) => {
             collector.end();
             reject(err);
         });
         collector.on("error", reject);
         collector.on("finish", function () {
-            const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
+            const bytes = concatBytes(this.bufferedBytes);
             resolve(bytes);
         });
     });
 };
+class Collector extends Writable {
+    bufferedBytes = [];
+    _write(chunk, encoding, callback) {
+        this.bufferedBytes.push(chunk);
+        callback();
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUint8Array.browser.js

@@ -1,5 +1,8 @@
 import { fromUtf8 } from "./fromUtf8.browser";
 export const toUint8Array = (data) => {
+    if (data instanceof Uint8Array) {
+        return data;
+    }
     if (typeof data === "string") {
         return fromUtf8(data);
     }

package/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUint8Array.js

@@ -1,5 +1,8 @@
 import { fromUtf8 } from "./fromUtf8";
 export const toUint8Array = (data) => {
+    if (data instanceof Uint8Array) {
+        return data;
+    }
     if (typeof data === "string") {
         return fromUtf8(data);
     }

package/node_modules/@smithy/core/dist-types/submodules/checksum/crc32/Crc32Js.d.ts

@@ -0,0 +1,18 @@
+import type { Checksum } from "@smithy/types";
+/**
+ * Pure JS CRC-32 implementation using the IEEE 802.3 polynomial.
+ * @see https://www.w3.org/TR/png/#D-CRCAppendix
+ * @public
+ */
+export declare class Crc32Js implements Checksum {
+    readonly digestLength = 4;
+    private checksum;
+    update(data: Uint8Array): void;
+    /**
+     * Used by EventStreamCodec.
+     * @internal
+     */
+    digestSync(): number;
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+}

package/node_modules/@smithy/core/dist-types/submodules/checksum/crc32/Crc32Node.d.ts

@@ -0,0 +1,18 @@
+import type { Checksum } from "@smithy/types";
+/**
+ * CRC-32 using Node.js zlib native implementation when available,
+ * falling back to the pure JS implementation.
+ * @public
+ */
+export interface Crc32Node extends Checksum {
+    readonly digestLength: 4;
+    /**
+     * Used by EventStreamCodec.
+     * @internal
+     */
+    digestSync(): number;
+}
+/**
+ * @public
+ */
+export declare const Crc32Node: new () => Crc32Node;

package/node_modules/@smithy/core/dist-types/submodules/checksum/index.browser.d.ts

@@ -1,5 +1,11 @@
 export { blobHasher } from "./hash-blob-browser/blobHasher";
 export declare const fileStreamHasher: symbol;
 export declare const readableStreamHasher: symbol;
-export { Md5 } from "./md5-js/md5";
+export { Md5Js, Md5Js as Md5 } from "./md5/Md5Js";
+export declare const Md5Node: symbol;
+export { Crc32Js, Crc32Js as Crc32 } from "./crc32/Crc32Js";
+export declare const Crc32Node: symbol;
+export { Sha256Js } from "./sha256/Sha256Js";
+export { Sha256WebCrypto, Sha256WebCrypto as Sha256 } from "./sha256/Sha256WebCrypto";
+export declare const Sha256Node: symbol;
 export { blobReader } from "./chunked-blob-reader/chunked-blob-reader";

package/node_modules/@smithy/core/dist-types/submodules/checksum/index.d.ts

@@ -1,5 +1,11 @@
 export { blobHasher } from "./hash-blob-browser/blobHasher";
 export { fileStreamHasher } from "./hash-stream-node/fileStreamHasher";
 export { readableStreamHasher } from "./hash-stream-node/readableStreamHasher";
-export { Md5 } from "./md5-js/md5";
+export { Md5Js } from "./md5/Md5Js";
+export { Md5Node, Md5Node as Md5 } from "./md5/Md5Node";
+export { Crc32Js } from "./crc32/Crc32Js";
+export { Crc32Node, Crc32Node as Crc32 } from "./crc32/Crc32Node";
+export { Sha256Js } from "./sha256/Sha256Js";
+export { Sha256Node, Sha256Node as Sha256 } from "./sha256/Sha256Node";
+export { Sha256WebCrypto } from "./sha256/Sha256WebCrypto";
 export { blobReader } from "./chunked-blob-reader/chunked-blob-reader";

package/node_modules/@smithy/core/dist-types/submodules/checksum/index.native.d.ts

@@ -1,5 +1,11 @@
 export { blobHasher } from "./hash-blob-browser/blobHasher";
 export declare const fileStreamHasher: symbol;
 export declare const readableStreamHasher: symbol;
-export { Md5 } from "./md5-js/md5";
+export { Md5Js, Md5Js as Md5 } from "./md5/Md5Js";
+export declare const Md5Node: symbol;
+export { Crc32Js, Crc32Js as Crc32 } from "./crc32/Crc32Js";
+export declare const Crc32Node: symbol;
+export { Sha256Js } from "./sha256/Sha256Js";
+export { Sha256WebCrypto, Sha256WebCrypto as Sha256 } from "./sha256/Sha256WebCrypto";
+export declare const Sha256Node: symbol;
 export { blobReader } from "./chunked-blob-reader/chunked-blob-reader.native";

package/node_modules/@smithy/core/dist-types/submodules/checksum/md5/Md5Js.d.ts

@@ -0,0 +1,19 @@
+import type { Checksum, SourceData } from "@smithy/types";
+/**
+ * Pure-JS MD5 implementation. Used as fallback where node:crypto is unavailable.
+ *
+ * @public
+ */
+export declare class Md5Js implements Checksum {
+    readonly digestLength = 16;
+    private state;
+    private writeBuffer;
+    private bufferLength;
+    private bytesHashed;
+    update(sourceData: SourceData): void;
+    /**
+     * Non-destructive: works on copies so update() may continue after digest().
+     */
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+}

package/node_modules/@smithy/core/dist-types/submodules/checksum/md5/Md5Node.d.ts

@@ -0,0 +1,17 @@
+import type { Checksum, SourceData } from "@smithy/types";
+/**
+ * MD5 using Node.js crypto native implementation when available,
+ * falling back to the pure JS implementation.
+ * @public
+ */
+export interface Md5Node extends Checksum {
+    readonly digestLength: 16;
+    /**
+     * @override
+     */
+    update(data: SourceData): void;
+}
+/**
+ * @public
+ */
+export declare const Md5Node: new () => Md5Node;

package/node_modules/@smithy/core/dist-types/submodules/checksum/sha256/Sha256Js.d.ts

@@ -0,0 +1,28 @@
+import type { Checksum, SourceData } from "@smithy/types";
+/**
+ * Pure JS SHA-256 implementation with HMAC support.
+ * @see https://csrc.nist.gov/pubs/fips/180-4/upd1/final
+ * @public
+ */
+export declare class Sha256Js implements Checksum {
+    readonly digestLength = 32;
+    /** Eight 32-bit words representing the current hash state. */
+    private state;
+    /** Reused message schedule array (W), allocated on first use of hashBuffer. */
+    private w?;
+    /** Accumulates input bytes until a full 64-byte block is ready. */
+    private buffer;
+    private bufferLength;
+    private bytesHashed;
+    private finished;
+    private readonly inner?;
+    private readonly outer?;
+    constructor(secret?: SourceData);
+    update(data: SourceData): void;
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+    private digestSync;
+    private static normalizeKey;
+    private hashBuffer;
+    private hashBufferWith;
+}

package/node_modules/@smithy/core/dist-types/submodules/checksum/sha256/Sha256Node.d.ts

@@ -0,0 +1,13 @@
+import type { Checksum, SourceData } from "@smithy/types";
+/**
+ * SHA-256 using Node.js crypto native implementation when available,
+ * falling back to the pure JS implementation.
+ * @public
+ */
+export interface Sha256Node extends Checksum {
+    readonly digestLength: 32;
+}
+/**
+ * @public
+ */
+export declare const Sha256Node: new (secret?: SourceData) => Sha256Node;