@cdk8s/awscdk-resolver 0.0.563 → 0.0.565

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

@@ -3,6 +3,122 @@
 var protocols = require('@smithy/core/protocols');
 var endpoints = require('@smithy/core/endpoints');
 
+const chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
+const alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
+    acc[c] = Number(i);
+    return acc;
+}, {});
+const alphabetByValue = chars.split("");
+const bitsPerLetter = 6;
+const bitsPerByte = 8;
+const maxLetterValue = 0b111111;
+
+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);
+};
+
+const fromUtf8 = (input) => new TextEncoder().encode(input);
+
+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;
+}
+
+function bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+    return 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);
+        }
+    };
+}
+
+const toUtf8 = (input) => {
+    if (typeof input === "string") {
+        return input;
+    }
+    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+        throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
+    }
+    return new TextDecoder("utf-8").decode(input);
+};
+
 const decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
 function bindV4(getRandomValues) {
     if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
@@ -721,107 +837,6 @@ function toHex(bytes) {
     return out;
 }
 
-const chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
-const alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
-    acc[c] = Number(i);
-    return acc;
-}, {});
-const alphabetByValue = chars.split("");
-const bitsPerLetter = 6;
-const bitsPerByte = 8;
-const maxLetterValue = 0b111111;
-
-const fromBase64$1 = (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);
-};
-
-const isArrayBuffer = (arg) => (typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer) ||
-    Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
-
-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);
-};
-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);
-};
-
-const fromUtf8$1 = (input) => {
-    const buf = fromString(input, "utf8");
-    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
-};
-
-function toBase64$1(_input) {
-    let input;
-    if (typeof _input === "string") {
-        input = fromUtf8$1(_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;
-}
-
 const TEXT_ENCODER = typeof TextEncoder == "function" ? new TextEncoder() : null;
 const calculateBodyLength = (body) => {
     if (typeof body === "string") {
@@ -849,11 +864,9 @@ const calculateBodyLength = (body) => {
     throw new Error(`Body Length computation failed for ${body}`);
 };
 
-const fromUtf8 = (input) => new TextEncoder().encode(input);
-
 const toUint8Array = (data) => {
     if (typeof data === "string") {
-        return fromUtf8$1(data);
+        return fromUtf8(data);
     }
     if (ArrayBuffer.isView(data)) {
         return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
@@ -861,15 +874,8 @@ const toUint8Array = (data) => {
     return new Uint8Array(data);
 };
 
-const toUtf8$1 = (input) => {
-    if (typeof input === "string") {
-        return input;
-    }
-    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
-        throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
-    }
-    return new TextDecoder("utf-8").decode(input);
-};
+const isArrayBuffer = (arg) => (typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer) ||
+    Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
 
 const deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
     const { response } = await next(args);
@@ -965,64 +971,6 @@ function getSerdePlugin(config, serializer, deserializer) {
     };
 }
 
-const BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
-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);
-};
-
-const toBase64 = (_input) => {
-    let input;
-    if (typeof _input === "string") {
-        input = fromUtf8$1(_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");
-};
-
-const toUtf8 = (input) => {
-    if (typeof input === "string") {
-        return input;
-    }
-    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
-        throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
-    }
-    return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
-};
-
-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$1(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);
-    }
-}
-
 const ReadableStreamRef = typeof ReadableStream === "function" ? ReadableStream : function () { };
 class ChecksumStream extends ReadableStreamRef {
 }
@@ -1376,7 +1324,11 @@ async function splitStream(stream) {
 }
 
 const no = Symbol.for("node-only");
+const fromArrayBuffer = no;
+const fromString = no;
 const Hash = no;
+class Uint8ArrayBlobAdapter extends bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+}
 const _getRandomValues = (array) => crypto.getRandomValues(array);
 const v4 = bindV4(_getRandomValues);
 const generateIdempotencyToken = v4;
