@qqbrowser/openclaw-qbot 0.10.8 → 0.10.10

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/{smithy-client/dist-es → core/dist-es/submodules/client/smithy-client}/client.js

@@ -1,4 +1,4 @@
-import { constructStack } from "@smithy/middleware-stack";
+import { constructStack } from "../middleware-stack/MiddlewareStack";
 export class Client {
     config;
     middlewareStack = constructStack();

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

@@ -1,5 +1,5 @@
-import { constructStack } from "@smithy/middleware-stack";
-import { SMITHY_CONTEXT_KEY } from "@smithy/types";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { constructStack } from "../middleware-stack/MiddlewareStack";
 import { schemaLogFilter } from "./schemaLogFilter";
 export class Command {
     middlewareStack = constructStack();

package/node_modules/@smithy/{smithy-client/dist-es → core/dist-es/submodules/client/smithy-client}/extensions/checksum.js

@@ -1,4 +1,4 @@
-import { AlgorithmId } from "@smithy/types";
+import { AlgorithmId, } from "@smithy/types";
 export { AlgorithmId };
 const knownAlgorithms = Object.values(AlgorithmId);
 export const getChecksumConfiguration = (runtimeConfig) => {

package/node_modules/@smithy/{smithy-client/dist-es → core/dist-es/submodules/client/smithy-client}/extensions/defaultExtensionConfiguration.js

@@ -1,4 +1,4 @@
-import { getChecksumConfiguration, resolveChecksumRuntimeConfig } from "./checksum";
+import { getChecksumConfiguration, resolveChecksumRuntimeConfig, } from "./checksum";
 import { getRetryConfiguration, resolveRetryRuntimeConfig } from "./retry";
 export const getDefaultExtensionConfiguration = (runtimeConfig) => {
     return Object.assign(getChecksumConfiguration(runtimeConfig), getRetryConfiguration(runtimeConfig));

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

@@ -0,0 +1,12 @@
+export const getCircularReplacer = () => {
+    const seen = new WeakSet();
+    return (key, value) => {
+        if (typeof value === "object" && value !== null) {
+            if (seen.has(value)) {
+                return "[Circular]";
+            }
+            seen.add(value);
+        }
+        return value;
+    };
+};

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

@@ -0,0 +1,48 @@
+import { runPolling } from "./poller";
+import { validateWaiterOptions } from "./utils/validate";
+import { WaiterState, waiterServiceDefaults } from "./waiter";
+const abortTimeout = (abortSignal) => {
+    let onAbort;
+    const promise = new Promise((resolve) => {
+        onAbort = () => resolve({ state: WaiterState.ABORTED });
+        if (typeof abortSignal.addEventListener === "function") {
+            abortSignal.addEventListener("abort", onAbort);
+        }
+        else {
+            abortSignal.onabort = onAbort;
+        }
+    });
+    return {
+        clearListener() {
+            if (typeof abortSignal.removeEventListener === "function") {
+                abortSignal.removeEventListener("abort", onAbort);
+            }
+        },
+        aborted: promise,
+    };
+};
+export const createWaiter = async (options, input, acceptorChecks) => {
+    const params = {
+        ...waiterServiceDefaults,
+        ...options,
+    };
+    validateWaiterOptions(params);
+    const exitConditions = [runPolling(params, input, acceptorChecks)];
+    const finalize = [];
+    if (options.abortSignal) {
+        const { aborted, clearListener } = abortTimeout(options.abortSignal);
+        finalize.push(clearListener);
+        exitConditions.push(aborted);
+    }
+    if (options.abortController?.signal) {
+        const { aborted, clearListener } = abortTimeout(options.abortController.signal);
+        finalize.push(clearListener);
+        exitConditions.push(aborted);
+    }
+    return Promise.race(exitConditions).then((result) => {
+        for (const fn of finalize) {
+            fn();
+        }
+        return result;
+    });
+};

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

@@ -0,0 +1,87 @@
+import { getCircularReplacer } from "./circularReplacer";
+import { sleep } from "./utils/sleep";
+import { WaiterState } from "./waiter";
+export const runPolling = async ({ minDelay, maxDelay, maxWaitTime, abortController, client, abortSignal }, input, acceptorChecks) => {
+    const observedResponses = {};
+    const [minDelayMs, maxDelayMs] = [minDelay * 1000, maxDelay * 1000];
+    let currentAttempt = 0;
+    const waitUntil = Date.now() + maxWaitTime * 1000;
+    const warn403Time = Date.now() + 60_000;
+    let didWarn403 = false;
+    while (true) {
+        if (currentAttempt > 0) {
+            const delayMs = exponentialBackoffWithJitter(minDelayMs, maxDelayMs, currentAttempt, waitUntil);
+            if (abortController?.signal?.aborted || abortSignal?.aborted) {
+                const message = "AbortController signal aborted.";
+                observedResponses[message] |= 0;
+                observedResponses[message] += 1;
+                return { state: WaiterState.ABORTED, observedResponses };
+            }
+            if (Date.now() + delayMs > waitUntil) {
+                return { state: WaiterState.TIMEOUT, observedResponses };
+            }
+            await sleep(delayMs / 1_000);
+        }
+        const { state, reason } = await acceptorChecks(client, input);
+        if (reason) {
+            const message = createMessageFromResponse(reason);
+            observedResponses[message] |= 0;
+            observedResponses[message] += 1;
+        }
+        if (state !== WaiterState.RETRY) {
+            return { state, reason, final: reason, observedResponses };
+        }
+        currentAttempt += 1;
+        if (!didWarn403 && Date.now() >= warn403Time) {
+            checkWarn403(observedResponses, client);
+            didWarn403 = true;
+        }
+    }
+};
+const checkWarn403 = (observedResponses = {}, client) => {
+    const orderedErrors = Object.keys(observedResponses);
+    let maxCount = 0;
+    let count403 = 0;
+    for (const response of orderedErrors) {
+        const n = observedResponses[response] | 0;
+        maxCount = Math.max(n, maxCount);
+        if (response.startsWith("403:")) {
+            count403 += n;
+        }
+    }
+    const clientLogger = client?.config?.logger;
+    const warningLogger = typeof clientLogger?.warn === "function" && !clientLogger.constructor?.name?.includes?.("NoOpLogger")
+        ? clientLogger
+        : console;
+    if (count403 >= 3 || orderedErrors[orderedErrors.length - 1]?.startsWith("403:")) {
+        warningLogger.warn(`@smithy/util-waiter WARN - 403 status code encountered during waiter polling.`);
+    }
+};
+const createMessageFromResponse = (reason) => {
+    const status = reason?.$response?.statusCode ?? reason?.$metadata?.httpStatusCode;
+    if (reason?.$responseBodyText) {
+        return `${status ? status + ": " : ""}Deserialization error for body: ${reason.$responseBodyText}`;
+    }
+    if (status) {
+        if (reason?.$response || reason?.message) {
+            return `${status ?? "Unknown"}: ${reason?.message}`;
+        }
+        return `${status}: OK`;
+    }
+    return String(reason?.message ?? JSON.stringify(reason, getCircularReplacer()) ?? "Unknown");
+};
+const exponentialBackoffWithJitter = (minDelayMs, maxDelayMs, attempt, waitUntil) => {
+    const attemptCountCeiling = Math.log(maxDelayMs / minDelayMs) / Math.log(2) + 1;
+    if (attempt > attemptCountCeiling) {
+        return maxDelayMs;
+    }
+    const delay = minDelayMs * 2 ** (attempt - 1);
+    const capped = Math.min(delay, maxDelayMs);
+    const waitFor = randomInRange(minDelayMs, capped);
+    if (Date.now() + waitFor > waitUntil) {
+        const timeRemaining = waitUntil - Date.now();
+        return Math.max(0, timeRemaining - 500);
+    }
+    return waitFor;
+};
+const randomInRange = (min, max) => min + Math.random() * (max - min);

package/node_modules/@smithy/core/dist-es/submodules/client/util-waiter/utils/sleep.js

@@ -0,0 +1,3 @@
+export const sleep = (seconds) => {
+    return new Promise((resolve) => setTimeout(resolve, seconds * 1000));
+};

package/node_modules/@smithy/core/dist-es/submodules/client/util-waiter/utils/validate.js

@@ -0,0 +1,17 @@
+export const validateWaiterOptions = (options) => {
+    if (options.maxWaitTime <= 0) {
+        throw new Error(`WaiterConfiguration.maxWaitTime must be greater than 0`);
+    }
+    else if (options.minDelay <= 0) {
+        throw new Error(`WaiterConfiguration.minDelay must be greater than 0`);
+    }
+    else if (options.maxDelay <= 0) {
+        throw new Error(`WaiterConfiguration.maxDelay must be greater than 0`);
+    }
+    else if (options.maxWaitTime <= options.minDelay) {
+        throw new Error(`WaiterConfiguration.maxWaitTime [${options.maxWaitTime}] must be greater than WaiterConfiguration.minDelay [${options.minDelay}] for this waiter`);
+    }
+    else if (options.maxDelay < options.minDelay) {
+        throw new Error(`WaiterConfiguration.maxDelay [${options.maxDelay}] must be greater than WaiterConfiguration.minDelay [${options.minDelay}] for this waiter`);
+    }
+};