@cdk8s/awscdk-resolver 0.0.562 → 0.0.564

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

@@ -0,0 +1,111 @@
+import { isThrottlingError } from "../service-error-classification/service-error-classification";
+export class DefaultRateLimiter {
+    static setTimeoutFn = setTimeout;
+    beta;
+    minCapacity;
+    minFillRate;
+    scaleConstant;
+    smooth;
+    enabled = false;
+    availableTokens = 0;
+    lastMaxRate = 0;
+    measuredTxRate = 0;
+    requestCount = 0;
+    fillRate;
+    lastThrottleTime;
+    lastTimestamp = 0;
+    lastTxRateBucket;
+    maxCapacity;
+    timeWindow = 0;
+    constructor(options) {
+        this.beta = options?.beta ?? 0.7;
+        this.minCapacity = options?.minCapacity ?? 1;
+        this.minFillRate = options?.minFillRate ?? 0.5;
+        this.scaleConstant = options?.scaleConstant ?? 0.4;
+        this.smooth = options?.smooth ?? 0.8;
+        this.lastThrottleTime = this.getCurrentTimeInSeconds();
+        this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds());
+        this.fillRate = this.minFillRate;
+        this.maxCapacity = this.minCapacity;
+    }
+    async getSendToken() {
+        return this.acquireTokenBucket(1);
+    }
+    updateClientSendingRate(response) {
+        let calculatedRate;
+        this.updateMeasuredRate();
+        const retryErrorInfo = response;
+        const isThrottling = retryErrorInfo?.errorType === "THROTTLING" || isThrottlingError(retryErrorInfo?.error ?? response);
+        if (isThrottling) {
+            const rateToUse = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate);
+            this.lastMaxRate = rateToUse;
+            this.calculateTimeWindow();
+            this.lastThrottleTime = this.getCurrentTimeInSeconds();
+            calculatedRate = this.cubicThrottle(rateToUse);
+            this.enableTokenBucket();
+        }
+        else {
+            this.calculateTimeWindow();
+            calculatedRate = this.cubicSuccess(this.getCurrentTimeInSeconds());
+        }
+        const newRate = Math.min(calculatedRate, 2 * this.measuredTxRate);
+        this.updateTokenBucketRate(newRate);
+    }
+    getCurrentTimeInSeconds() {
+        return Date.now() / 1000;
+    }
+    async acquireTokenBucket(amount) {
+        if (!this.enabled) {
+            return;
+        }
+        this.refillTokenBucket();
+        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;
+    }
+    refillTokenBucket() {
+        const timestamp = this.getCurrentTimeInSeconds();
+        if (!this.lastTimestamp) {
+            this.lastTimestamp = timestamp;
+            return;
+        }
+        const fillAmount = (timestamp - this.lastTimestamp) * this.fillRate;
+        this.availableTokens = Math.min(this.maxCapacity, this.availableTokens + fillAmount);
+        this.lastTimestamp = timestamp;
+    }
+    calculateTimeWindow() {
+        this.timeWindow = this.getPrecise(Math.pow((this.lastMaxRate * (1 - this.beta)) / this.scaleConstant, 1 / 3));
+    }
+    cubicThrottle(rateToUse) {
+        return this.getPrecise(rateToUse * this.beta);
+    }
+    cubicSuccess(timestamp) {
+        return this.getPrecise(this.scaleConstant * Math.pow(timestamp - this.lastThrottleTime - this.timeWindow, 3) + this.lastMaxRate);
+    }
+    enableTokenBucket() {
+        this.enabled = true;
+    }
+    updateTokenBucketRate(newRate) {
+        this.refillTokenBucket();
+        this.fillRate = Math.max(newRate, this.minFillRate);
+        this.maxCapacity = Math.max(newRate, this.minCapacity);
+        this.availableTokens = Math.min(this.availableTokens, this.maxCapacity);
+    }
+    updateMeasuredRate() {
+        const t = this.getCurrentTimeInSeconds();
+        const timeBucket = Math.floor(t * 2) / 2;
+        this.requestCount++;
+        if (timeBucket > this.lastTxRateBucket) {
+            const currentRate = this.requestCount / (timeBucket - this.lastTxRateBucket);
+            this.measuredTxRate = this.getPrecise(currentRate * this.smooth + this.measuredTxRate * (1 - this.smooth));
+            this.requestCount = 0;
+            this.lastTxRateBucket = timeBucket;
+        }
+    }
+    getPrecise(num) {
+        return parseFloat(num.toFixed(8));
+    }
+}

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