@@ -1409,7 +1361,7 @@ exports.expectShort = expectShort;
 exports.expectString = expectString;
 exports.expectUnion = expectUnion;
 exports.fromArrayBuffer = fromArrayBuffer;
-exports.fromBase64 = fromBase64$1;
+exports.fromBase64 = fromBase64;
 exports.fromHex = fromHex;
 exports.fromString = fromString;
 exports.fromUtf8 = fromUtf8;
@@ -1446,8 +1398,8 @@ exports.strictParseInt = strictParseInt;
 exports.strictParseInt32 = strictParseInt32;
 exports.strictParseLong = strictParseLong;
 exports.strictParseShort = strictParseShort;
-exports.toBase64 = toBase64$1;
+exports.toBase64 = toBase64;
 exports.toHex = toHex;
 exports.toUint8Array = toUint8Array;
-exports.toUtf8 = toUtf8$1;
+exports.toUtf8 = toUtf8;
 exports.v4 = v4;

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

@@ -83,7 +83,7 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
         const ns = NormalizedSchema.of(errorSchema);
         const ErrorCtor = registry.getErrorCtor(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-        const exception = new ErrorCtor(message);
+        const exception = new ErrorCtor({});
         const output = {};
         for (const [name, member] of ns.structIterator()) {
             output[name] = this.deserializer.readValue(member, dataObject[name]);

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

@@ -1,3 +1,8 @@
+import { fromBase64 } from "./util-base64/fromBase64.browser";
+import { toBase64 } from "./util-base64/toBase64.browser";
+import { bindUint8ArrayBlobAdapter } from "./util-stream/blob/Uint8ArrayBlobAdapter";
+import { fromUtf8 } from "./util-utf8/fromUtf8.browser";
+import { toUtf8 } from "./util-utf8/toUtf8.browser";
 import { bindV4 } from "./uuid/v4";
 const no = Symbol.for("node-only");
 export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
@@ -10,19 +15,19 @@ 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 { toBase64, fromBase64 };
 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 { toUint8Array } from "./util-utf8/toUint8Array.browser";
+export { toUtf8, fromUtf8 };
+export const fromArrayBuffer = no;
+export const fromString = no;
 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 class Uint8ArrayBlobAdapter extends bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+}
 export { ChecksumStream } from "./util-stream/checksum/ChecksumStream.browser";
 export { createChecksumStream } from "./util-stream/checksum/createChecksumStream.browser";
 export { createBufferedReadable } from "./util-stream/createBufferedReadable.browser";

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

@@ -1,4 +1,9 @@
 import { getRandomValues } from "node:crypto";
+import { fromBase64 } from "./util-base64/fromBase64";
+import { toBase64 } from "./util-base64/toBase64";
+import { bindUint8ArrayBlobAdapter } from "./util-stream/blob/Uint8ArrayBlobAdapter";
+import { fromUtf8 } from "./util-utf8/fromUtf8";
+import { toUtf8 } from "./util-utf8/toUtf8";
 import { bindV4 } from "./uuid/v4";
 export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
 export { dateToUtcString, parseRfc3339DateTime, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, parseEpochTimestamp, } from "./date-utils";
@@ -10,19 +15,18 @@ 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 { toBase64, fromBase64 };
 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 { toUtf8, fromUtf8 };
 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 class Uint8ArrayBlobAdapter extends bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+}
 export { ChecksumStream } from "./util-stream/checksum/ChecksumStream";
 export { createChecksumStream } from "./util-stream/checksum/createChecksumStream";
 export { createBufferedReadable } from "./util-stream/createBufferedReadable";

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

@@ -1,3 +1,8 @@
+import { fromBase64 } from "./util-base64/fromBase64.browser";
+import { toBase64 } from "./util-base64/toBase64.browser";
+import { bindUint8ArrayBlobAdapter } from "./util-stream/blob/Uint8ArrayBlobAdapter";
+import { fromUtf8 } from "./util-utf8/fromUtf8.browser";
+import { toUtf8 } from "./util-utf8/toUtf8.browser";
 import { bindV4 } from "./uuid/v4";
 const no = Symbol.for("node-only");
 export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
