@cdk8s/awscdk-resolver 0.0.562 → 0.0.564

package/node_modules/@smithy/core/dist-cjs/util-identity-and-auth/httpAuthSchemes/httpApiKeyAuth.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpApiKeyAuthSigner = void 0;
-const protocol_http_1 = require("@smithy/protocol-http");
+const protocols_1 = require("@smithy/core/protocols");
 const types_1 = require("@smithy/types");
 class HttpApiKeyAuthSigner {
     async sign(httpRequest, identity, signingProperties) {
@@ -17,7 +17,7 @@ class HttpApiKeyAuthSigner {
         if (!identity.apiKey) {
             throw new Error("request could not be signed with `apiKey` since the `apiKey` is not defined");
         }
-        const clonedRequest = protocol_http_1.HttpRequest.clone(httpRequest);
+        const clonedRequest = protocols_1.HttpRequest.clone(httpRequest);
         if (signingProperties.in === types_1.HttpApiKeyAuthLocation.QUERY) {
             clonedRequest.query[signingProperties.name] = identity.apiKey;
         }

package/node_modules/@smithy/core/dist-cjs/util-identity-and-auth/httpAuthSchemes/httpBearerAuth.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpBearerAuthSigner = void 0;
-const protocol_http_1 = require("@smithy/protocol-http");
+const protocols_1 = require("@smithy/core/protocols");
 class HttpBearerAuthSigner {
     async sign(httpRequest, identity, signingProperties) {
-        const clonedRequest = protocol_http_1.HttpRequest.clone(httpRequest);
+        const clonedRequest = protocols_1.HttpRequest.clone(httpRequest);
         if (!identity.token) {
             throw new Error("request could not be signed with `token` since the `token` is not defined");
         }

package/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/httpAuthSchemeMiddleware.js

@@ -1,4 +1,4 @@
-import { getSmithyContext } from "@smithy/util-middleware";
+import { getSmithyContext } from "@smithy/core/client";
 import { resolveAuthOptions } from "./resolveAuthOptions";
 function convertHttpAuthSchemesToMap(httpAuthSchemes) {
     const map = new Map();

package/node_modules/@smithy/core/dist-es/middleware-http-signing/httpSigningMiddleware.js

@@ -1,5 +1,5 @@
-import { HttpRequest } from "@smithy/protocol-http";
-import { getSmithyContext } from "@smithy/util-middleware";
+import { getSmithyContext } from "@smithy/core/client";
+import { HttpRequest } from "@smithy/core/protocols";
 const defaultErrorHandler = (signingProperties) => (error) => {
     throw error;
 };

package/node_modules/@smithy/core/dist-es/submodules/cbor/CborCodec.js

@@ -1,8 +1,6 @@
 import { SerdeContext } from "@smithy/core/protocols";
 import { NormalizedSchema } from "@smithy/core/schema";
-import { _parseEpochTimestamp, generateIdempotencyToken } from "@smithy/core/serde";
-import { NumericValue } from "@smithy/core/serde";
-import { fromBase64 } from "@smithy/util-base64";
+import { NumericValue, _parseEpochTimestamp, fromBase64, generateIdempotencyToken } from "@smithy/core/serde";
 import { cbor } from "./cbor";
 import { dateToTag } from "./parseCborBody";
 export class CborCodec extends SerdeContext {

package/node_modules/@smithy/core/dist-es/submodules/cbor/SmithyRpcV2CborProtocol.js

@@ -1,7 +1,6 @@
+import { getSmithyContext } from "@smithy/core/client";
 import { RpcProtocol } from "@smithy/core/protocols";
-import { TypeRegistry } from "@smithy/core/schema";
-import { deref, NormalizedSchema } from "@smithy/core/schema";
-import { getSmithyContext } from "@smithy/util-middleware";
+import { NormalizedSchema, TypeRegistry, deref } from "@smithy/core/schema";
 import { CborCodec } from "./CborCodec";
 import { loadSmithyRpcV2CborErrorCode } from "./parseCborBody";
 export class SmithyRpcV2CborProtocol extends RpcProtocol {

package/node_modules/@smithy/core/dist-es/submodules/cbor/cbor-decode.js

@@ -1,5 +1,4 @@
-import { nv } from "@smithy/core/serde";
-import { toUtf8 } from "@smithy/util-utf8";
+import { nv, toUtf8 } from "@smithy/core/serde";
 import { alloc, extendedFloat16, extendedFloat32, extendedFloat64, extendedOneByte, majorList, majorMap, majorNegativeInt64, majorTag, majorUint64, majorUnstructuredByteString, majorUtf8String, minorIndefinite, specialFalse, specialNull, specialTrue, specialUndefined, tag, } from "./cbor-types";
 const USE_TEXT_DECODER = typeof TextDecoder !== "undefined";
 const USE_BUFFER = typeof Buffer !== "undefined";

package/node_modules/@smithy/core/dist-es/submodules/cbor/cbor-encode.js

@@ -1,5 +1,4 @@
-import { NumericValue } from "@smithy/core/serde";
-import { fromUtf8 } from "@smithy/util-utf8";
+import { NumericValue, fromUtf8 } from "@smithy/core/serde";
 import { alloc, extendedFloat16, extendedFloat32, extendedFloat64, majorList, majorMap, majorNegativeInt64, majorSpecial, majorTag, majorUint64, majorUnstructuredByteString, majorUtf8String, specialFalse, specialNull, specialTrue, tagSymbol, } from "./cbor-types";
 const USE_BUFFER = typeof Buffer !== "undefined";
 const initialSize = 2048;

package/node_modules/@smithy/core/dist-es/submodules/cbor/parseCborBody.js

@@ -1,6 +1,5 @@
-import { collectBody } from "@smithy/core/protocols";
-import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { HttpRequest as __HttpRequest, collectBody } from "@smithy/core/protocols";
+import { calculateBodyLength } from "@smithy/core/serde";
 import { cbor } from "./cbor";
 import { tag } from "./cbor-types";
 export const parseCborBody = (streamBody, context) => {

package/node_modules/@smithy/core/dist-es/submodules/checksum/chunked-blob-reader/chunked-blob-reader.js

@@ -0,0 +1,9 @@
+export async function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
+    const size = blob.size;
+    let totalBytesRead = 0;
+    while (totalBytesRead < size) {
+        const slice = blob.slice(totalBytesRead, Math.min(size, totalBytesRead + chunkSize));
+        onChunk(new Uint8Array(await slice.arrayBuffer()));
+        totalBytesRead += slice.size;
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/checksum/chunked-blob-reader/chunked-blob-reader.native.js

@@ -0,0 +1,27 @@
+import { fromBase64 } from "@smithy/core/serde";
+export function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
+    return new Promise((resolve, reject) => {
+        const fileReader = new FileReader();
+        fileReader.onerror = reject;
+        fileReader.onabort = reject;
+        const size = blob.size;
+        let totalBytesRead = 0;
+        const read = () => {
+            if (totalBytesRead >= size) {
+                resolve();
+                return;
+            }
+            fileReader.readAsDataURL(blob.slice(totalBytesRead, Math.min(size, totalBytesRead + chunkSize)));
+        };
+        fileReader.onload = (event) => {
+            const result = event.target.result;
+            const dataOffset = result.indexOf(",") + 1;
+            const data = result.substring(dataOffset);
+            const decoded = fromBase64(data);
+            onChunk(decoded);
+            totalBytesRead += decoded.byteLength;
+            read();
+        };
+        read();
+    });
+}

package/node_modules/@smithy/core/dist-es/submodules/checksum/hash-blob-browser/blobHasher.js

@@ -0,0 +1,8 @@
+import { blobReader } from "../chunked-blob-reader/chunked-blob-reader";
+export const blobHasher = async function blobHasher(hashCtor, blob) {
+    const hash = new hashCtor();
+    await blobReader(blob, (chunk) => {
+        hash.update(chunk);
+    });
+    return hash.digest();
+};

package/node_modules/@smithy/core/dist-es/submodules/checksum/hash-stream-node/HashCalculator.js

@@ -0,0 +1,18 @@
+import { Writable } from "node:stream";
+import { toUint8Array } from "@smithy/core/serde";
+export class HashCalculator extends Writable {
+    hash;
+    constructor(hash, options) {
+        super(options);
+        this.hash = hash;
+    }
+    _write(chunk, encoding, callback) {
+        try {
+            this.hash.update(toUint8Array(chunk));
+        }
+        catch (err) {
+            return callback(err);
+        }
+        callback();
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/checksum/hash-stream-node/fileStreamHasher.js

@@ -0,0 +1,24 @@
+import { createReadStream } from "node:fs";
+import { HashCalculator } from "./HashCalculator";
+export const fileStreamHasher = (hashCtor, fileStream) => new Promise((resolve, reject) => {
+    if (!isReadStream(fileStream)) {
+        reject(new Error("Unable to calculate hash for non-file streams."));
+        return;
+    }
+    const fileStreamTee = createReadStream(fileStream.path, {
+        start: fileStream.start,
+        end: fileStream.end,
+    });
+    const hash = new hashCtor();
+    const hashCalculator = new HashCalculator(hash);
+    fileStreamTee.pipe(hashCalculator);
+    fileStreamTee.on("error", (err) => {
+        hashCalculator.end();
+        reject(err);
+    });
+    hashCalculator.on("error", reject);
+    hashCalculator.on("finish", function () {
+        hash.digest().then(resolve).catch(reject);
+    });
+});
+const isReadStream = (stream) => typeof stream.path === "string";

package/node_modules/@smithy/core/dist-es/submodules/checksum/hash-stream-node/readableStreamHasher.js

@@ -0,0 +1,19 @@
+import { HashCalculator } from "./HashCalculator";
+export const readableStreamHasher = (hashCtor, readableStream) => {
+    if (readableStream.readableFlowing !== null) {
+        throw new Error("Unable to calculate hash for flowing readable stream");
+    }
+    const hash = new hashCtor();
+    const hashCalculator = new HashCalculator(hash);
+    readableStream.pipe(hashCalculator);
+    return new Promise((resolve, reject) => {
+        readableStream.on("error", (err) => {
+            hashCalculator.end();
+            reject(err);
+        });
+        hashCalculator.on("error", reject);
+        hashCalculator.on("finish", () => {
+            hash.digest().then(resolve).catch(reject);
+        });
+    });
+};

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

@@ -0,0 +1,6 @@
+const no = Symbol.for("node-only");
+export { blobHasher } from "./hash-blob-browser/blobHasher";
+export const fileStreamHasher = no;
+export const readableStreamHasher = no;
+export { Md5 } from "./md5-js/md5";
+export { blobReader } from "./chunked-blob-reader/chunked-blob-reader";

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

@@ -0,0 +1,5 @@
+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 { blobReader } from "./chunked-blob-reader/chunked-blob-reader";

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

@@ -0,0 +1,6 @@
+const no = Symbol.for("node-only");
+export { blobHasher } from "./hash-blob-browser/blobHasher";
+export const fileStreamHasher = no;
+export const readableStreamHasher = no;
+export { Md5 } from "./md5-js/md5";
+export { blobReader } from "./chunked-blob-reader/chunked-blob-reader.native";

package/node_modules/@smithy/core/dist-es/submodules/checksum/md5-js/constants.js

@@ -0,0 +1,3 @@
+export const BLOCK_SIZE = 64;
+export const DIGEST_LENGTH = 16;
+export const INIT = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476];

package/node_modules/@smithy/core/dist-es/submodules/checksum/md5-js/md5.js

@@ -0,0 +1,168 @@
+import { fromUtf8 } from "@smithy/core/serde";
+import { BLOCK_SIZE, DIGEST_LENGTH, INIT } from "./constants";
+export class Md5 {
+    state;
+    buffer;
+    bufferLength;
+    bytesHashed;
+    finished;
+    constructor() {
+        this.reset();
+    }
+    update(sourceData) {
+        if (isEmptyData(sourceData)) {
+            return;
+        }
+        else if (this.finished) {
+            throw new Error("Attempted to update an already finished hash.");
+        }
+        const data = convertToBuffer(sourceData);
+        let position = 0;
+        let { byteLength } = data;
+        this.bytesHashed += byteLength;
+        while (byteLength > 0) {
+            this.buffer.setUint8(this.bufferLength++, data[position++]);
+            byteLength--;
+            if (this.bufferLength === BLOCK_SIZE) {
+                this.hashBuffer();
+                this.bufferLength = 0;
+            }
+        }
+    }
+    async digest() {
+        if (!this.finished) {
+            const { buffer, bufferLength: undecoratedLength, bytesHashed } = this;
+            const bitsHashed = bytesHashed * 8;
+            buffer.setUint8(this.bufferLength++, 0b10000000);
+            if (undecoratedLength % BLOCK_SIZE >= BLOCK_SIZE - 8) {
+                for (let i = this.bufferLength; i < BLOCK_SIZE; i++) {
+                    buffer.setUint8(i, 0);
+                }
+                this.hashBuffer();
+                this.bufferLength = 0;
+            }
+            for (let i = this.bufferLength; i < BLOCK_SIZE - 8; i++) {
+                buffer.setUint8(i, 0);
+            }
+            buffer.setUint32(BLOCK_SIZE - 8, bitsHashed >>> 0, true);
+            buffer.setUint32(BLOCK_SIZE - 4, Math.floor(bitsHashed / 0x100000000), true);
+            this.hashBuffer();
+            this.finished = true;
+        }
+        const out = new DataView(new ArrayBuffer(DIGEST_LENGTH));
+        for (let i = 0; i < 4; i++) {
+            out.setUint32(i * 4, this.state[i], true);
+        }
+        return new Uint8Array(out.buffer, out.byteOffset, out.byteLength);
+    }
+    hashBuffer() {
+        const { buffer, state } = this;
+        let a = state[0], b = state[1], c = state[2], d = state[3];
+        a = ff(a, b, c, d, buffer.getUint32(0, true), 7, 0xd76aa478);
+        d = ff(d, a, b, c, buffer.getUint32(4, true), 12, 0xe8c7b756);
+        c = ff(c, d, a, b, buffer.getUint32(8, true), 17, 0x242070db);
+        b = ff(b, c, d, a, buffer.getUint32(12, true), 22, 0xc1bdceee);
+        a = ff(a, b, c, d, buffer.getUint32(16, true), 7, 0xf57c0faf);
+        d = ff(d, a, b, c, buffer.getUint32(20, true), 12, 0x4787c62a);
+        c = ff(c, d, a, b, buffer.getUint32(24, true), 17, 0xa8304613);
+        b = ff(b, c, d, a, buffer.getUint32(28, true), 22, 0xfd469501);
+        a = ff(a, b, c, d, buffer.getUint32(32, true), 7, 0x698098d8);
+        d = ff(d, a, b, c, buffer.getUint32(36, true), 12, 0x8b44f7af);
+        c = ff(c, d, a, b, buffer.getUint32(40, true), 17, 0xffff5bb1);
+        b = ff(b, c, d, a, buffer.getUint32(44, true), 22, 0x895cd7be);
+        a = ff(a, b, c, d, buffer.getUint32(48, true), 7, 0x6b901122);
+        d = ff(d, a, b, c, buffer.getUint32(52, true), 12, 0xfd987193);
+        c = ff(c, d, a, b, buffer.getUint32(56, true), 17, 0xa679438e);
+        b = ff(b, c, d, a, buffer.getUint32(60, true), 22, 0x49b40821);
+        a = gg(a, b, c, d, buffer.getUint32(4, true), 5, 0xf61e2562);
+        d = gg(d, a, b, c, buffer.getUint32(24, true), 9, 0xc040b340);
+        c = gg(c, d, a, b, buffer.getUint32(44, true), 14, 0x265e5a51);
+        b = gg(b, c, d, a, buffer.getUint32(0, true), 20, 0xe9b6c7aa);
+        a = gg(a, b, c, d, buffer.getUint32(20, true), 5, 0xd62f105d);
+        d = gg(d, a, b, c, buffer.getUint32(40, true), 9, 0x02441453);
+        c = gg(c, d, a, b, buffer.getUint32(60, true), 14, 0xd8a1e681);
+        b = gg(b, c, d, a, buffer.getUint32(16, true), 20, 0xe7d3fbc8);
+        a = gg(a, b, c, d, buffer.getUint32(36, true), 5, 0x21e1cde6);
+        d = gg(d, a, b, c, buffer.getUint32(56, true), 9, 0xc33707d6);
+        c = gg(c, d, a, b, buffer.getUint32(12, true), 14, 0xf4d50d87);
+        b = gg(b, c, d, a, buffer.getUint32(32, true), 20, 0x455a14ed);
+        a = gg(a, b, c, d, buffer.getUint32(52, true), 5, 0xa9e3e905);
+        d = gg(d, a, b, c, buffer.getUint32(8, true), 9, 0xfcefa3f8);
+        c = gg(c, d, a, b, buffer.getUint32(28, true), 14, 0x676f02d9);
+        b = gg(b, c, d, a, buffer.getUint32(48, true), 20, 0x8d2a4c8a);
+        a = hh(a, b, c, d, buffer.getUint32(20, true), 4, 0xfffa3942);
+        d = hh(d, a, b, c, buffer.getUint32(32, true), 11, 0x8771f681);
+        c = hh(c, d, a, b, buffer.getUint32(44, true), 16, 0x6d9d6122);
+        b = hh(b, c, d, a, buffer.getUint32(56, true), 23, 0xfde5380c);
+        a = hh(a, b, c, d, buffer.getUint32(4, true), 4, 0xa4beea44);
+        d = hh(d, a, b, c, buffer.getUint32(16, true), 11, 0x4bdecfa9);
+        c = hh(c, d, a, b, buffer.getUint32(28, true), 16, 0xf6bb4b60);
+        b = hh(b, c, d, a, buffer.getUint32(40, true), 23, 0xbebfbc70);
+        a = hh(a, b, c, d, buffer.getUint32(52, true), 4, 0x289b7ec6);
+        d = hh(d, a, b, c, buffer.getUint32(0, true), 11, 0xeaa127fa);
+        c = hh(c, d, a, b, buffer.getUint32(12, true), 16, 0xd4ef3085);
+        b = hh(b, c, d, a, buffer.getUint32(24, true), 23, 0x04881d05);
+        a = hh(a, b, c, d, buffer.getUint32(36, true), 4, 0xd9d4d039);
+        d = hh(d, a, b, c, buffer.getUint32(48, true), 11, 0xe6db99e5);
+        c = hh(c, d, a, b, buffer.getUint32(60, true), 16, 0x1fa27cf8);
+        b = hh(b, c, d, a, buffer.getUint32(8, true), 23, 0xc4ac5665);
+        a = ii(a, b, c, d, buffer.getUint32(0, true), 6, 0xf4292244);
+        d = ii(d, a, b, c, buffer.getUint32(28, true), 10, 0x432aff97);
+        c = ii(c, d, a, b, buffer.getUint32(56, true), 15, 0xab9423a7);
+        b = ii(b, c, d, a, buffer.getUint32(20, true), 21, 0xfc93a039);
+        a = ii(a, b, c, d, buffer.getUint32(48, true), 6, 0x655b59c3);
+        d = ii(d, a, b, c, buffer.getUint32(12, true), 10, 0x8f0ccc92);
+        c = ii(c, d, a, b, buffer.getUint32(40, true), 15, 0xffeff47d);
+        b = ii(b, c, d, a, buffer.getUint32(4, true), 21, 0x85845dd1);
+        a = ii(a, b, c, d, buffer.getUint32(32, true), 6, 0x6fa87e4f);
+        d = ii(d, a, b, c, buffer.getUint32(60, true), 10, 0xfe2ce6e0);
+        c = ii(c, d, a, b, buffer.getUint32(24, true), 15, 0xa3014314);
+        b = ii(b, c, d, a, buffer.getUint32(52, true), 21, 0x4e0811a1);
+        a = ii(a, b, c, d, buffer.getUint32(16, true), 6, 0xf7537e82);
+        d = ii(d, a, b, c, buffer.getUint32(44, true), 10, 0xbd3af235);
+        c = ii(c, d, a, b, buffer.getUint32(8, true), 15, 0x2ad7d2bb);
+        b = ii(b, c, d, a, buffer.getUint32(36, true), 21, 0xeb86d391);
+        state[0] = (a + state[0]) & 0xffffffff;
+        state[1] = (b + state[1]) & 0xffffffff;
+        state[2] = (c + state[2]) & 0xffffffff;
+        state[3] = (d + state[3]) & 0xffffffff;
+    }
+    reset() {
+        this.state = Uint32Array.from(INIT);
+        this.buffer = new DataView(new ArrayBuffer(BLOCK_SIZE));
+        this.bufferLength = 0;
+        this.bytesHashed = 0;
+        this.finished = false;
+    }
+}
+function cmn(q, a, b, x, s, t) {
+    a = (((a + q) & 0xffffffff) + ((x + t) & 0xffffffff)) & 0xffffffff;
+    return (((a << s) | (a >>> (32 - s))) + b) & 0xffffffff;
+}
+function ff(a, b, c, d, x, s, t) {
+    return cmn((b & c) | (~b & d), a, b, x, s, t);
+}
+function gg(a, b, c, d, x, s, t) {
+    return cmn((b & d) | (c & ~d), a, b, x, s, t);
+}
+function hh(a, b, c, d, x, s, t) {
+    return cmn(b ^ c ^ d, a, b, x, s, t);
+}
+function ii(a, b, c, d, x, s, t) {
+    return cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+function isEmptyData(data) {
+    if (typeof data === "string") {
+        return data.length === 0;
+    }
+    return data.byteLength === 0;
+}
+function convertToBuffer(data) {
+    if (typeof data === "string") {
+        return fromUtf8(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+    }
+    return new Uint8Array(data);
+}

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

@@ -0,0 +1,26 @@
+export { constructStack } from "./middleware-stack/MiddlewareStack";
+export { getSmithyContext } from "./util-middleware/getSmithyContext";
+export { normalizeProvider } from "./util-middleware/normalizeProvider";
+export { invalidFunction } from "./invalid-dependency/invalidFunction";
+export { invalidProvider } from "./invalid-dependency/invalidProvider";
+export { createWaiter } from "./util-waiter/createWaiter";
+export { waiterServiceDefaults, WaiterState, checkExceptions, } from "./util-waiter/waiter";
+export { Client } from "./smithy-client/client";
+export { Command } from "./smithy-client/command";
+export { SENSITIVE_STRING } from "./smithy-client/constants";
+export { createAggregatedClient } from "./smithy-client/create-aggregated-client";
+export { throwDefaultError, withBaseException } from "./smithy-client/default-error-handler";
+export { loadConfigsForDefaultMode, } from "./smithy-client/defaults-mode";
+export { emitWarningIfUnsupportedVersion } from "./smithy-client/emitWarningIfUnsupportedVersion";
+export { ServiceException, decorateServiceException, } from "./smithy-client/exceptions";
+export { getDefaultExtensionConfiguration, getDefaultClientConfiguration, resolveDefaultRuntimeConfig, } from "./smithy-client/extensions/defaultExtensionConfiguration";
+export { AlgorithmId, getChecksumConfiguration, resolveChecksumRuntimeConfig, } from "./smithy-client/extensions/checksum";
+export { getRetryConfiguration, resolveRetryRuntimeConfig, } from "./smithy-client/extensions/retry";
+export { getArrayIfSingleItem } from "./smithy-client/get-array-if-single-item";
+export { getValueFromTextNode } from "./smithy-client/get-value-from-text-node";
+export { isSerializableHeaderValue } from "./smithy-client/is-serializable-header-value";
+export { NoOpLogger } from "./smithy-client/NoOpLogger";
+export { map, convertMap, take, } from "./smithy-client/object-mapping";
+export { schemaLogFilter } from "./smithy-client/schemaLogFilter";
+export { serializeFloat, serializeDateTime } from "./smithy-client/ser-utils";
+export { _json } from "./smithy-client/serde-json";

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

@@ -0,0 +1,51 @@
+import { constructStack } from "../middleware-stack/MiddlewareStack";
+export class Client {
+    config;
+    middlewareStack = constructStack();
+    initConfig;
+    handlers;
+    constructor(config) {
+        this.config = config;
+        const { protocol, protocolSettings } = config;
+        if (protocolSettings) {
+            if (typeof protocol === "function") {
+                config.protocol = new protocol(protocolSettings);
+            }
+        }
+    }
+    send(command, optionsOrCb, cb) {
+        const options = typeof optionsOrCb !== "function" ? optionsOrCb : undefined;
+        const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
+        const useHandlerCache = options === undefined && this.config.cacheMiddleware === true;
+        let handler;
+        if (useHandlerCache) {
+            if (!this.handlers) {
+                this.handlers = new WeakMap();
+            }
+            const handlers = this.handlers;
+            if (handlers.has(command.constructor)) {
+                handler = handlers.get(command.constructor);
+            }
+            else {
+                handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
+                handlers.set(command.constructor, handler);
+            }
+        }
+        else {
+            delete this.handlers;
+            handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
+        }
+        if (callback) {
+            handler(command)
+                .then((result) => callback(null, result.output), (err) => callback(err))
+                .catch(() => { });
+        }
+        else {
+            return handler(command).then((result) => result.output);
+        }
+    }
+    destroy() {
+        this.config?.requestHandler?.destroy?.();
+        delete this.handlers;
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/client/smithy-client/command.js

@@ -0,0 +1,131 @@
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { constructStack } from "../middleware-stack/MiddlewareStack";
+import { schemaLogFilter } from "./schemaLogFilter";
+export class Command {
+    middlewareStack = constructStack();
+    schema;
+    static classBuilder() {
+        return new ClassBuilder();
+    }
+    resolveMiddlewareWithContext(clientStack, configuration, options, { middlewareFn, clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, smithyContext, additionalContext, CommandCtor, }) {
+        for (const mw of middlewareFn.bind(this)(CommandCtor, clientStack, configuration, options)) {
+            this.middlewareStack.use(mw);
+        }
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog,
+            outputFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                commandInstance: this,
+                ...smithyContext,
+            },
+            ...additionalContext,
+        };
+        const { requestHandler } = configuration;
+        let requestOptions = options ?? {};
+        if (smithyContext.eventStream) {
+            requestOptions = {
+                isEventStream: true,
+                ...requestOptions,
+            };
+        }
+        return stack.resolve((request) => requestHandler.handle(request.request, requestOptions), handlerExecutionContext);
+    }
+}
+class ClassBuilder {
+    _init = () => { };
+    _ep = {};
+    _middlewareFn = () => [];
+    _commandName = "";
+    _clientName = "";
+    _additionalContext = {};
+    _smithyContext = {};
+    _inputFilterSensitiveLog = undefined;
+    _outputFilterSensitiveLog = undefined;
+    _serializer = null;
+    _deserializer = null;
+    _operationSchema;
+    init(cb) {
+        this._init = cb;
+    }
+    ep(endpointParameterInstructions) {
+        this._ep = endpointParameterInstructions;
+        return this;
+    }
+    m(middlewareSupplier) {
+        this._middlewareFn = middlewareSupplier;
+        return this;
+    }
+    s(service, operation, smithyContext = {}) {
+        this._smithyContext = {
+            service,
+            operation,
+            ...smithyContext,
+        };
+        return this;
+    }
+    c(additionalContext = {}) {
+        this._additionalContext = additionalContext;
+        return this;
+    }
+    n(clientName, commandName) {
+        this._clientName = clientName;
+        this._commandName = commandName;
+        return this;
+    }
+    f(inputFilter = (_) => _, outputFilter = (_) => _) {
+        this._inputFilterSensitiveLog = inputFilter;
+        this._outputFilterSensitiveLog = outputFilter;
+        return this;
+    }
+    ser(serializer) {
+        this._serializer = serializer;
+        return this;
+    }
+    de(deserializer) {
+        this._deserializer = deserializer;
+        return this;
+    }
+    sc(operation) {
+        this._operationSchema = operation;
+        this._smithyContext.operationSchema = operation;
+        return this;
+    }
+    build() {
+        const closure = this;
+        let CommandRef;
+        return (CommandRef = class extends Command {
+            input;
+            static getEndpointParameterInstructions() {
+                return closure._ep;
+            }
+            constructor(...[input]) {
+                super();
+                this.input = input ?? {};
+                closure._init(this);
+                this.schema = closure._operationSchema;
+            }
+            resolveMiddleware(stack, configuration, options) {
+                const op = closure._operationSchema;
+                const input = op?.[4] ?? op?.input;
+                const output = op?.[5] ?? op?.output;
+                return this.resolveMiddlewareWithContext(stack, configuration, options, {
+                    CommandCtor: CommandRef,
+                    middlewareFn: closure._middlewareFn,
+                    clientName: closure._clientName,
+                    commandName: closure._commandName,
+                    inputFilterSensitiveLog: closure._inputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, input) : (_) => _),
+                    outputFilterSensitiveLog: closure._outputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, output) : (_) => _),
+                    smithyContext: closure._smithyContext,
+                    additionalContext: closure._additionalContext,
+                });
+            }
+            serialize = closure._serializer;
+            deserialize = closure._deserializer;
+        });
+    }
+}