@@ -0,0 +1,93 @@
+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;
+    retryBackoffStrategy;
+    maxAttemptsProvider;
+    baseDelay;
+    constructor(arg1) {
+        if (typeof arg1 === "number") {
+            this.maxAttemptsProvider = async () => arg1;
+        }
+        else if (typeof arg1 === "function") {
+            this.maxAttemptsProvider = arg1;
+        }
+        else if (arg1 && typeof arg1 === "object") {
+            this.maxAttemptsProvider = async () => arg1.maxAttempts;
+            this.baseDelay = arg1.baseDelay;
+            this.retryBackoffStrategy = arg1.backoff;
+        }
+        this.maxAttemptsProvider ??= async () => DEFAULT_MAX_ATTEMPTS;
+        this.baseDelay ??= Retry.delay();
+        this.retryBackoffStrategy ??= new DefaultRetryBackoffStrategy();
+    }
+    async acquireInitialRetryToken(retryTokenScope) {
+        return new DefaultRetryToken(Retry.delay(), 0, undefined, Retry.v2026 && retryTokenScope.includes(":longpoll"));
+    }
+    async refreshRetryTokenForRetry(token, errorInfo) {
+        const maxAttempts = await this.getMaxAttempts();
+        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());
+            let retryDelay = delayFromErrorType;
+            if (errorInfo.retryAfterHint instanceof Date) {
+                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 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0,
+                });
+            }
+            else {
+                const capacityCost = this.getCapacityCost(errorType);
+                this.capacity -= capacityCost;
+                return new DefaultRetryToken(retryDelay, token.getRetryCount() + 1, capacityCost, token.isLongPoll?.() ?? false);
+            }
+        }
+        throw new Error("No retry token available");
+    }
+    recordSuccess(token) {
+        this.capacity = Math.min(INITIAL_RETRY_TOKENS, this.capacity + (token.getRetryCost() ?? NO_RETRY_INCREMENT));
+    }
+    getCapacity() {
+        return this.capacity;
+    }
+    async maxAttempts() {
+        return this.maxAttemptsProvider();
+    }
+    async getMaxAttempts() {
+        try {
+            return await this.maxAttemptsProvider();
+        }
+        catch (error) {
+            console.warn(`Max attempts provider could not resolve. Using default of ${DEFAULT_MAX_ATTEMPTS}`);
+            return DEFAULT_MAX_ATTEMPTS;
+        }
+    }
+    retryCode(tokenToRenew, errorInfo, maxAttempts) {
+        const attempts = tokenToRenew.getRetryCount() + 1;
+        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();
+    }
+    isRetryableError(errorType) {
+        return errorType === "THROTTLING" || errorType === "TRANSIENT";
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/retry/util-retry/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -36,6 +36,18 @@ export class TypeRegistry {
     getSchema(shapeId) {
         const id = this.normalizeShapeId(shapeId);
         if (!this.schemas.has(id)) {
+            if (!shapeId.includes("#")) {
+                const suffix = "#" + shapeId;
+                const candidates = [];
+                for (const [shapeId, schema] of this.schemas.entries()) {
+                    if (shapeId.endsWith(suffix)) {
+                        candidates.push(schema);
+                    }
+                }
+                if (candidates.length === 1) {
+                    return candidates[0];
+                }
+            }
             throw new Error(`@smithy/core/schema - schema not found for ${id}`);
         }
         return this.schemas.get(id);

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/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,36 @@
+import { bindV4 } from "./uuid/v4";
+const no = Symbol.for("node-only");
+export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
+export { dateToUtcString, parseRfc3339DateTime, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, parseEpochTimestamp, } from "./date-utils";
+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";
+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

@@ -1,10 +1,36 @@
-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";
+import { getRandomValues } from "node:crypto";
+import { bindV4 } from "./uuid/v4";
+export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
+export { dateToUtcString, parseRfc3339DateTime, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, parseEpochTimestamp, } from "./date-utils";
+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";
+const _getRandomValues = getRandomValues;
+export const v4 = bindV4(_getRandomValues);
+export const generateIdempotencyToken = v4;

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

@@ -0,0 +1,36 @@
+import { bindV4 } from "./uuid/v4";
+const no = Symbol.for("node-only");
+export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
+export { dateToUtcString, parseRfc3339DateTime, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, parseEpochTimestamp, } from "./date-utils";
+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";
+const _getRandomValues = (array) => crypto.getRandomValues(array);
+export const v4 = bindV4(_getRandomValues);
+export const generateIdempotencyToken = v4;

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

@@ -0,0 +1,58 @@
+import { HttpResponse } from "@smithy/core/protocols";
+export const deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
+    const { response } = await next(args);
+    try {
+        const parsed = await deserializer(response, options);
+        return {
+            response,
+            output: parsed,
+        };
+    }
+    catch (error) {
+        Object.defineProperty(error, "$response", {
+            value: response,
+            enumerable: false,
+            writable: false,
+            configurable: false,
+        });
+        if (!("$metadata" in error)) {
+            const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
+            try {
+                error.message += "\n  " + hint;
+            }
+            catch (e) {
+                if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
+                    console.warn(hint);
+                }
+                else {
+                    context.logger?.warn?.(hint);
+                }
+            }
+            if (typeof error.$responseBodyText !== "undefined") {
+                if (error.$response) {
+                    error.$response.body = error.$responseBodyText;
+                }
+            }
+            try {
+                if (HttpResponse.isInstance(response)) {
+                    const { headers = {} } = response;
+                    const headerEntries = Object.entries(headers);
+                    error.$metadata = {
+                        httpStatusCode: response.statusCode,
+                        requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
+                        extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
+                        cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries),
+                    };
+                }
+            }
+            catch (e) {
+            }
+        }
+        throw error;
+    }
+};
+const findHeader = (pattern, headers) => {
+    return (headers.find(([k]) => {
+        return k.match(pattern);
+    }) || [void 0, void 1])[1];
+};

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

