@junando/worker 0.16.1 → 0.16.3

package/dist/event-streams-D0peAKGF.cjs

@@ -0,0 +1,1676 @@
+const require_rolldown_runtime = require('./rolldown-runtime-BDXX5GFZ.cjs');
+const require_serde = require('./serde-BKDOXNkW.cjs');
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+let node_stream = require("node:stream");
+let node_zlib = require("node:zlib");
+node_zlib = require_rolldown_runtime.__toESM(node_zlib);
+
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/chunked-blob-reader/chunked-blob-reader.js
+async function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
+	const size = blob.size;
+	let totalBytesRead = 0;
+	while (totalBytesRead < size) {
+		const slice = blob.slice(totalBytesRead, Math.min(size, totalBytesRead + chunkSize));
+		onChunk(new Uint8Array(await slice.arrayBuffer()));
+		totalBytesRead += slice.size;
+	}
+}
+var init_chunked_blob_reader = require_rolldown_runtime.__esmMin((() => {}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/hash-blob-browser/blobHasher.js
+var blobHasher;
+var init_blobHasher = require_rolldown_runtime.__esmMin((() => {
+	init_chunked_blob_reader();
+	blobHasher = async function blobHasher(hashCtor, blob) {
+		const hash = new hashCtor();
+		await blobReader(blob, (chunk) => {
+			hash.update(chunk);
+		});
+		return hash.digest();
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/hash-stream-node/HashCalculator.js
+var HashCalculator;
+var init_HashCalculator = require_rolldown_runtime.__esmMin((() => {
+	require_serde.init_serde();
+	HashCalculator = class extends node_stream.Writable {
+		hash;
+		constructor(hash, options) {
+			super(options);
+			this.hash = hash;
+		}
+		_write(chunk, encoding, callback) {
+			try {
+				this.hash.update(require_serde.toUint8Array(chunk));
+			} catch (err) {
+				return callback(err);
+			}
+			callback();
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/hash-stream-node/fileStreamHasher.js
+var fileStreamHasher, isReadStream;
+var init_fileStreamHasher = require_rolldown_runtime.__esmMin((() => {
+	init_HashCalculator();
+	fileStreamHasher = (hashCtor, fileStream) => new Promise((resolve, reject) => {
+		if (!isReadStream(fileStream)) {
+			reject(new Error("Unable to calculate hash for non-file streams."));
+			return;
+		}
+		const fileStreamTee = (0, node_fs.createReadStream)(fileStream.path, {
+			start: fileStream.start,
+			end: fileStream.end
+		});
+		const hash = new hashCtor();
+		const hashCalculator = new HashCalculator(hash);
+		fileStreamTee.pipe(hashCalculator);
+		fileStreamTee.on("error", (err) => {
+			hashCalculator.end();
+			reject(err);
+		});
+		hashCalculator.on("error", reject);
+		hashCalculator.on("finish", function() {
+			hash.digest().then(resolve).catch(reject);
+		});
+	});
+	isReadStream = (stream) => typeof stream.path === "string";
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/hash-stream-node/readableStreamHasher.js
+var readableStreamHasher;
+var init_readableStreamHasher = require_rolldown_runtime.__esmMin((() => {
+	init_HashCalculator();
+	readableStreamHasher = (hashCtor, readableStream) => {
+		if (readableStream.readableFlowing !== null) {
+			throw new Error("Unable to calculate hash for flowing readable stream");
+		}
+		const hash = new hashCtor();
+		const hashCalculator = new HashCalculator(hash);
+		readableStream.pipe(hashCalculator);
+		return new Promise((resolve, reject) => {
+			readableStream.on("error", (err) => {
+				hashCalculator.end();
+				reject(err);
+			});
+			hashCalculator.on("error", reject);
+			hashCalculator.on("finish", () => {
+				hash.digest().then(resolve).catch(reject);
+			});
+		});
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/md5/Md5Js.js
+function compress(state, block) {
+	let a = state[0], b = state[1], c = state[2], d = state[3];
+	for (let i = 0; i < 64; ++i) {
+		let f, g;
+		if (i < 16) {
+			f = b & c | ~b & d;
+			g = i;
+		} else if (i < 32) {
+			f = d & b | c & ~d;
+			g = (5 * i + 1) % 16;
+		} else if (i < 48) {
+			f = b ^ c ^ d;
+			g = (3 * i + 5) % 16;
+		} else {
+			f = c ^ (b | ~d);
+			g = 7 * i % 16;
+		}
+		const x = block.getUint32(g * 4, true);
+		const tmp = d;
+		d = c;
+		c = b;
+		const s = S[(i >> 4) * 4 + (i & 3)];
+		const sum = (a + f & M) + (x + T[i] & M) & M;
+		b = b + ((sum << s | sum >>> 32 - s) >>> 0) & M;
+		a = tmp;
+	}
+	state[0] = state[0] + a & M;
+	state[1] = state[1] + b & M;
+	state[2] = state[2] + c & M;
+	state[3] = state[3] + d & M;
+}
+var Md5Js, INIT$1, M, S, T;
+var init_Md5Js = require_rolldown_runtime.__esmMin((() => {
+	require_serde.init_serde();
+	Md5Js = class {
+		digestLength = 16;
+		state = Uint32Array.from(INIT$1);
+		writeBuffer = new DataView(new ArrayBuffer(64));
+		bufferLength = 0;
+		bytesHashed = 0;
+		update(sourceData) {
+			const data = require_serde.toUint8Array(sourceData);
+			let pos = 0;
+			let len = data.byteLength;
+			this.bytesHashed += len;
+			while (len > 0) {
+				this.writeBuffer.setUint8(this.bufferLength++, data[pos++]);
+				--len;
+				if (this.bufferLength === 64) {
+					compress(this.state, this.writeBuffer);
+					this.bufferLength = 0;
+				}
+			}
+		}
+		async digest() {
+			const state = Uint32Array.from(this.state);
+			const buf = new DataView(this.writeBuffer.buffer.slice(0));
+			let bufLen = this.bufferLength;
+			const bits = this.bytesHashed * 8;
+			buf.setUint8(bufLen++, 128);
+			if (this.bufferLength % 64 >= 56) {
+				for (let i = bufLen; i < 64; ++i) {
+					buf.setUint8(i, 0);
+				}
+				compress(state, buf);
+				bufLen = 0;
+			}
+			for (let i = bufLen; i < 56; ++i) {
+				buf.setUint8(i, 0);
+			}
+			buf.setUint32(56, bits >>> 0, true);
+			buf.setUint32(60, Math.floor(bits / 2 ** 32), true);
+			compress(state, buf);
+			const out = new Uint8Array(16);
+			const view = new DataView(out.buffer);
+			for (let i = 0; i < 4; ++i) {
+				view.setUint32(i * 4, state[i], true);
+			}
+			return out;
+		}
+		reset() {
+			this.state.set(INIT$1);
+			this.writeBuffer = new DataView(new ArrayBuffer(64));
+			this.bufferLength = 0;
+			this.bytesHashed = 0;
+		}
+	};
+	INIT$1 = [
+		1732584193,
+		4023233417,
+		2562383102,
+		271733878
+	];
+	M = 4294967295;
+	S = Uint8Array.of(7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21);
+	T = Array.from({ length: 64 }, (_, i) => Math.abs(Math.sin(i + 1)) * 2 ** 32 >>> 0);
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/md5/Md5Node.js
+function buildNativeClass$2() {
+	return class Md5Node {
+		digestLength = 16;
+		hash = (0, node_crypto.createHash)("md5");
+		update(data) {
+			this.hash.update(require_serde.toUint8Array(data));
+		}
+		async digest() {
+			const buf = this.hash.copy().digest();
+			return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+		}
+		reset() {
+			this.hash = (0, node_crypto.createHash)("md5");
+		}
+	};
+}
+var hasNativeCrypto$1, Md5Node;
+var init_Md5Node = require_rolldown_runtime.__esmMin((() => {
+	require_serde.init_serde();
+	init_Md5Js();
+	hasNativeCrypto$1 = (() => {
+		try {
+			(0, node_crypto.createHash)("md5");
+			return true;
+		} catch {
+			return false;
+		}
+	})();
+	Md5Node = hasNativeCrypto$1 ? buildNativeClass$2() : Md5Js;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/crc32/Crc32Js.js
+var CRC32_TABLE, ONES, Crc32Js;
+var init_Crc32Js = require_rolldown_runtime.__esmMin((() => {
+	CRC32_TABLE = new Uint32Array(256);
+	for (let i = 0; i < 256; ++i) {
+		let c = i;
+		for (let j = 0; j < 8; ++j) {
+			c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+		}
+		CRC32_TABLE[i] = c >>> 0;
+	}
+	ONES = 4294967295;
+	Crc32Js = class {
+		digestLength = 4;
+		checksum = ONES;
+		update(data) {
+			for (let i = 0; i < data.length; ++i) {
+				this.checksum = this.checksum >>> 8 ^ CRC32_TABLE[(this.checksum ^ data[i]) & 255];
+			}
+		}
+		digestSync() {
+			return (this.checksum ^ ONES) >>> 0;
+		}
+		async digest() {
+			const value = this.digestSync();
+			const out = new Uint8Array(4);
+			new DataView(out.buffer).setUint32(0, value, false);
+			return out;
+		}
+		reset() {
+			this.checksum = ONES;
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/crc32/Crc32Node.js
+function buildNativeClass$1(nativeCrc32) {
+	return class Crc32Node {
+		digestLength = 4;
+		value = 0;
+		update(data) {
+			this.value = nativeCrc32(data, this.value);
+		}
+		digestSync() {
+			return this.value >>> 0;
+		}
+		async digest() {
+			const out = new Uint8Array(4);
+			new DataView(out.buffer).setUint32(0, this.digestSync(), false);
+			return out;
+		}
+		reset() {
+			this.value = 0;
+		}
+	};
+}
+var zlibCrc32, Crc32Node;
+var init_Crc32Node = require_rolldown_runtime.__esmMin((() => {
+	init_Crc32Js();
+	zlibCrc32 = typeof node_zlib.crc32 === "function" ? node_zlib.crc32 : undefined;
+	Crc32Node = zlibCrc32 ? buildNativeClass$1(zlibCrc32) : Crc32Js;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/sha256/Sha256Js.js
+var BLOCK, DIGEST_LENGTH, MAX_HASHABLE_LENGTH, Sha256Js, INIT, K;
+var init_Sha256Js = require_rolldown_runtime.__esmMin((() => {
+	require_serde.init_serde();
+	BLOCK = 64;
+	DIGEST_LENGTH = 32;
+	MAX_HASHABLE_LENGTH = 2 ** 53 - 1;
+	Sha256Js = class Sha256Js {
+		digestLength = DIGEST_LENGTH;
+		state = Int32Array.from(INIT);
+		w;
+		buffer = new Uint8Array(64);
+		bufferLength = 0;
+		bytesHashed = 0;
+		finished = false;
+		inner;
+		outer;
+		constructor(secret) {
+			if (secret) {
+				const key = Sha256Js.normalizeKey(secret);
+				this.inner = new Sha256Js();
+				this.outer = new Sha256Js();
+				const { inner, outer } = this;
+				const pad = new Uint8Array(BLOCK * 2);
+				for (let i = 0; i < BLOCK; ++i) {
+					pad[i] = 54 ^ key[i];
+					pad[i + BLOCK] = 92 ^ key[i];
+				}
+				inner.update(pad.subarray(0, BLOCK));
+				outer.update(pad.subarray(BLOCK));
+			}
+		}
+		update(data) {
+			if (this.finished) {
+				throw new Error("Attempted to update an already finished HMAC.");
+			}
+			if (this.inner) {
+				this.inner.update(data);
+				return;
+			}
+			const chunk = require_serde.toUint8Array(data);
+			let position = 0;
+			let { byteLength } = chunk;
+			this.bytesHashed += byteLength;
+			if (this.bytesHashed * 8 > MAX_HASHABLE_LENGTH) {
+				throw new Error("Cannot hash more than 2^53 - 1 bits");
+			}
+			while (byteLength > 0) {
+				this.buffer[this.bufferLength++] = chunk[position++];
+				byteLength--;
+				if (this.bufferLength === BLOCK) {
+					this.hashBuffer();
+					this.bufferLength = 0;
+				}
+			}
+		}
+		async digest() {
+			const { inner, outer } = this;
+			if (inner && outer) {
+				if (this.finished) {
+					throw new Error("Attempted to digest an already finished HMAC.");
+				}
+				this.finished = true;
+				const innerDigest = inner.digestSync();
+				outer.update(innerDigest);
+				return outer.digestSync();
+			}
+			return this.digestSync();
+		}
+		reset() {
+			this.state = Int32Array.from(INIT);
+			this.buffer = new Uint8Array(64);
+			this.bufferLength = 0;
+			this.bytesHashed = 0;
+		}
+		digestSync() {
+			const state = this.state.slice();
+			const buffer = this.buffer.slice();
+			let bufferLength = this.bufferLength;
+			const bitsHashed = this.bytesHashed * 8;
+			const bufferView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+			bufferView.setUint8(bufferLength++, 128);
+			if ((bufferLength - 1) % BLOCK >= BLOCK - 8) {
+				for (let i = bufferLength; i < BLOCK; ++i) {
+					bufferView.setUint8(i, 0);
+				}
+				this.hashBufferWith(state, buffer);
+				bufferLength = 0;
+			}
+			for (let i = bufferLength; i < BLOCK - 8; ++i) {
+				bufferView.setUint8(i, 0);
+			}
+			bufferView.setUint32(BLOCK - 8, Math.floor(bitsHashed / 4294967296), false);
+			bufferView.setUint32(BLOCK - 4, bitsHashed, false);
+			this.hashBufferWith(state, buffer);
+			const out = new Uint8Array(DIGEST_LENGTH);
+			for (let i = 0; i < 8; ++i) {
+				out[i * 4] = state[i] >>> 24 & 255;
+				out[i * 4 + 1] = state[i] >>> 16 & 255;
+				out[i * 4 + 2] = state[i] >>> 8 & 255;
+				out[i * 4 + 3] = state[i] >>> 0 & 255;
+			}
+			return out;
+		}
+		static normalizeKey(secret) {
+			const key = require_serde.toUint8Array(secret);
+			if (key.byteLength > BLOCK) {
+				const h = new Sha256Js();
+				h.update(key);
+				const out = h.digestSync();
+				const padded = new Uint8Array(BLOCK);
+				padded.set(out);
+				return padded;
+			}
+			if (key.byteLength < BLOCK) {
+				const padded = new Uint8Array(BLOCK);
+				padded.set(key);
+				return padded;
+			}
+			return key;
+		}
+		hashBuffer() {
+			this.hashBufferWith(this.state, this.buffer);
+		}
+		hashBufferWith(state, buffer) {
+			const w = this.w ??= new Int32Array(64);
+			let s0 = state[0], s1 = state[1], s2 = state[2], s3 = state[3], s4 = state[4], s5 = state[5], s6 = state[6], s7 = state[7];
+			for (let i = 0; i < BLOCK; ++i) {
+				if (i < 16) {
+					w[i] = (buffer[i * 4] & 255) << 24 | (buffer[i * 4 + 1] & 255) << 16 | (buffer[i * 4 + 2] & 255) << 8 | buffer[i * 4 + 3] & 255;
+				} else {
+					let u = w[i - 2];
+					const t1 = (u >>> 17 | u << 15) ^ (u >>> 19 | u << 13) ^ u >>> 10;
+					u = w[i - 15];
+					const t2 = (u >>> 7 | u << 25) ^ (u >>> 18 | u << 14) ^ u >>> 3;
+					w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);
+				}
+				const t1 = (((s4 >>> 6 | s4 << 26) ^ (s4 >>> 11 | s4 << 21) ^ (s4 >>> 25 | s4 << 7)) + (s4 & s5 ^ ~s4 & s6) | 0) + (s7 + (K[i] + w[i] | 0) | 0) | 0;
+				const t2 = ((s0 >>> 2 | s0 << 30) ^ (s0 >>> 13 | s0 << 19) ^ (s0 >>> 22 | s0 << 10)) + (s0 & s1 ^ s0 & s2 ^ s1 & s2) | 0;
+				s7 = s6;
+				s6 = s5;
+				s5 = s4;
+				s4 = s3 + t1 | 0;
+				s3 = s2;
+				s2 = s1;
+				s1 = s0;
+				s0 = t1 + t2 | 0;
+			}
+			state[0] += s0;
+			state[1] += s1;
+			state[2] += s2;
+			state[3] += s3;
+			state[4] += s4;
+			state[5] += s5;
+			state[6] += s6;
+			state[7] += s7;
+		}
+	};
+	INIT = new Int32Array([
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	]);
+	K = new Int32Array([
+		1116352408,
+		1899447441,
+		3049323471,
+		3921009573,
+		961987163,
+		1508970993,
+		2453635748,
+		2870763221,
+		3624381080,
+		310598401,
+		607225278,
+		1426881987,
+		1925078388,
+		2162078206,
+		2614888103,
+		3248222580,
+		3835390401,
+		4022224774,
+		264347078,
+		604807628,
+		770255983,
+		1249150122,
+		1555081692,
+		1996064986,
+		2554220882,
+		2821834349,
+		2952996808,
+		3210313671,
+		3336571891,
+		3584528711,
+		113926993,
+		338241895,
+		666307205,
+		773529912,
+		1294757372,
+		1396182291,
+		1695183700,
+		1986661051,
+		2177026350,
+		2456956037,
+		2730485921,
+		2820302411,
+		3259730800,
+		3345764771,
+		3516065817,
+		3600352804,
+		4094571909,
+		275423344,
+		430227734,
+		506948616,
+		659060556,
+		883997877,
+		958139571,
+		1322822218,
+		1537002063,
+		1747873779,
+		1955562222,
+		2024104815,
+		2227730452,
+		2361852424,
+		2428436474,
+		2756734187,
+		3204031479,
+		3329325298
+	]);
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/sha256/Sha256Node.js
+function buildNativeClass() {
+	return class Sha256Node {
+		digestLength = 32;
+		secret;
+		hash;
+		isHmac;
+		finished = false;
+		constructor(secret) {
+			this.secret = secret;
+			this.isHmac = !!secret;
+			this.hash = this.createHash();
+		}
+		update(data) {
+			if (this.finished) {
+				throw new Error("Attempted to update an already finished hash.");
+			}
+			this.hash.update(data);
+		}
+		async digest() {
+			let buf;
+			if (this.isHmac) {
+				this.finished = true;
+				buf = this.hash.digest();
+			} else {
+				buf = this.hash.copy().digest();
+			}
+			return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+		}
+		reset() {
+			this.hash = this.createHash();
+			this.finished = false;
+		}
+		createHash() {
+			return this.secret ? (0, node_crypto.createHmac)("sha256", toBuffer(this.secret)) : (0, node_crypto.createHash)("sha256");
+		}
+	};
+}
+function toBuffer(data) {
+	if (typeof data === "string") {
+		return data;
+	}
+	if (ArrayBuffer.isView(data)) {
+		return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+	}
+	return Buffer.from(data);
+}
+var hasNativeCrypto, Sha256Node;
+var init_Sha256Node = require_rolldown_runtime.__esmMin((() => {
+	init_Sha256Js();
+	hasNativeCrypto = (() => {
+		try {
+			(0, node_crypto.createHash)("sha256");
+			return true;
+		} catch {
+			return false;
+		}
+	})();
+	Sha256Node = hasNativeCrypto ? buildNativeClass() : Sha256Js;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/sha256/Sha256WebCrypto.js
+var digest, sign, importKey, subtle, MAX_PENDING_BYTES, Sha256WebCrypto;
+var init_Sha256WebCrypto = require_rolldown_runtime.__esmMin((() => {
+	require_serde.init_serde();
+	init_Sha256Js();
+	({digest, sign, importKey} = globalThis?.crypto?.subtle ?? {});
+	subtle = typeof digest === "function" && typeof sign === "function" && typeof importKey === "function" ? globalThis.crypto.subtle : undefined;
+	MAX_PENDING_BYTES = 8 * 1024 * 1024;
+	Sha256WebCrypto = class {
+		digestLength = 32;
+		secret;
+		pending = [];
+		pendingBytes = 0;
+		fallback;
+		finished = false;
+		constructor(secret) {
+			if (secret) {
+				this.secret = require_serde.toUint8Array(secret);
+			}
+		}
+		update(data) {
+			if (this.finished) {
+				throw new Error("Attempted to update an already finished HMAC.");
+			}
+			if (this.fallback) {
+				this.fallback.update(data);
+				return;
+			}
+			this.pending.push(data.slice());
+			this.pendingBytes += data.byteLength;
+			if (this.pendingBytes >= MAX_PENDING_BYTES) {
+				this.switchToFallback();
+			}
+		}
+		async digest() {
+			if (this.fallback) {
+				return this.fallback.digest();
+			}
+			if (this.secret && this.finished) {
+				throw new Error("Attempted to digest an already finished HMAC.");
+			}
+			const data = require_serde.concatBytes(this.pending);
+			if (subtle) {
+				if (this.secret) {
+					this.finished = true;
+					const key = await subtle.importKey("raw", this.secret, {
+						name: "HMAC",
+						hash: "SHA-256"
+					}, false, ["sign"]);
+					const sig = await subtle.sign("HMAC", key, data);
+					return new Uint8Array(sig);
+				}
+				const hash = await subtle.digest("SHA-256", data);
+				return new Uint8Array(hash);
+			}
+			const sha256 = new Sha256Js(this.secret);
+			sha256.update(data);
+			return sha256.digest();
+		}
+		reset() {
+			this.pending = [];
+			this.pendingBytes = 0;
+			this.fallback = undefined;
+			this.finished = false;
+		}
+		switchToFallback() {
+			const sha256Js = new Sha256Js(this.secret);
+			for (const chunk of this.pending) {
+				sha256Js.update(chunk);
+			}
+			this.fallback = sha256Js;
+			this.pending = [];
+			this.pendingBytes = 0;
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/checksum/index.js
+var init_checksum = require_rolldown_runtime.__esmMin((() => {
+	init_blobHasher();
+	init_fileStreamHasher();
+	init_readableStreamHasher();
+	init_Md5Js();
+	init_Md5Node();
+	init_Crc32Js();
+	init_Crc32Node();
+	init_Sha256Js();
+	init_Sha256Node();
+	init_Sha256WebCrypto();
+	init_chunked_blob_reader();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/Int64.js
+function negate(bytes) {
+	for (let i = 0; i < 8; i++) {
+		bytes[i] ^= 255;
+	}
+	for (let i = 7; i > -1; i--) {
+		bytes[i]++;
+		if (bytes[i] !== 0) break;
+	}
+}
+var Int64;
+var init_Int64 = require_rolldown_runtime.__esmMin((() => {
+	require_serde.init_serde();
+	Int64 = class Int64 {
+		bytes;
+		constructor(bytes) {
+			this.bytes = bytes;
+			if (bytes.byteLength !== 8) {
+				throw new Error("Int64 buffers must be exactly 8 bytes");
+			}
+		}
+		static fromNumber(number) {
+			if (number > 0x8000000000000000 || number < -0x8000000000000000) {
+				throw new Error(`${number} is too large (or, if negative, too small) to represent as an Int64`);
+			}
+			const bytes = new Uint8Array(8);
+			for (let i = 7, remaining = Math.abs(Math.round(number)); i > -1 && remaining > 0; i--, remaining /= 256) {
+				bytes[i] = remaining;
+			}
+			if (number < 0) {
+				negate(bytes);
+			}
+			return new Int64(bytes);
+		}
+		valueOf() {
+			const bytes = this.bytes.slice(0);
+			const negative = bytes[0] & 128;
+			if (negative) {
+				negate(bytes);
+			}
+			return parseInt(require_serde.toHex(bytes), 16) * (negative ? -1 : 1);
+		}
+		toString() {
+			return String(this.valueOf());
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/HeaderMarshaller.js
+var HeaderMarshaller, HEADER_VALUE_TYPE, BOOLEAN_TAG, BYTE_TAG, SHORT_TAG, INT_TAG, LONG_TAG, BINARY_TAG, STRING_TAG, TIMESTAMP_TAG, UUID_TAG, UUID_PATTERN;
+var init_HeaderMarshaller = require_rolldown_runtime.__esmMin((() => {
+	require_serde.init_transport();
+	require_serde.init_serde();
+	init_Int64();
+	HeaderMarshaller = class {
+		toUtf8;
+		fromUtf8;
+		constructor(toUtf8, fromUtf8) {
+			this.toUtf8 = toUtf8;
+			this.fromUtf8 = fromUtf8;
+		}
+		format(headers) {
+			const chunks = [];
+			for (const headerName in headers) {
+				if (!require_serde.hasOwn(headers, headerName)) continue;
+				const bytes = this.fromUtf8(headerName);
+				chunks.push(Uint8Array.from([bytes.byteLength]), bytes, this.formatHeaderValue(headers[headerName]));
+			}
+			const out = new Uint8Array(chunks.reduce((carry, bytes) => carry + bytes.byteLength, 0));
+			let position = 0;
+			for (const chunk of chunks) {
+				out.set(chunk, position);
+				position += chunk.byteLength;
+			}
+			return out;
+		}
+		formatHeaderValue(header) {
+			switch (header.type) {
+				case "boolean": return Uint8Array.from([header.value ? 0 : 1]);
+				case "byte": return Uint8Array.from([2, header.value]);
+				case "short":
+					const shortView = new DataView(new ArrayBuffer(3));
+					shortView.setUint8(0, 3);
+					shortView.setInt16(1, header.value, false);
+					return new Uint8Array(shortView.buffer);
+				case "integer":
+					const intView = new DataView(new ArrayBuffer(5));
+					intView.setUint8(0, 4);
+					intView.setInt32(1, header.value, false);
+					return new Uint8Array(intView.buffer);
+				case "long":
+					const longBytes = new Uint8Array(9);
+					longBytes[0] = 5;
+					longBytes.set(header.value.bytes, 1);
+					return longBytes;
+				case "binary":
+					const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
+					binView.setUint8(0, 6);
+					binView.setUint16(1, header.value.byteLength, false);
+					const binBytes = new Uint8Array(binView.buffer);
+					binBytes.set(header.value, 3);
+					return binBytes;
+				case "string":
+					const utf8Bytes = this.fromUtf8(header.value);
+					const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
+					strView.setUint8(0, 7);
+					strView.setUint16(1, utf8Bytes.byteLength, false);
+					const strBytes = new Uint8Array(strView.buffer);
+					strBytes.set(utf8Bytes, 3);
+					return strBytes;
+				case "timestamp":
+					const tsBytes = new Uint8Array(9);
+					tsBytes[0] = 8;
+					tsBytes.set(Int64.fromNumber(header.value.valueOf()).bytes, 1);
+					return tsBytes;
+				case "uuid":
+					if (!UUID_PATTERN.test(header.value)) {
+						throw new Error(`Invalid UUID received: ${header.value}`);
+					}
+					const uuidBytes = new Uint8Array(17);
+					uuidBytes[0] = 9;
+					uuidBytes.set(require_serde.fromHex(header.value.replace(/-/g, "")), 1);
+					return uuidBytes;
+			}
+		}
+		parse(headers) {
+			const out = {};
+			let position = 0;
+			while (position < headers.byteLength) {
+				const nameLength = headers.getUint8(position++);
+				const name = this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, nameLength));
+				position += nameLength;
+				switch (headers.getUint8(position++)) {
+					case 0:
+						out[name] = {
+							type: BOOLEAN_TAG,
+							value: true
+						};
+						break;
+					case 1:
+						out[name] = {
+							type: BOOLEAN_TAG,
+							value: false
+						};
+						break;
+					case 2:
+						out[name] = {
+							type: BYTE_TAG,
+							value: headers.getInt8(position++)
+						};
+						break;
+					case 3:
+						out[name] = {
+							type: SHORT_TAG,
+							value: headers.getInt16(position, false)
+						};
+						position += 2;
+						break;
+					case 4:
+						out[name] = {
+							type: INT_TAG,
+							value: headers.getInt32(position, false)
+						};
+						position += 4;
+						break;
+					case 5:
+						out[name] = {
+							type: LONG_TAG,
+							value: new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8))
+						};
+						position += 8;
+						break;
+					case 6:
+						const binaryLength = headers.getUint16(position, false);
+						position += 2;
+						out[name] = {
+							type: BINARY_TAG,
+							value: new Uint8Array(headers.buffer, headers.byteOffset + position, binaryLength)
+						};
+						position += binaryLength;
+						break;
+					case 7:
+						const stringLength = headers.getUint16(position, false);
+						position += 2;
+						out[name] = {
+							type: STRING_TAG,
+							value: this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, stringLength))
+						};
+						position += stringLength;
+						break;
+					case 8:
+						out[name] = {
+							type: TIMESTAMP_TAG,
+							value: new Date(new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8)).valueOf())
+						};
+						position += 8;
+						break;
+					case 9:
+						const uuidBytes = new Uint8Array(headers.buffer, headers.byteOffset + position, 16);
+						position += 16;
+						out[name] = {
+							type: UUID_TAG,
+							value: `${require_serde.toHex(uuidBytes.subarray(0, 4))}-${require_serde.toHex(uuidBytes.subarray(4, 6))}-${require_serde.toHex(uuidBytes.subarray(6, 8))}-${require_serde.toHex(uuidBytes.subarray(8, 10))}-${require_serde.toHex(uuidBytes.subarray(10))}`
+						};
+						break;
+					default: throw new Error(`Unrecognized header type tag`);
+				}
+			}
+			return out;
+		}
+	};
+	;
+	(function(HEADER_VALUE_TYPE) {
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["boolTrue"] = 0] = "boolTrue";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["boolFalse"] = 1] = "boolFalse";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["byte"] = 2] = "byte";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["short"] = 3] = "short";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["integer"] = 4] = "integer";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["long"] = 5] = "long";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["byteArray"] = 6] = "byteArray";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["string"] = 7] = "string";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["timestamp"] = 8] = "timestamp";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["uuid"] = 9] = "uuid";
+	})(HEADER_VALUE_TYPE || (HEADER_VALUE_TYPE = {}));
+	BOOLEAN_TAG = "boolean";
+	BYTE_TAG = "byte";
+	SHORT_TAG = "short";
+	INT_TAG = "integer";
+	LONG_TAG = "long";
+	BINARY_TAG = "binary";
+	STRING_TAG = "string";
+	TIMESTAMP_TAG = "timestamp";
+	UUID_TAG = "uuid";
+	UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/splitMessage.js
+function splitMessage({ byteLength, byteOffset, buffer }) {
+	if (byteLength < MINIMUM_MESSAGE_LENGTH) {
+		throw new Error("Provided message too short to accommodate event stream message overhead");
+	}
+	const view = new DataView(buffer, byteOffset, byteLength);
+	const messageLength = view.getUint32(0, false);
+	if (byteLength !== messageLength) {
+		throw new Error("Reported message length does not match received message length");
+	}
+	const headerLength = view.getUint32(PRELUDE_MEMBER_LENGTH, false);
+	const expectedPreludeChecksum = view.getUint32(PRELUDE_LENGTH, false);
+	const expectedMessageChecksum = view.getUint32(byteLength - CHECKSUM_LENGTH, false);
+	const checksummer = new Crc32Node();
+	checksummer.update(new Uint8Array(buffer, byteOffset, PRELUDE_LENGTH));
+	if (expectedPreludeChecksum !== checksummer.digestSync()) {
+		throw new Error(`The prelude checksum specified in the message (${expectedPreludeChecksum}) does not match the calculated CRC32 checksum (${checksummer.digestSync()})`);
+	}
+	checksummer.update(new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH, byteLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH)));
+	if (expectedMessageChecksum !== checksummer.digestSync()) {
+		throw new Error(`The message checksum (${checksummer.digestSync()}) did not match the expected value of ${expectedMessageChecksum}`);
+	}
+	return {
+		headers: new DataView(buffer, byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH, headerLength),
+		body: new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH + headerLength, messageLength - headerLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH + CHECKSUM_LENGTH))
+	};
+}
+var PRELUDE_MEMBER_LENGTH, PRELUDE_LENGTH, CHECKSUM_LENGTH, MINIMUM_MESSAGE_LENGTH;
+var init_splitMessage = require_rolldown_runtime.__esmMin((() => {
+	init_checksum();
+	PRELUDE_MEMBER_LENGTH = 4;
+	PRELUDE_LENGTH = PRELUDE_MEMBER_LENGTH * 2;
+	CHECKSUM_LENGTH = 4;
+	MINIMUM_MESSAGE_LENGTH = PRELUDE_LENGTH + CHECKSUM_LENGTH * 2;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/EventStreamCodec.js
+var EventStreamCodec;
+var init_EventStreamCodec = require_rolldown_runtime.__esmMin((() => {
+	init_checksum();
+	init_HeaderMarshaller();
+	init_splitMessage();
+	EventStreamCodec = class {
+		headerMarshaller;
+		messageBuffer;
+		isEndOfStream;
+		constructor(toUtf8, fromUtf8) {
+			this.headerMarshaller = new HeaderMarshaller(toUtf8, fromUtf8);
+			this.messageBuffer = [];
+			this.isEndOfStream = false;
+		}
+		feed(message) {
+			this.messageBuffer.push(this.decode(message));
+		}
+		endOfStream() {
+			this.isEndOfStream = true;
+		}
+		getMessage() {
+			const message = this.messageBuffer.pop();
+			const isEndOfStream = this.isEndOfStream;
+			return {
+				getMessage() {
+					return message;
+				},
+				isEndOfStream() {
+					return isEndOfStream;
+				}
+			};
+		}
+		getAvailableMessages() {
+			const messages = this.messageBuffer;
+			this.messageBuffer = [];
+			const isEndOfStream = this.isEndOfStream;
+			return {
+				getMessages() {
+					return messages;
+				},
+				isEndOfStream() {
+					return isEndOfStream;
+				}
+			};
+		}
+		encode({ headers: rawHeaders, body }) {
+			const headers = this.headerMarshaller.format(rawHeaders);
+			const length = headers.byteLength + body.byteLength + 16;
+			const out = new Uint8Array(length);
+			const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+			const checksum = new Crc32Node();
+			view.setUint32(0, length, false);
+			view.setUint32(4, headers.byteLength, false);
+			checksum.update(out.subarray(0, 8));
+			view.setUint32(8, checksum.digestSync(), false);
+			out.set(headers, 12);
+			out.set(body, headers.byteLength + 12);
+			checksum.update(out.subarray(8, length - 4));
+			view.setUint32(length - 4, checksum.digestSync(), false);
+			return out;
+		}
+		decode(message) {
+			const { headers, body } = splitMessage(message);
+			return {
+				headers: this.headerMarshaller.parse(headers),
+				body
+			};
+		}
+		formatHeaders(rawHeaders) {
+			return this.headerMarshaller.format(rawHeaders);
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/MessageDecoderStream.js
+var MessageDecoderStream;
+var init_MessageDecoderStream = require_rolldown_runtime.__esmMin((() => {
+	MessageDecoderStream = class {
+		options;
+		constructor(options) {
+			this.options = options;
+		}
+		[Symbol.asyncIterator]() {
+			return this.asyncIterator();
+		}
+		async *asyncIterator() {
+			for await (const bytes of this.options.inputStream) {
+				const decoded = this.options.decoder.decode(bytes);
+				yield decoded;
+			}
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/MessageEncoderStream.js
+var MessageEncoderStream;
+var init_MessageEncoderStream = require_rolldown_runtime.__esmMin((() => {
+	MessageEncoderStream = class {
+		options;
+		constructor(options) {
+			this.options = options;
+		}
+		[Symbol.asyncIterator]() {
+			return this.asyncIterator();
+		}
+		async *asyncIterator() {
+			for await (const msg of this.options.messageStream) {
+				const encoded = this.options.encoder.encode(msg);
+				yield encoded;
+			}
+			if (this.options.includeEndFrame) {
+				yield new Uint8Array(0);
+			}
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/SmithyMessageDecoderStream.js
+var SmithyMessageDecoderStream;
+var init_SmithyMessageDecoderStream = require_rolldown_runtime.__esmMin((() => {
+	SmithyMessageDecoderStream = class {
+		options;
+		constructor(options) {
+			this.options = options;
+		}
+		[Symbol.asyncIterator]() {
+			return this.asyncIterator();
+		}
+		async *asyncIterator() {
+			for await (const message of this.options.messageStream) {
+				const deserialized = await this.options.deserializer(message);
+				if (deserialized === undefined) continue;
+				yield deserialized;
+			}
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/SmithyMessageEncoderStream.js
+var SmithyMessageEncoderStream;
+var init_SmithyMessageEncoderStream = require_rolldown_runtime.__esmMin((() => {
+	SmithyMessageEncoderStream = class {
+		options;
+		constructor(options) {
+			this.options = options;
+		}
+		[Symbol.asyncIterator]() {
+			return this.asyncIterator();
+		}
+		async *asyncIterator() {
+			for await (const chunk of this.options.inputStream) {
+				const payloadBuf = this.options.serializer(chunk);
+				yield payloadBuf;
+			}
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde-universal/getChunkedStream.js
+function getChunkedStream(source) {
+	let currentMessageTotalLength = 0;
+	let currentMessagePendingLength = 0;
+	let currentMessage = null;
+	let messageLengthBuffer = null;
+	const allocateMessage = (size) => {
+		if (typeof size !== "number") {
+			throw new Error("Attempted to allocate an event message where size was not a number: " + size);
+		}
+		currentMessageTotalLength = size;
+		currentMessagePendingLength = 4;
+		currentMessage = new Uint8Array(size);
+		const currentMessageView = new DataView(currentMessage.buffer);
+		currentMessageView.setUint32(0, size, false);
+	};
+	const iterator = async function* () {
+		const sourceIterator = source[Symbol.asyncIterator]();
+		while (true) {
+			const { value, done } = await sourceIterator.next();
+			if (done) {
+				if (!currentMessageTotalLength) {
+					return;
+				} else if (currentMessageTotalLength === currentMessagePendingLength) {
+					yield currentMessage;
+				} else {
+					throw new Error("Truncated event message received.");
+				}
+				return;
+			}
+			const chunkLength = value.length;
+			let currentOffset = 0;
+			while (currentOffset < chunkLength) {
+				if (!currentMessage) {
+					const bytesRemaining = chunkLength - currentOffset;
+					if (!messageLengthBuffer) {
+						messageLengthBuffer = new Uint8Array(4);
+					}
+					const numBytesForTotal = Math.min(4 - currentMessagePendingLength, bytesRemaining);
+					messageLengthBuffer.set(value.slice(currentOffset, currentOffset + numBytesForTotal), currentMessagePendingLength);
+					currentMessagePendingLength += numBytesForTotal;
+					currentOffset += numBytesForTotal;
+					if (currentMessagePendingLength < 4) {
+						break;
+					}
+					allocateMessage(new DataView(messageLengthBuffer.buffer).getUint32(0, false));
+					messageLengthBuffer = null;
+				}
+				const numBytesToWrite = Math.min(currentMessageTotalLength - currentMessagePendingLength, chunkLength - currentOffset);
+				currentMessage.set(value.slice(currentOffset, currentOffset + numBytesToWrite), currentMessagePendingLength);
+				currentMessagePendingLength += numBytesToWrite;
+				currentOffset += numBytesToWrite;
+				if (currentMessageTotalLength && currentMessageTotalLength === currentMessagePendingLength) {
+					yield currentMessage;
+					currentMessage = null;
+					currentMessageTotalLength = 0;
+					currentMessagePendingLength = 0;
+				}
+			}
+		}
+	};
+	return { [Symbol.asyncIterator]: iterator };
+}
+var init_getChunkedStream = require_rolldown_runtime.__esmMin((() => {}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde-universal/getUnmarshalledStream.js
+function getUnmarshalledStream(source, options) {
+	const messageUnmarshaller = getMessageUnmarshaller(options.deserializer, options.toUtf8);
+	return { [Symbol.asyncIterator]: async function* () {
+		for await (const chunk of source) {
+			const message = options.eventStreamCodec.decode(chunk);
+			const type = await messageUnmarshaller(message);
+			if (type === undefined) continue;
+			yield type;
+		}
+	} };
+}
+function getMessageUnmarshaller(deserializer, toUtf8) {
+	return async function(message) {
+		const { value: messageType } = message.headers[":message-type"];
+		if (messageType === "error") {
+			const unmodeledError = new Error(message.headers[":error-message"].value || "UnknownError");
+			unmodeledError.name = message.headers[":error-code"].value;
+			throw unmodeledError;
+		} else if (messageType === "exception") {
+			const code = message.headers[":exception-type"].value;
+			const exception = { [code]: message };
+			const deserializedException = await deserializer(exception);
+			if (deserializedException.$unknown) {
+				const error = new Error(toUtf8(message.body));
+				error.name = code;
+				throw error;
+			}
+			throw deserializedException[code];
+		} else if (messageType === "event") {
+			const event = { [message.headers[":event-type"].value]: message };
+			const deserialized = await deserializer(event);
+			if (deserialized.$unknown) return;
+			return deserialized;
+		} else {
+			throw Error(`Unrecognizable event type: ${message.headers[":event-type"].value}`);
+		}
+	};
+}
+var init_getUnmarshalledStream = require_rolldown_runtime.__esmMin((() => {}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde-universal/EventStreamMarshaller.js
+var EventStreamMarshaller$1, eventStreamSerdeProvider$1;
+var init_EventStreamMarshaller$1 = require_rolldown_runtime.__esmMin((() => {
+	init_EventStreamCodec();
+	init_MessageDecoderStream();
+	init_MessageEncoderStream();
+	init_SmithyMessageDecoderStream();
+	init_SmithyMessageEncoderStream();
+	init_getChunkedStream();
+	init_getUnmarshalledStream();
+	EventStreamMarshaller$1 = class {
+		eventStreamCodec;
+		utfEncoder;
+		constructor({ utf8Encoder, utf8Decoder }) {
+			this.eventStreamCodec = new EventStreamCodec(utf8Encoder, utf8Decoder);
+			this.utfEncoder = utf8Encoder;
+		}
+		deserialize(body, deserializer) {
+			const inputStream = getChunkedStream(body);
+			return new SmithyMessageDecoderStream({
+				messageStream: new MessageDecoderStream({
+					inputStream,
+					decoder: this.eventStreamCodec
+				}),
+				deserializer: getMessageUnmarshaller(deserializer, this.utfEncoder)
+			});
+		}
+		serialize(inputStream, serializer) {
+			return new MessageEncoderStream({
+				messageStream: new SmithyMessageEncoderStream({
+					inputStream,
+					serializer
+				}),
+				encoder: this.eventStreamCodec,
+				includeEndFrame: true
+			});
+		}
+	};
+	eventStreamSerdeProvider$1 = (options) => new EventStreamMarshaller$1(options);
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde/EventStreamMarshaller.js
+async function* readableToIterable(readStream) {
+	let streamEnded = false;
+	let generationEnded = false;
+	const records = new Array();
+	readStream.on("error", (err) => {
+		if (!streamEnded) {
+			streamEnded = true;
+		}
+		if (err) {
+			throw err;
+		}
+	});
+	readStream.on("data", (data) => {
+		records.push(data);
+	});
+	readStream.on("end", () => {
+		streamEnded = true;
+	});
+	while (!generationEnded) {
+		const value = await new Promise((resolve) => setTimeout(() => resolve(records.shift()), 0));
+		if (value) {
+			yield value;
+		}
+		generationEnded = streamEnded && records.length === 0;
+	}
+}
+var EventStreamMarshaller, eventStreamSerdeProvider;
+var init_EventStreamMarshaller = require_rolldown_runtime.__esmMin((() => {
+	init_EventStreamMarshaller$1();
+	EventStreamMarshaller = class {
+		universalMarshaller;
+		constructor({ utf8Encoder, utf8Decoder }) {
+			this.universalMarshaller = new EventStreamMarshaller$1({
+				utf8Decoder,
+				utf8Encoder
+			});
+		}
+		deserialize(body, deserializer) {
+			const bodyIterable = typeof body[Symbol.asyncIterator] === "function" ? body : readableToIterable(body);
+			return this.universalMarshaller.deserialize(bodyIterable, deserializer);
+		}
+		serialize(input, serializer) {
+			return node_stream.Readable.from(this.universalMarshaller.serialize(input, serializer));
+		}
+	};
+	eventStreamSerdeProvider = (options) => new EventStreamMarshaller(options);
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde/utils.js
+var readableStreamToIterable, iterableToReadableStream;
+var init_utils = require_rolldown_runtime.__esmMin((() => {
+	readableStreamToIterable = (readableStream) => ({ [Symbol.asyncIterator]: async function* () {
+		const reader = readableStream.getReader();
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) return;
+				yield value;
+			}
+		} finally {
+			reader.releaseLock();
+		}
+	} });
+	iterableToReadableStream = (asyncIterable) => {
+		const iterator = asyncIterable[Symbol.asyncIterator]();
+		return new ReadableStream({ async pull(controller) {
+			const { done, value } = await iterator.next();
+			if (done) {
+				return controller.close();
+			}
+			controller.enqueue(value);
+		} });
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde-config-resolver/EventStreamSerdeConfig.js
+var resolveEventStreamSerdeConfig;
+var init_EventStreamSerdeConfig = require_rolldown_runtime.__esmMin((() => {
+	resolveEventStreamSerdeConfig = (input) => Object.assign(input, { eventStreamMarshaller: input.eventStreamSerdeProvider(input) });
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js
+var EventStreamSerde;
+var init_EventStreamSerde = require_rolldown_runtime.__esmMin((() => {
+	require_serde.init_transport();
+	require_serde.init_schema();
+	require_serde.init_serde();
+	EventStreamSerde = class {
+		marshaller;
+		serializer;
+		deserializer;
+		serdeContext;
+		defaultContentType;
+		compositeErrorRegistry;
+		constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, compositeErrorRegistry }) {
+			this.marshaller = marshaller;
+			this.serializer = serializer;
+			this.deserializer = deserializer;
+			this.serdeContext = serdeContext;
+			this.defaultContentType = defaultContentType;
+			this.compositeErrorRegistry = compositeErrorRegistry;
+		}
+		async serializeEventStream({ eventStream, requestSchema, initialRequest, initialMessageType }) {
+			const marshaller = this.marshaller;
+			const eventStreamMember = requestSchema.getEventStreamMember();
+			const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
+			const serializer = this.serializer;
+			const defaultContentType = this.defaultContentType;
+			const initialRequestMarker = Symbol("initialRequestMarker");
+			const eventStreamIterable = { async *[Symbol.asyncIterator]() {
+				if (initialRequest) {
+					const headers = {
+						":event-type": {
+							type: "string",
+							value: initialMessageType ?? "initial-request"
+						},
+						":message-type": {
+							type: "string",
+							value: "event"
+						},
+						":content-type": {
+							type: "string",
+							value: defaultContentType
+						}
+					};
+					serializer.write(requestSchema, initialRequest);
+					const body = serializer.flush();
+					yield {
+						[initialRequestMarker]: true,
+						headers,
+						body
+					};
+				}
+				for await (const page of eventStream) {
+					yield page;
+				}
+			} };
+			return marshaller.serialize(eventStreamIterable, (event) => {
+				if (event[initialRequestMarker]) {
+					return {
+						headers: event.headers,
+						body: event.body
+					};
+				}
+				let unionMember = "";
+				for (const key in event) {
+					if (!require_serde.hasOwn(event, key)) continue;
+					if (key !== "__type") {
+						unionMember = key;
+						break;
+					}
+				}
+				const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
+				const headers = {
+					":event-type": {
+						type: "string",
+						value: eventType
+					},
+					":message-type": {
+						type: "string",
+						value: "event"
+					},
+					":content-type": {
+						type: "string",
+						value: explicitPayloadContentType ?? defaultContentType
+					},
+					...additionalHeaders
+				};
+				return {
+					headers,
+					body
+				};
+			});
+		}
+		async deserializeEventStream({ response, responseSchema, initialResponseContainer, initialMessageType }) {
+			const marshaller = this.marshaller;
+			const eventStreamMember = responseSchema.getEventStreamMember();
+			const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
+			const memberSchemas = unionSchema.getMemberSchemas();
+			const initialResponseMarker = Symbol("initialResponseMarker");
+			const asyncIterable = marshaller.deserialize(response.body, async (event) => {
+				let unionMember = "";
+				for (const key in event) {
+					if (!require_serde.hasOwn(event, key)) continue;
+					if (key !== "__type") {
+						unionMember = key;
+						break;
+					}
+				}
+				const body = event[unionMember].body;
+				if (unionMember === (initialMessageType ?? "initial-response")) {
+					const dataObject = await this.deserializer.read(responseSchema, body);
+					delete dataObject[eventStreamMember];
+					return {
+						[initialResponseMarker]: true,
+						...dataObject
+					};
+				} else if (unionMember in memberSchemas) {
+					const eventStreamSchema = memberSchemas[unionMember];
+					if (eventStreamSchema.isStructSchema()) {
+						const out = {};
+						let hasBindings = false;
+						for (const [name, member] of eventStreamSchema.structIterator()) {
+							const { eventHeader, eventPayload } = member.getMergedTraits();
+							hasBindings = hasBindings || Boolean(eventHeader || eventPayload);
+							if (eventPayload) {
+								if (member.isBlobSchema()) {
+									out[name] = body;
+								} else if (member.isStringSchema()) {
+									out[name] = (this.serdeContext?.utf8Encoder ?? require_serde.toUtf8)(body);
+								} else if (member.isStructSchema()) {
+									out[name] = await this.deserializer.read(member, body);
+								}
+							} else if (eventHeader) {
+								const value = event[unionMember].headers[name]?.value;
+								if (value != null) {
+									if (member.isNumericSchema()) {
+										if (value && typeof value === "object" && "bytes" in value) {
+											out[name] = BigInt(value.toString());
+										} else {
+											out[name] = Number(value);
+										}
+									} else {
+										out[name] = value;
+									}
+								}
+							}
+						}
+						return { [unionMember]: await this.readEventMember(eventStreamSchema, body, hasBindings, out) };
+					}
+					return { [unionMember]: await this.deserializer.read(eventStreamSchema, body) };
+				} else {
+					return { $unknown: event };
+				}
+			});
+			const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+			const firstEvent = await asyncIterator.next();
+			if (firstEvent.done) {
+				return asyncIterable;
+			}
+			if (firstEvent.value?.[initialResponseMarker]) {
+				if (!responseSchema) {
+					throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
+				}
+				for (const key in firstEvent.value) {
+					if (!require_serde.hasOwn(firstEvent.value, key)) continue;
+					initialResponseContainer[key] = firstEvent.value[key];
+				}
+			}
+			return { async *[Symbol.asyncIterator]() {
+				if (!firstEvent?.value?.[initialResponseMarker]) {
+					yield firstEvent.value;
+				}
+				while (true) {
+					const { done, value } = await asyncIterator.next();
+					if (done) {
+						break;
+					}
+					yield value;
+				}
+			} };
+		}
+		async readEventMember(eventStreamSchema, body, hasBindings, out) {
+			let ErrCtor;
+			const staticStructuralSchema = eventStreamSchema.getSchema();
+			if (Array.isArray(staticStructuralSchema) && staticStructuralSchema[0] === -3) {
+				const namespace = staticStructuralSchema[1];
+				const nsRegistry = require_serde.TypeRegistry.for(namespace);
+				this.compositeErrorRegistry?.copyFrom(nsRegistry);
+				ErrCtor = (this.compositeErrorRegistry ?? nsRegistry)?.getErrorCtor(staticStructuralSchema);
+			}
+			const dataObject = hasBindings ? out : body.byteLength === 0 ? {} : await this.deserializer.read(eventStreamSchema, body);
+			if (ErrCtor) {
+				const message = dataObject.message ?? dataObject.Message ?? "Unknown";
+				const metadata = {};
+				const $fault = eventStreamSchema.getMergedTraits().error;
+				if ($fault) {
+					metadata.$fault = $fault;
+				}
+				return Object.assign(new ErrCtor({}), metadata, { message }, dataObject);
+			}
+			return dataObject;
+		}
+		writeEventBody(unionMember, unionSchema, event) {
+			const serializer = this.serializer;
+			let eventType = unionMember;
+			let explicitPayloadMember = null;
+			let explicitPayloadContentType;
+			const isKnownSchema = (() => {
+				const struct = unionSchema.getSchema();
+				return struct[4].includes(unionMember);
+			})();
+			const additionalHeaders = {};
+			if (!isKnownSchema) {
+				const [type, value] = event[unionMember];
+				eventType = type;
+				serializer.write(15, value);
+			} else {
+				const eventSchema = unionSchema.getMemberSchema(unionMember);
+				if (eventSchema.isStructSchema()) {
+					for (const [memberName, memberSchema] of eventSchema.structIterator()) {
+						const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
+						if (eventPayload) {
+							explicitPayloadMember = memberName;
+						} else if (eventHeader) {
+							const value = event[unionMember][memberName];
+							let type = "binary";
+							if (memberSchema.isNumericSchema()) {
+								if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {
+									type = "integer";
+								} else {
+									type = "long";
+								}
+							} else if (memberSchema.isTimestampSchema()) {
+								type = "timestamp";
+							} else if (memberSchema.isStringSchema()) {
+								type = "string";
+							} else if (memberSchema.isBooleanSchema()) {
+								type = "boolean";
+							}
+							if (value != null) {
+								additionalHeaders[memberName] = {
+									type,
+									value
+								};
+								delete event[unionMember][memberName];
+							}
+						}
+					}
+					if (explicitPayloadMember !== null) {
+						const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
+						if (payloadSchema.isBlobSchema()) {
+							explicitPayloadContentType = "application/octet-stream";
+						} else if (payloadSchema.isStringSchema()) {
+							explicitPayloadContentType = "text/plain";
+						}
+						serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
+					} else {
+						serializer.write(eventSchema, event[unionMember]);
+					}
+				} else if (eventSchema.isUnitSchema()) {
+					serializer.write(eventSchema, {});
+				} else {
+					throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+				}
+			}
+			const messageSerialization = serializer.flush() ?? new Uint8Array();
+			const body = typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? require_serde.fromUtf8)(messageSerialization) : messageSerialization;
+			return {
+				body,
+				eventType,
+				explicitPayloadContentType,
+				additionalHeaders
+			};
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/event-streams/index.js
+var init_event_streams = require_rolldown_runtime.__esmMin((() => {
+	init_EventStreamCodec();
+	init_HeaderMarshaller();
+	init_Int64();
+	init_MessageDecoderStream();
+	init_MessageEncoderStream();
+	init_SmithyMessageDecoderStream();
+	init_SmithyMessageEncoderStream();
+	init_EventStreamMarshaller();
+	init_utils();
+	init_EventStreamMarshaller$1();
+	init_getChunkedStream();
+	init_getUnmarshalledStream();
+	init_EventStreamSerdeConfig();
+	init_EventStreamSerde();
+}));
+
+//#endregion
+init_event_streams();
+exports.EventStreamSerde = EventStreamSerde;
+exports.eventStreamSerdeProvider = eventStreamSerdeProvider;