@@ -14,15 +19,17 @@ 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 { toUint8Array } from "./util-utf8/toUint8Array.browser";
 export { toUtf8 } from "./util-utf8/toUtf8.browser";
-export { fromArrayBuffer, fromString } from "./util-buffer-from/buffer-from";
+export const fromArrayBuffer = no;
+export const fromString = no;
 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 class Uint8ArrayBlobAdapter extends bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+}
 export { ChecksumStream } from "./util-stream/checksum/ChecksumStream.browser";
 export { createChecksumStream } from "./util-stream/checksum/createChecksumStream.browser";
 export { createBufferedReadable } from "./util-stream/createBufferedReadable.browser";

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

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

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

@@ -1,25 +1,23 @@
-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));
+export function bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+    return 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));
             }
-            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;
         }
-        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);
+        transformToString(encoding = "utf-8") {
+            if (encoding === "base64") {
+                return toBase64(this);
+            }
+            return toUtf8(this);
         }
-        return toUtf8(this);
-    }
+    };
 }

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

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

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

@@ -1,6 +1,6 @@
-import { toBase64 } from "../util-base64/toBase64";
+import { toBase64 } from "../util-base64/toBase64.browser";
 import { toHex } from "../util-hex-encoding/hex-encoding";
-import { toUtf8 } from "../util-utf8/toUtf8";
+import { toUtf8 } from "../util-utf8/toUtf8.browser";
 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.";

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