@@ -0,0 +1,36 @@
+import { alphabetByEncoding, bitsPerByte, bitsPerLetter } from "./constants-for-browser";
+export const fromBase64 = (input) => {
+    let totalByteLength = (input.length / 4) * 3;
+    if (input.slice(-2) === "==") {
+        totalByteLength -= 2;
+    }
+    else if (input.slice(-1) === "=") {
+        totalByteLength--;
+    }
+    const out = new ArrayBuffer(totalByteLength);
+    const dataView = new DataView(out);
+    for (let i = 0; i < input.length; i += 4) {
+        let bits = 0;
+        let bitLength = 0;
+        for (let j = i, limit = i + 3; j <= limit; j++) {
+            if (input[j] !== "=") {
+                if (!(input[j] in alphabetByEncoding)) {
+                    throw new TypeError(`Invalid character ${input[j]} in base64 string.`);
+                }
+                bits |= alphabetByEncoding[input[j]] << ((limit - j) * bitsPerLetter);
+                bitLength += bitsPerLetter;
+            }
+            else {
+                bits >>= bitsPerLetter;
+            }
+        }
+        const chunkOffset = (i / 4) * 3;
+        bits >>= bitLength % bitsPerByte;
+        const byteLength = Math.floor(bitLength / bitsPerByte);
+        for (let k = 0; k < byteLength; k++) {
+            const offset = (byteLength - k - 1) * bitsPerByte;
+            dataView.setUint8(chunkOffset + k, (bits & (255 << offset)) >> offset);
+        }
+    }
+    return new Uint8Array(out);
+};

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

