@qqbrowser/openclaw-qbot 0.10.9 → 0.10.10

package/node_modules/@smithy/{util-retry/dist-es → core/dist-es/submodules/retry/util-retry}/DefaultRateLimiter.js

@@ -1,4 +1,4 @@
-import { isThrottlingError } from "@smithy/service-error-classification";
+import { isThrottlingError } from "../service-error-classification/service-error-classification";
 export class DefaultRateLimiter {
     static setTimeoutFn = setTimeout;
     beta;
@@ -59,9 +59,10 @@ export class DefaultRateLimiter {
             return;
         }
         this.refillTokenBucket();
-        if (amount > this.availableTokens) {
+        while (amount > this.availableTokens) {
             const delay = ((amount - this.availableTokens) / this.fillRate) * 1000;
             await new Promise((resolve) => DefaultRateLimiter.setTimeoutFn(resolve, delay));
+            this.refillTokenBucket();
         }
         this.availableTokens = this.availableTokens - amount;
     }

package/node_modules/@smithy/{util-retry/dist-es → core/dist-es/submodules/retry/util-retry}/StandardRetryStrategy.js

@@ -1,8 +1,13 @@
-import { DEFAULT_MAX_ATTEMPTS, RETRY_MODES } from "./config";
-import { INITIAL_RETRY_TOKENS, NO_RETRY_INCREMENT } from "./constants";
 import { DefaultRetryBackoffStrategy } from "./DefaultRetryBackoffStrategy";
 import { DefaultRetryToken } from "./DefaultRetryToken";
+import { DEFAULT_MAX_ATTEMPTS, RETRY_MODES } from "./config";
+import { INITIAL_RETRY_TOKENS, NO_RETRY_INCREMENT } from "./constants";
 import { Retry } from "./retries-2026-config";
+const refusal = {
+    incompatible: 1,
+    attempts: 2,
+    capacity: 3,
+};
 export class StandardRetryStrategy {
     mode = RETRY_MODES.STANDARD;
     capacity = INITIAL_RETRY_TOKENS;
@@ -30,8 +35,10 @@ export class StandardRetryStrategy {
     }
     async refreshRetryTokenForRetry(token, errorInfo) {
         const maxAttempts = await this.getMaxAttempts();
-        const shouldRetry = this.shouldRetry(token, errorInfo, maxAttempts);
-        if (shouldRetry || token.isLongPoll?.()) {
+        const retryCode = this.retryCode(token, errorInfo, maxAttempts);
+        const shouldRetry = retryCode === 0;
+        const isLongPoll = token.isLongPoll?.();
+        if (shouldRetry || isLongPoll) {
             const errorType = errorInfo.errorType;
             this.retryBackoffStrategy.setDelayBase(errorType === "THROTTLING" ? Retry.throttlingDelay() : this.baseDelay);
             const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());
@@ -40,7 +47,9 @@ export class StandardRetryStrategy {
                 retryDelay = Math.max(delayFromErrorType, Math.min(errorInfo.retryAfterHint.getTime() - Date.now(), delayFromErrorType + 5_000));
             }
             if (!shouldRetry) {
-                throw Object.assign(new Error("No retry token available"), { $backoff: Retry.v2026 ? retryDelay : 0 });
+                throw Object.assign(new Error("No retry token available"), {
+                    $backoff: Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0,
+                });
             }
             else {
                 const capacityCost = this.getCapacityCost(errorType);
@@ -56,6 +65,9 @@ export class StandardRetryStrategy {
     getCapacity() {
         return this.capacity;
     }
+    async maxAttempts() {
+        return this.maxAttemptsProvider();
+    }
     async getMaxAttempts() {
         try {
             return await this.maxAttemptsProvider();
@@ -65,11 +77,12 @@ export class StandardRetryStrategy {
             return DEFAULT_MAX_ATTEMPTS;
         }
     }
-    shouldRetry(tokenToRenew, errorInfo, maxAttempts) {
+    retryCode(tokenToRenew, errorInfo, maxAttempts) {
         const attempts = tokenToRenew.getRetryCount() + 1;
-        return (attempts < maxAttempts &&
-            this.capacity >= this.getCapacityCost(errorInfo.errorType) &&
-            this.isRetryableError(errorInfo.errorType));
+        const retryableStatus = this.isRetryableError(errorInfo.errorType) ? 0 : refusal.incompatible;
+        const attemptStatus = attempts < maxAttempts ? 0 : refusal.attempts;
+        const capacityStatus = this.capacity >= this.getCapacityCost(errorInfo.errorType) ? 0 : refusal.capacity;
+        return retryableStatus || attemptStatus || capacityStatus;
     }
     getCapacityCost(errorType) {
         return errorType === Retry.modifiedCostType() ? Retry.throttlingCost() : Retry.cost();
@@ -77,7 +90,4 @@ export class StandardRetryStrategy {
     isRetryableError(errorType) {
         return errorType === "THROTTLING" || errorType === "TRANSIENT";
     }
-    async maxAttempts() {
-        return this.maxAttemptsProvider();
-    }
 }

package/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js

@@ -1,5 +1,5 @@
-import { HttpResponse } from "@smithy/protocol-http";
-import { getSmithyContext } from "@smithy/util-middleware";
+import { getSmithyContext } from "@smithy/core/client";
+import { HttpResponse } from "@smithy/core/protocols";
 import { operation } from "../schemas/operation";
 export const schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
     const { response } = await next(args);

package/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js

@@ -1,5 +1,5 @@
+import { getSmithyContext } from "@smithy/core/client";
 import { toEndpointV1 } from "@smithy/core/endpoints";
-import { getSmithyContext } from "@smithy/util-middleware";
 import { operation } from "../schemas/operation";
 export const schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
     const { operationSchema } = getSmithyContext(context);

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

@@ -1,2 +1,2 @@
-import { v4 as generateIdempotencyToken } from "@smithy/uuid";
+import { v4 as generateIdempotencyToken } from "./uuid/v4";
 export { generateIdempotencyToken };

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

@@ -0,0 +1,36 @@
+import { createHash, createHmac } from "node:crypto";
+import { fromArrayBuffer, fromString } from "../util-buffer-from/buffer-from";
+import { toUint8Array } from "../util-utf8/toUint8Array";
+export class Hash {
+    algorithmIdentifier;
+    secret;
+    hash;
+    constructor(algorithmIdentifier, secret) {
+        this.algorithmIdentifier = algorithmIdentifier;
+        this.secret = secret;
+        this.reset();
+    }
+    update(toHash, encoding) {
+        this.hash.update(toUint8Array(castSourceData(toHash, encoding)));
+    }
+    digest() {
+        return Promise.resolve(this.hash.digest());
+    }
+    reset() {
+        this.hash = this.secret
+            ? createHmac(this.algorithmIdentifier, castSourceData(this.secret))
+            : createHash(this.algorithmIdentifier);
+    }
+}
+function castSourceData(toCast, encoding) {
+    if (Buffer.isBuffer(toCast)) {
+        return toCast;
+    }
+    if (typeof toCast === "string") {
+        return fromString(toCast, encoding);
+    }
+    if (ArrayBuffer.isView(toCast)) {
+        return fromArrayBuffer(toCast.buffer, toCast.byteOffset, toCast.byteLength);
+    }
+    return fromArrayBuffer(toCast);
+}

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

@@ -0,0 +1,34 @@
+const no = Symbol.for("node-only");
+export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
+export { dateToUtcString, parseRfc3339DateTime, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, parseEpochTimestamp, } from "./date-utils";
+export { generateIdempotencyToken } from "./generateIdempotencyToken";
+export { LazyJsonString } from "./lazy-json";
+export { logger, parseBoolean, expectBoolean, expectNumber, expectFloat32, expectInt, expectInt32, expectShort, expectByte, expectNonNull, expectObject, expectString, expectUnion, expectLong, strictParseDouble, strictParseFloat, strictParseFloat32, strictParseLong, strictParseInt, strictParseInt32, strictParseShort, strictParseByte, limitedParseDouble, handleFloat, limitedParseFloat, limitedParseFloat32, } from "./parse-utils";
+export { quoteHeader } from "./quote-header";
+export { _parseEpochTimestamp, _parseRfc3339DateTimeWithOffset, _parseRfc7231DateTime, } from "./schema-serde-lib/schema-date-utils";
+export { splitEvery } from "./split-every";
+export { splitHeader } from "./split-header";
+export { NumericValue, nv } from "./value/NumericValue";
+export { fromHex, toHex } from "./util-hex-encoding/hex-encoding";
+export { fromBase64 } from "./util-base64/fromBase64.browser";
+export { toBase64 } from "./util-base64/toBase64.browser";
+export { calculateBodyLength } from "./util-body-length/calculateBodyLength.browser";
+export { fromUtf8 } from "./util-utf8/fromUtf8.browser";
+export { toUint8Array } from "./util-utf8/toUint8Array";
+export { toUtf8 } from "./util-utf8/toUtf8.browser";
+export { fromArrayBuffer, fromString } from "./util-buffer-from/buffer-from";
+export { isArrayBuffer } from "./is-array-buffer/is-array-buffer";
+export { deserializerMiddleware } from "./middleware-serde/deserializerMiddleware";
+export { deserializerMiddlewareOption, serializerMiddlewareOption, getSerdePlugin, } from "./middleware-serde/serdePlugin";
+export { serializerMiddleware } from "./middleware-serde/serializerMiddleware";
+export const Hash = no;
+export { Uint8ArrayBlobAdapter } from "./util-stream/blob/Uint8ArrayBlobAdapter";
+export { ChecksumStream } from "./util-stream/checksum/ChecksumStream.browser";
+export { createChecksumStream } from "./util-stream/checksum/createChecksumStream.browser";
+export { createBufferedReadable } from "./util-stream/createBufferedReadable.browser";
+export { getAwsChunkedEncodingStream } from "./util-stream/getAwsChunkedEncodingStream.browser";
+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 { v4 } from "./uuid/v4";

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

@@ -1,10 +1,33 @@
-export * from "./copyDocumentWithTransform";
-export * from "./date-utils";
-export * from "./generateIdempotencyToken";
-export * from "./lazy-json";
-export * from "./parse-utils";
-export * from "./quote-header";
-export * from "./schema-serde-lib/schema-date-utils";
-export * from "./split-every";
-export * from "./split-header";
-export * from "./value/NumericValue";
+export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
+export { dateToUtcString, parseRfc3339DateTime, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, parseEpochTimestamp, } from "./date-utils";
+export { generateIdempotencyToken } from "./generateIdempotencyToken";
+export { LazyJsonString } from "./lazy-json";
+export { logger, parseBoolean, expectBoolean, expectNumber, expectFloat32, expectInt, expectInt32, expectShort, expectByte, expectNonNull, expectObject, expectString, expectUnion, expectLong, strictParseDouble, strictParseFloat, strictParseFloat32, strictParseLong, strictParseInt, strictParseInt32, strictParseShort, strictParseByte, limitedParseDouble, handleFloat, limitedParseFloat, limitedParseFloat32, } from "./parse-utils";
+export { quoteHeader } from "./quote-header";
+export { _parseEpochTimestamp, _parseRfc3339DateTimeWithOffset, _parseRfc7231DateTime, } from "./schema-serde-lib/schema-date-utils";
+export { splitEvery } from "./split-every";
+export { splitHeader } from "./split-header";
+export { NumericValue, nv } from "./value/NumericValue";
+export { fromHex, toHex } from "./util-hex-encoding/hex-encoding";
+export { fromBase64 } from "./util-base64/fromBase64";
+export { toBase64 } from "./util-base64/toBase64";
+export { calculateBodyLength } from "./util-body-length/calculateBodyLength";
+export { fromUtf8 } from "./util-utf8/fromUtf8";
+export { toUint8Array } from "./util-utf8/toUint8Array";
+export { toUtf8 } from "./util-utf8/toUtf8";
+export { fromArrayBuffer, fromString } from "./util-buffer-from/buffer-from";
+export { isArrayBuffer } from "./is-array-buffer/is-array-buffer";
+export { deserializerMiddleware } from "./middleware-serde/deserializerMiddleware";
+export { deserializerMiddlewareOption, serializerMiddlewareOption, getSerdePlugin, } from "./middleware-serde/serdePlugin";
+export { serializerMiddleware } from "./middleware-serde/serializerMiddleware";
+export { Hash } from "./hash-node/hash-node";
+export { Uint8ArrayBlobAdapter } from "./util-stream/blob/Uint8ArrayBlobAdapter";
+export { ChecksumStream } from "./util-stream/checksum/ChecksumStream";
+export { createChecksumStream } from "./util-stream/checksum/createChecksumStream";
+export { createBufferedReadable } from "./util-stream/createBufferedReadable";
+export { getAwsChunkedEncodingStream } from "./util-stream/getAwsChunkedEncodingStream";
+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 { v4 } from "./uuid/v4";

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

@@ -0,0 +1,34 @@
+const no = Symbol.for("node-only");
+export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
+export { dateToUtcString, parseRfc3339DateTime, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, parseEpochTimestamp, } from "./date-utils";
+export { generateIdempotencyToken } from "./generateIdempotencyToken";
+export { LazyJsonString } from "./lazy-json";
+export { logger, parseBoolean, expectBoolean, expectNumber, expectFloat32, expectInt, expectInt32, expectShort, expectByte, expectNonNull, expectObject, expectString, expectUnion, expectLong, strictParseDouble, strictParseFloat, strictParseFloat32, strictParseLong, strictParseInt, strictParseInt32, strictParseShort, strictParseByte, limitedParseDouble, handleFloat, limitedParseFloat, limitedParseFloat32, } from "./parse-utils";
+export { quoteHeader } from "./quote-header";
+export { _parseEpochTimestamp, _parseRfc3339DateTimeWithOffset, _parseRfc7231DateTime, } from "./schema-serde-lib/schema-date-utils";
+export { splitEvery } from "./split-every";
+export { splitHeader } from "./split-header";
+export { NumericValue, nv } from "./value/NumericValue";
+export { fromHex, toHex } from "./util-hex-encoding/hex-encoding";
+export { fromBase64 } from "./util-base64/fromBase64.browser";
+export { toBase64 } from "./util-base64/toBase64.browser";
+export { calculateBodyLength } from "./util-body-length/calculateBodyLength.browser";
+export { fromUtf8 } from "./util-utf8/fromUtf8.browser";
+export { toUint8Array } from "./util-utf8/toUint8Array";
+export { toUtf8 } from "./util-utf8/toUtf8.browser";
+export { fromArrayBuffer, fromString } from "./util-buffer-from/buffer-from";
+export { isArrayBuffer } from "./is-array-buffer/is-array-buffer";
+export { deserializerMiddleware } from "./middleware-serde/deserializerMiddleware";
+export { deserializerMiddlewareOption, serializerMiddlewareOption, getSerdePlugin, } from "./middleware-serde/serdePlugin";
+export { serializerMiddleware } from "./middleware-serde/serializerMiddleware";
+export const Hash = no;
+export { Uint8ArrayBlobAdapter } from "./util-stream/blob/Uint8ArrayBlobAdapter";
+export { ChecksumStream } from "./util-stream/checksum/ChecksumStream.browser";
+export { createChecksumStream } from "./util-stream/checksum/createChecksumStream.browser";
+export { createBufferedReadable } from "./util-stream/createBufferedReadable.browser";
+export { getAwsChunkedEncodingStream } from "./util-stream/getAwsChunkedEncodingStream.browser";
+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 { v4 } from "./uuid/v4";

package/node_modules/@smithy/{middleware-serde/dist-es → core/dist-es/submodules/serde/middleware-serde}/deserializerMiddleware.js

@@ -1,4 +1,4 @@
-import { HttpResponse } from "@smithy/protocol-http";
+import { HttpResponse } from "@smithy/core/protocols";
 export const deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
     const { response } = await next(args);
     try {

package/node_modules/@smithy/{util-base64/dist-es → core/dist-es/submodules/serde/util-base64}/fromBase64.browser.js

@@ -1,4 +1,4 @@
-import { alphabetByEncoding, bitsPerByte, bitsPerLetter } from "./constants.browser";
+import { alphabetByEncoding, bitsPerByte, bitsPerLetter } from "./constants-for-browser";
 export const fromBase64 = (input) => {
     let totalByteLength = (input.length / 4) * 3;
     if (input.slice(-2) === "==") {

package/node_modules/@smithy/{util-base64/dist-es → core/dist-es/submodules/serde/util-base64}/fromBase64.js

@@ -1,4 +1,4 @@
-import { fromString } from "@smithy/util-buffer-from";
+import { fromString } from "../util-buffer-from/buffer-from";
 const BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
 export const fromBase64 = (input) => {
     if ((input.length * 3) % 4 !== 0) {

package/node_modules/@smithy/{util-base64/dist-es → core/dist-es/submodules/serde/util-base64}/toBase64.browser.js

@@ -1,5 +1,5 @@
-import { fromUtf8 } from "@smithy/util-utf8";
-import { alphabetByValue, bitsPerByte, bitsPerLetter, maxLetterValue } from "./constants.browser";
+import { fromUtf8 } from "../util-utf8/fromUtf8";
+import { alphabetByValue, bitsPerByte, bitsPerLetter, maxLetterValue } from "./constants-for-browser";
 export function toBase64(_input) {
     let input;
     if (typeof _input === "string") {

package/node_modules/@smithy/{util-base64/dist-es → core/dist-es/submodules/serde/util-base64}/toBase64.js

@@ -1,5 +1,5 @@
-import { fromArrayBuffer } from "@smithy/util-buffer-from";
-import { fromUtf8 } from "@smithy/util-utf8";
+import { fromArrayBuffer } from "../util-buffer-from/buffer-from";
+import { fromUtf8 } from "../util-utf8/fromUtf8";
 export const toBase64 = (_input) => {
     let input;
     if (typeof _input === "string") {

package/node_modules/@smithy/{util-body-length-node/dist-es → core/dist-es/submodules/serde/util-body-length}/calculateBodyLength.js

@@ -1,4 +1,4 @@
-import { fstatSync, lstatSync, ReadStream } from "node:fs";
+import { ReadStream, fstatSync, lstatSync } from "node:fs";
 export const calculateBodyLength = (body) => {
     if (!body) {
         return 0;

package/node_modules/{@aws-crypto/sha256-browser/node_modules/@smithy/util-buffer-from/dist-es/index.js → @smithy/core/dist-es/submodules/serde/util-buffer-from/buffer-from.js}

@@ -1,5 +1,4 @@
-import { isArrayBuffer } from "@smithy/is-array-buffer";
-import { Buffer } from "buffer";
+import { isArrayBuffer } from "../is-array-buffer/is-array-buffer";
 export const fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => {
     if (!isArrayBuffer(input)) {
         throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);

package/node_modules/@smithy/core/dist-es/submodules/serde/util-hex-encoding/hex-encoding.js

@@ -0,0 +1,33 @@
+const SHORT_TO_HEX = {};
+const HEX_TO_SHORT = {};
+for (let i = 0; i < 256; i++) {
+    let encodedByte = i.toString(16).toLowerCase();
+    if (encodedByte.length === 1) {
+        encodedByte = `0${encodedByte}`;
+    }
+    SHORT_TO_HEX[i] = encodedByte;
+    HEX_TO_SHORT[encodedByte] = i;
+}
+export function fromHex(encoded) {
+    if (encoded.length % 2 !== 0) {
+        throw new Error("Hex encoded strings must have an even number length");
+    }
+    const out = new Uint8Array(encoded.length / 2);
+    for (let i = 0; i < encoded.length; i += 2) {
+        const encodedByte = encoded.slice(i, i + 2).toLowerCase();
+        if (encodedByte in HEX_TO_SHORT) {
+            out[i / 2] = HEX_TO_SHORT[encodedByte];
+        }
+        else {
+            throw new Error(`Cannot decode unrecognized sequence ${encodedByte} as hexadecimal`);
+        }
+    }
+    return out;
+}
+export function toHex(bytes) {
+    let out = "";
+    for (let i = 0; i < bytes.byteLength; i++) {
+        out += SHORT_TO_HEX[bytes[i]];
+    }
+    return out;
+}

package/node_modules/@smithy/{util-stream/dist-es → core/dist-es/submodules/serde/util-stream}/blob/Uint8ArrayBlobAdapter.js

@@ -1,5 +1,7 @@
-import { fromBase64, toBase64 } from "@smithy/util-base64";
-import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
+import { fromBase64 } from "../../util-base64/fromBase64";
+import { toBase64 } from "../../util-base64/toBase64";
+import { fromUtf8 } from "../../util-utf8/fromUtf8";
+import { toUtf8 } from "../../util-utf8/toUtf8";
 export class Uint8ArrayBlobAdapter extends Uint8Array {
     static fromString(source, encoding = "utf-8") {
         if (typeof source === "string") {

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

@@ -1,5 +1,5 @@
-import { toBase64 } from "@smithy/util-base64";
-import { Duplex } from "stream";
+import { Duplex } from "node:stream";
+import { toBase64 } from "../../util-base64/toBase64";
 export class ChecksumStream extends Duplex {
     expectedChecksum;
     checksumSourceLocation;

package/node_modules/@smithy/{util-stream/dist-es → core/dist-es/submodules/serde/util-stream}/checksum/createChecksumStream.browser.js

@@ -1,4 +1,4 @@
-import { toBase64 } from "@smithy/util-base64";
+import { toBase64 } from "../../util-base64/toBase64";
 import { isReadableStream } from "../stream-type-check";
 import { ChecksumStream } from "./ChecksumStream.browser";
 export const createChecksumStream = ({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }) => {

package/node_modules/@smithy/{util-stream/dist-es → core/dist-es/submodules/serde/util-stream}/checksum/createChecksumStream.js

@@ -1,6 +1,6 @@
 import { isReadableStream } from "../stream-type-check";
 import { ChecksumStream } from "./ChecksumStream";
-import { createChecksumStream as createChecksumStreamWeb } from "./createChecksumStream.browser";
+import { createChecksumStream as createChecksumStreamWeb, } from "./createChecksumStream.browser";
 export function createChecksumStream(init) {
     if (typeof ReadableStream === "function" && isReadableStream(init.source)) {
         return createChecksumStreamWeb(init);

package/node_modules/@smithy/{util-stream/dist-es → core/dist-es/submodules/serde/util-stream}/createBufferedReadable.js

@@ -1,6 +1,6 @@
 import { Readable } from "node:stream";
 import { ByteArrayCollector } from "./ByteArrayCollector";
-import { createBufferedReadableStream, flush, merge, modeOf, sizeOf } from "./createBufferedReadableStream";
+import { createBufferedReadableStream, flush, merge, modeOf, sizeOf, } from "./createBufferedReadable.browser";
 import { isReadableStream } from "./stream-type-check";
 export function createBufferedReadable(upstream, size, logger) {
     if (isReadableStream(upstream)) {

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

@@ -1,4 +1,4 @@
-import { Writable } from "stream";
+import { Writable } from "node:stream";
 import { headStream as headWebStream } from "./headStream.browser";
 import { isReadableStream } from "./stream-type-check";
 export const headStream = (stream, bytes) => {

package/node_modules/@smithy/{util-stream/dist-es → core/dist-es/submodules/serde/util-stream}/sdk-stream-mixin.browser.js

@@ -1,7 +1,7 @@
-import { streamCollector } from "@smithy/fetch-http-handler";
-import { toBase64 } from "@smithy/util-base64";
-import { toHex } from "@smithy/util-hex-encoding";
-import { toUtf8 } from "@smithy/util-utf8";
+import { toBase64 } from "../util-base64/toBase64";
+import { toHex } from "../util-hex-encoding/hex-encoding";
+import { toUtf8 } from "../util-utf8/toUtf8";
+import { streamCollector } from "./stream-collector.browser";
 import { isReadableStream } from "./stream-type-check";
 const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
 export const sdkStreamMixin = (stream) => {

package/node_modules/@smithy/{util-stream/dist-es → core/dist-es/submodules/serde/util-stream}/sdk-stream-mixin.js

@@ -1,7 +1,7 @@
-import { streamCollector } from "@smithy/node-http-handler";
-import { fromArrayBuffer } from "@smithy/util-buffer-from";
-import { Readable } from "stream";
+import { Readable } from "node:stream";
+import { fromArrayBuffer } from "../util-buffer-from/buffer-from";
 import { sdkStreamMixin as sdkStreamMixinReadableStream } from "./sdk-stream-mixin.browser";
+import { streamCollector } from "./stream-collector";
 const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
 export const sdkStreamMixin = (stream) => {
     if (!(stream instanceof Readable)) {

package/node_modules/@smithy/{util-stream/dist-es → core/dist-es/submodules/serde/util-stream}/splitStream.js

@@ -1,4 +1,4 @@
-import { PassThrough } from "stream";
+import { PassThrough } from "node:stream";
 import { splitStream as splitWebStream } from "./splitStream.browser";
 import { isBlob, isReadableStream } from "./stream-type-check";
 export async function splitStream(stream) {

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

@@ -0,0 +1,53 @@
+import { fromBase64 } from "../util-base64/fromBase64";
+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());
+        }
+        return collectBlob(stream);
+    }
+    return collectStream(stream);
+};
+async function collectBlob(blob) {
+    const base64 = await readToBase64(blob);
+    const arrayBuffer = fromBase64(base64);
+    return new Uint8Array(arrayBuffer);
+}
+async function collectStream(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;
+}
+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);
+    });
+}

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

@@ -0,0 +1,48 @@
+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;
+}
+export const streamCollector = (stream) => {
+    if (isReadableStreamInstance(stream)) {
+        return collectReadableStream(stream);
+    }
+    return new Promise((resolve, reject) => {
+        const collector = new Collector();
+        stream.pipe(collector);
+        stream.on("error", (err) => {
+            collector.end();
+            reject(err);
+        });
+        collector.on("error", reject);
+        collector.on("finish", function () {
+            const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
+            resolve(bytes);
+        });
+    });
+};

package/node_modules/@smithy/{util-utf8/dist-es → core/dist-es/submodules/serde/util-utf8}/fromUtf8.js

@@ -1,4 +1,4 @@
-import { fromString } from "@smithy/util-buffer-from";
+import { fromString } from "../util-buffer-from/buffer-from";
 export const fromUtf8 = (input) => {
     const buf = fromString(input, "utf8");
     return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);

package/node_modules/@smithy/{util-utf8/dist-es → core/dist-es/submodules/serde/util-utf8}/toUtf8.js

@@ -1,4 +1,4 @@
-import { fromArrayBuffer } from "@smithy/util-buffer-from";
+import { fromArrayBuffer } from "../util-buffer-from/buffer-from";
 export const toUtf8 = (input) => {
     if (typeof input === "string") {
         return input;

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

@@ -0,0 +1,3 @@
+export const randomUUID = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+    ? crypto.randomUUID.bind(crypto)
+    : undefined;

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

@@ -1,5 +1,5 @@
-import { HttpRequest } from "@smithy/protocol-http";
-import { HttpApiKeyAuthLocation } from "@smithy/types";
+import { HttpRequest } from "@smithy/core/protocols";
+import { HttpApiKeyAuthLocation, } from "@smithy/types";
 export class HttpApiKeyAuthSigner {
     async sign(httpRequest, identity, signingProperties) {
         if (!signingProperties) {

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

@@ -1,4 +1,4 @@
-import { HttpRequest } from "@smithy/protocol-http";
+import { HttpRequest } from "@smithy/core/protocols";
 export class HttpBearerAuthSigner {
     async sign(httpRequest, identity, signingProperties) {
         const clonedRequest = HttpRequest.clone(httpRequest);