@@ -1,4 +1,4 @@
-import { fromBase64 } from "../util-base64/fromBase64";
+import { fromBase64 } from "../util-base64/fromBase64.browser";
 export const streamCollector = async (stream) => {
     if ((typeof Blob === "function" && stream instanceof Blob) || stream.constructor?.name === "Blob") {
         if (Blob.prototype.arrayBuffer !== undefined) {

package/node_modules/{@aws-crypto/util/node_modules/@smithy/util-utf8/dist-es/toUint8Array.js → @smithy/core/dist-es/submodules/serde/util-utf8/toUint8Array.browser.js}

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

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

@@ -1,3 +1,7 @@
+import { fromBase64 } from "./util-base64/fromBase64.browser";
+import { toBase64 } from "./util-base64/toBase64.browser";
+import { fromUtf8 } from "./util-utf8/fromUtf8.browser";
+import { toUtf8 } from "./util-utf8/toUtf8.browser";
 export { copyDocumentWithTransform } from "./copyDocumentWithTransform";
 export { dateToUtcString, parseRfc3339DateTime, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, parseEpochTimestamp, } from "./date-utils";
 export { LazyJsonString, type AutomaticJsonStringConversion } from "./lazy-json";
@@ -8,19 +12,21 @@ export { splitEvery } from "./split-every";
 export { splitHeader } from "./split-header";
 export { NumericValue, nv, type NumericType } 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 { toBase64, fromBase64 };
 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, type StringEncoding } from "./util-buffer-from/buffer-from";
+export { toUint8Array } from "./util-utf8/toUint8Array.browser";
+export { toUtf8, fromUtf8 };
+export { type StringEncoding } from "./util-buffer-from/buffer-from";
+export declare const fromArrayBuffer: symbol;
+export declare const fromString: symbol;
 export { isArrayBuffer } from "./is-array-buffer/is-array-buffer";
 export { deserializerMiddleware } from "./middleware-serde/deserializerMiddleware";
 export { deserializerMiddlewareOption, serializerMiddlewareOption, getSerdePlugin, type V1OrV2Endpoint, } from "./middleware-serde/serdePlugin";
 export { serializerMiddleware } from "./middleware-serde/serializerMiddleware";
 export declare const Hash: symbol;
-export { Uint8ArrayBlobAdapter } from "./util-stream/blob/Uint8ArrayBlobAdapter";
+declare const Uint8ArrayBlobAdapter_base: import("./util-stream/blob/Uint8ArrayBlobAdapter").Uint8ArrayBlobAdapterConstructor;
+export declare class Uint8ArrayBlobAdapter extends Uint8ArrayBlobAdapter_base {
+}
 export { ChecksumStream, type ChecksumStreamInit } from "./util-stream/checksum/ChecksumStream.browser";
 export { createChecksumStream } from "./util-stream/checksum/createChecksumStream.browser";
 export { createBufferedReadable } from "./util-stream/createBufferedReadable.browser";

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

@@ -1,3 +1,7 @@
+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 { copyDocumentWithTransform } from "./copyDocumentWithTransform";
 export { dateToUtcString, parseRfc3339DateTime, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, parseEpochTimestamp, } from "./date-utils";
 export { LazyJsonString, type AutomaticJsonStringConversion } from "./lazy-json";
@@ -8,19 +12,19 @@ export { splitEvery } from "./split-every";
 export { splitHeader } from "./split-header";
 export { NumericValue, nv, type NumericType } 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 { toBase64, fromBase64 };
 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 { toUtf8, fromUtf8 };
 export { fromArrayBuffer, fromString, type StringEncoding } 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, type V1OrV2Endpoint, } from "./middleware-serde/serdePlugin";
 export { serializerMiddleware } from "./middleware-serde/serializerMiddleware";
 export { Hash } from "./hash-node/hash-node";
-export { Uint8ArrayBlobAdapter } from "./util-stream/blob/Uint8ArrayBlobAdapter";
+declare const Uint8ArrayBlobAdapter_base: import("./util-stream/blob/Uint8ArrayBlobAdapter").Uint8ArrayBlobAdapterConstructor;
+export declare class Uint8ArrayBlobAdapter extends Uint8ArrayBlobAdapter_base {
+}
 export { ChecksumStream, type ChecksumStreamInit } from "./util-stream/checksum/ChecksumStream";
 export { createChecksumStream } from "./util-stream/checksum/createChecksumStream";
 export { createBufferedReadable } from "./util-stream/createBufferedReadable";

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

@@ -12,15 +12,19 @@ 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 { toUint8Array } from "./util-utf8/toUint8Array.browser";
 export { toUtf8 } from "./util-utf8/toUtf8.browser";
-export { fromArrayBuffer, fromString, type StringEncoding } from "./util-buffer-from/buffer-from";
+export { type StringEncoding } from "./util-buffer-from/buffer-from";
+export declare const fromArrayBuffer: symbol;
+export declare const fromString: symbol;
 export { isArrayBuffer } from "./is-array-buffer/is-array-buffer";
 export { deserializerMiddleware } from "./middleware-serde/deserializerMiddleware";
 export { deserializerMiddlewareOption, serializerMiddlewareOption, getSerdePlugin, type V1OrV2Endpoint, } from "./middleware-serde/serdePlugin";
 export { serializerMiddleware } from "./middleware-serde/serializerMiddleware";
 export declare const Hash: symbol;
-export { Uint8ArrayBlobAdapter } from "./util-stream/blob/Uint8ArrayBlobAdapter";
+declare const Uint8ArrayBlobAdapter_base: import("./util-stream/blob/Uint8ArrayBlobAdapter").Uint8ArrayBlobAdapterConstructor;
+export declare class Uint8ArrayBlobAdapter extends Uint8ArrayBlobAdapter_base {
+}
 export { ChecksumStream, type ChecksumStreamInit } from "./util-stream/checksum/ChecksumStream.browser";
 export { createChecksumStream } from "./util-stream/checksum/createChecksumStream.browser";
 export { createBufferedReadable } from "./util-stream/createBufferedReadable.browser";