@@ -0,0 +1,12 @@
+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) {
+        throw new TypeError(`Incorrect padding on base64 string.`);
+    }
+    if (!BASE64_REGEX.exec(input)) {
+        throw new TypeError(`Invalid base64 string.`);
+    }
+    const buffer = fromString(input, "base64");
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+};

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

@@ -0,0 +1,35 @@
+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") {
+        input = fromUtf8(_input);
+    }
+    else {
+        input = _input;
+    }
+    const isArrayLike = typeof input === "object" && typeof input.length === "number";
+    const isUint8Array = typeof input === "object" &&
+        typeof input.byteOffset === "number" &&
+        typeof input.byteLength === "number";
+    if (!isArrayLike && !isUint8Array) {
+        throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
+    }
+    let str = "";
+    for (let i = 0; i < input.length; i += 3) {
+        let bits = 0;
+        let bitLength = 0;
+        for (let j = i, limit = Math.min(i + 3, input.length); j < limit; j++) {
+            bits |= input[j] << ((limit - j - 1) * bitsPerByte);
+            bitLength += bitsPerByte;
+        }
+        const bitClusterCount = Math.ceil(bitLength / bitsPerLetter);
+        bits <<= bitClusterCount * bitsPerLetter - bitLength;
+        for (let k = 1; k <= bitClusterCount; k++) {
+            const offset = (bitClusterCount - k) * bitsPerLetter;
+            str += alphabetByValue[(bits & (maxLetterValue << offset)) >> offset];
+        }
+        str += "==".slice(0, 4 - bitClusterCount);
+    }
+    return str;
+}

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

@@ -0,0 +1,15 @@
+import { fromArrayBuffer } from "../util-buffer-from/buffer-from";
+import { fromUtf8 } from "../util-utf8/fromUtf8";
+export const toBase64 = (_input) => {
+    let input;
+    if (typeof _input === "string") {
+        input = fromUtf8(_input);
+    }
+    else {
+        input = _input;
+    }
+    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+        throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
+    }
+    return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("base64");
+};

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

@@ -0,0 +1,27 @@
+import { ReadStream, fstatSync, lstatSync } from "node:fs";
+export const calculateBodyLength = (body) => {
+    if (!body) {
+        return 0;
+    }
+    if (typeof body === "string") {
+        return Buffer.byteLength(body);
+    }
+    else if (typeof body.byteLength === "number") {
+        return body.byteLength;
+    }
+    else if (typeof body.size === "number") {
+        return body.size;
+    }
+    else if (typeof body.start === "number" && typeof body.end === "number") {
+        return body.end + 1 - body.start;
+    }
+    else if (body instanceof ReadStream) {
+        if (body.path != null) {
+            return lstatSync(body.path).size;
+        }
+        else if (typeof body.fd === "number") {
+            return fstatSync(body.fd).size;
+        }
+    }
+    throw new Error(`Body Length computation failed for ${body}`);
+};

package/node_modules/@smithy/core/dist-es/submodules/serde/util-buffer-from/buffer-from.js

@@ -0,0 +1,13 @@
+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})`);
+    }
+    return Buffer.from(input, offset, length);
+};
+export const fromString = (input, encoding) => {
+    if (typeof input !== "string") {
+        throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
+    }
+    return encoding ? Buffer.from(input, encoding) : Buffer.from(input);
+};

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

@@ -0,0 +1,25 @@
+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") {
+            if (encoding === "base64") {
+                return Uint8ArrayBlobAdapter.mutate(fromBase64(source));
+            }
+            return Uint8ArrayBlobAdapter.mutate(fromUtf8(source));
+        }
+        throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
+    }
+    static mutate(source) {
+        Object.setPrototypeOf(source, Uint8ArrayBlobAdapter.prototype);
+        return source;
+    }
+    transformToString(encoding = "utf-8") {
+        if (encoding === "base64") {
+            return toBase64(this);
+        }
+        return toUtf8(this);
+    }
+}