@costrict/csc 4.0.4 → 4.0.5-2

package/dist/chunk-shj5md9j.js

@@ -0,0 +1,1486 @@
+// @bun
+import {
+  require_dist_cjs4 as require_dist_cjs2,
+  require_tslib
+} from "./chunk-03qpgz7e.js";
+import {
+  require_dist_cjs
+} from "./chunk-jcfk76z5.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@aws-sdk+middleware-eventstream@3.972.9/node_modules/@aws-sdk/middleware-eventstream/dist-es/eventStreamConfiguration.js
+function resolveEventStreamConfig(input) {
+  const eventSigner = input.signer;
+  const messageSigner = input.signer;
+  const newInput = Object.assign(input, {
+    eventSigner,
+    messageSigner
+  });
+  const eventStreamPayloadHandler = newInput.eventStreamPayloadHandlerProvider(newInput);
+  return Object.assign(newInput, {
+    eventStreamPayloadHandler
+  });
+}
+var init_eventStreamConfiguration = () => {};
+
+// node_modules/.bun/@aws-sdk+middleware-eventstream@3.972.9/node_modules/@aws-sdk/middleware-eventstream/dist-es/eventStreamHandlingMiddleware.js
+var import_protocol_http, eventStreamHandlingMiddleware = (options) => (next, context) => async (args) => {
+  const { request } = args;
+  if (!import_protocol_http.HttpRequest.isInstance(request))
+    return next(args);
+  return options.eventStreamPayloadHandler.handle(next, args, context);
+}, eventStreamHandlingMiddlewareOptions;
+var init_eventStreamHandlingMiddleware = __esm(() => {
+  import_protocol_http = __toESM(require_dist_cjs(), 1);
+  eventStreamHandlingMiddlewareOptions = {
+    tags: ["EVENT_STREAM", "SIGNATURE", "HANDLE"],
+    name: "eventStreamHandlingMiddleware",
+    relation: "after",
+    toMiddleware: "awsAuthMiddleware",
+    override: true
+  };
+});
+
+// node_modules/.bun/@aws-sdk+middleware-eventstream@3.972.9/node_modules/@aws-sdk/middleware-eventstream/dist-es/eventStreamHeaderMiddleware.js
+var import_protocol_http2, eventStreamHeaderMiddleware = (next) => async (args) => {
+  const { request } = args;
+  if (!import_protocol_http2.HttpRequest.isInstance(request))
+    return next(args);
+  request.headers = {
+    ...request.headers,
+    "content-type": "application/vnd.amazon.eventstream",
+    "x-amz-content-sha256": "STREAMING-AWS4-HMAC-SHA256-EVENTS"
+  };
+  return next({
+    ...args,
+    request
+  });
+}, eventStreamHeaderMiddlewareOptions;
+var init_eventStreamHeaderMiddleware = __esm(() => {
+  import_protocol_http2 = __toESM(require_dist_cjs(), 1);
+  eventStreamHeaderMiddlewareOptions = {
+    step: "build",
+    tags: ["EVENT_STREAM", "HEADER", "CONTENT_TYPE", "CONTENT_SHA256"],
+    name: "eventStreamHeaderMiddleware",
+    override: true
+  };
+});
+
+// node_modules/.bun/@aws-sdk+middleware-eventstream@3.972.9/node_modules/@aws-sdk/middleware-eventstream/dist-es/getEventStreamPlugin.js
+var getEventStreamPlugin = (options) => ({
+  applyToStack: (clientStack) => {
+    clientStack.addRelativeTo(eventStreamHandlingMiddleware(options), eventStreamHandlingMiddlewareOptions);
+    clientStack.add(eventStreamHeaderMiddleware, eventStreamHeaderMiddlewareOptions);
+  }
+});
+var init_getEventStreamPlugin = __esm(() => {
+  init_eventStreamHandlingMiddleware();
+  init_eventStreamHeaderMiddleware();
+});
+
+// node_modules/.bun/@aws-sdk+middleware-eventstream@3.972.9/node_modules/@aws-sdk/middleware-eventstream/dist-es/index.js
+var init_dist_es = __esm(() => {
+  init_eventStreamConfiguration();
+  init_eventStreamHandlingMiddleware();
+  init_eventStreamHeaderMiddleware();
+  init_getEventStreamPlugin();
+});
+
+// node_modules/.bun/@aws-sdk+middleware-websocket@3.972.15/node_modules/@aws-sdk/middleware-websocket/dist-es/middlewares/websocketEndpointMiddleware.js
+var import_protocol_http3, websocketEndpointMiddleware = (config, options) => (next) => (args) => {
+  const { request } = args;
+  if (import_protocol_http3.HttpRequest.isInstance(request) && config.requestHandler.metadata?.handlerProtocol?.toLowerCase().includes("websocket")) {
+    request.protocol = "wss:";
+    request.method = "GET";
+    request.path = `${request.path}-websocket`;
+    const { headers } = request;
+    delete headers["content-type"];
+    delete headers["x-amz-content-sha256"];
+    for (const name of Object.keys(headers)) {
+      if (name.indexOf(options.headerPrefix) === 0) {
+        const chunkedName = name.replace(options.headerPrefix, "");
+        request.query[chunkedName] = headers[name];
+      }
+    }
+    if (headers["x-amz-user-agent"]) {
+      request.query["user-agent"] = headers["x-amz-user-agent"];
+    }
+    request.headers = { host: headers.host ?? request.hostname };
+  }
+  return next(args);
+}, websocketEndpointMiddlewareOptions;
+var init_websocketEndpointMiddleware = __esm(() => {
+  import_protocol_http3 = __toESM(require_dist_cjs(), 1);
+  websocketEndpointMiddlewareOptions = {
+    name: "websocketEndpointMiddleware",
+    tags: ["WEBSOCKET", "EVENT_STREAM"],
+    relation: "after",
+    toMiddleware: "eventStreamHeaderMiddleware",
+    override: true
+  };
+});
+
+// node_modules/.bun/@aws-sdk+middleware-websocket@3.972.15/node_modules/@aws-sdk/middleware-websocket/dist-es/middlewares/websocketInjectSessionIdMiddleware.js
+var injectSessionIdMiddleware = () => (next) => async (args) => {
+  const requestParams = {
+    ...args.input
+  };
+  const response = await next(args);
+  const output = response.output;
+  if (requestParams.SessionId && output.SessionId == null) {
+    output.SessionId = requestParams.SessionId;
+  }
+  return response;
+}, injectSessionIdMiddlewareOptions;
+var init_websocketInjectSessionIdMiddleware = __esm(() => {
+  injectSessionIdMiddlewareOptions = {
+    step: "initialize",
+    name: "injectSessionIdMiddleware",
+    tags: ["WEBSOCKET", "EVENT_STREAM"],
+    override: true
+  };
+});
+
+// node_modules/.bun/@aws-sdk+middleware-websocket@3.972.15/node_modules/@aws-sdk/middleware-websocket/dist-es/getWebSocketPlugin.js
+var getWebSocketPlugin = (config, options) => ({
+  applyToStack: (clientStack) => {
+    clientStack.addRelativeTo(websocketEndpointMiddleware(config, options), websocketEndpointMiddlewareOptions);
+    clientStack.add(injectSessionIdMiddleware(), injectSessionIdMiddlewareOptions);
+  }
+});
+var init_getWebSocketPlugin = __esm(() => {
+  init_websocketEndpointMiddleware();
+  init_websocketInjectSessionIdMiddleware();
+});
+
+// node_modules/.bun/@aws-sdk+middleware-websocket@3.972.15/node_modules/@aws-sdk/middleware-websocket/dist-es/utils.js
+var isWebSocketRequest = (request) => request.protocol === "ws:" || request.protocol === "wss:";
+var init_utils = () => {};
+
+// node_modules/.bun/@aws-sdk+middleware-websocket@3.972.15/node_modules/@aws-sdk/middleware-websocket/dist-es/WebsocketSignatureV4.js
+class WebsocketSignatureV4 {
+  signer;
+  constructor(options) {
+    this.signer = options.signer;
+  }
+  presign(originalRequest, options = {}) {
+    return this.signer.presign(originalRequest, options);
+  }
+  async sign(toSign, options) {
+    if (import_protocol_http4.HttpRequest.isInstance(toSign) && isWebSocketRequest(toSign)) {
+      const signedRequest = await this.signer.presign({ ...toSign, body: "" }, {
+        ...options,
+        expiresIn: 60,
+        unsignableHeaders: new Set(Object.keys(toSign.headers).filter((header) => header !== "host"))
+      });
+      return {
+        ...signedRequest,
+        body: toSign.body
+      };
+    } else {
+      return this.signer.sign(toSign, options);
+    }
+  }
+  signMessage(message, args) {
+    return this.signer.signMessage(message, args);
+  }
+}
+var import_protocol_http4;
+var init_WebsocketSignatureV4 = __esm(() => {
+  init_utils();
+  import_protocol_http4 = __toESM(require_dist_cjs(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+middleware-websocket@3.972.15/node_modules/@aws-sdk/middleware-websocket/dist-es/resolveWebSocketConfig.js
+var resolveWebSocketConfig = (input) => {
+  const { signer } = input;
+  return Object.assign(input, {
+    signer: async (authScheme) => {
+      const signerObj = await signer(authScheme);
+      if (validateSigner(signerObj)) {
+        return new WebsocketSignatureV4({ signer: signerObj });
+      }
+      throw new Error("Expected WebsocketSignatureV4 signer, please check the client constructor.");
+    }
+  });
+}, validateSigner = (signer) => !!signer;
+var init_resolveWebSocketConfig = __esm(() => {
+  init_WebsocketSignatureV4();
+});
+
+// node_modules/.bun/tslib@2.8.1/node_modules/tslib/modules/index.js
+var import_tslib, __extends, __assign, __rest, __decorate, __param, __esDecorate, __runInitializers, __propKey, __setFunctionName, __metadata, __awaiter, __generator, __exportStar, __createBinding, __values, __read, __spread, __spreadArrays, __spreadArray, __await, __asyncGenerator, __asyncDelegator, __asyncValues, __makeTemplateObject, __importStar, __importDefault, __classPrivateFieldGet, __classPrivateFieldSet, __classPrivateFieldIn, __addDisposableResource, __disposeResources, __rewriteRelativeImportExtension;
+var init_modules = __esm(() => {
+  import_tslib = __toESM(require_tslib(), 1);
+  ({
+    __extends,
+    __assign,
+    __rest,
+    __decorate,
+    __param,
+    __esDecorate,
+    __runInitializers,
+    __propKey,
+    __setFunctionName,
+    __metadata,
+    __awaiter,
+    __generator,
+    __exportStar,
+    __createBinding,
+    __values,
+    __read,
+    __spread,
+    __spreadArrays,
+    __spreadArray,
+    __await,
+    __asyncGenerator,
+    __asyncDelegator,
+    __asyncValues,
+    __makeTemplateObject,
+    __importStar,
+    __importDefault,
+    __classPrivateFieldGet,
+    __classPrivateFieldSet,
+    __classPrivateFieldIn,
+    __addDisposableResource,
+    __disposeResources,
+    __rewriteRelativeImportExtension
+  } = import_tslib.default);
+});
+
+// node_modules/.bun/@smithy+is-array-buffer@2.2.0/node_modules/@smithy/is-array-buffer/dist-es/index.js
+var isArrayBuffer = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
+var init_dist_es2 = () => {};
+
+// node_modules/.bun/@smithy+util-buffer-from@2.2.0/node_modules/@smithy/util-buffer-from/dist-es/index.js
+import { Buffer as Buffer2 } from "buffer";
+var 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 Buffer2.from(input, offset, length);
+}, 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 ? Buffer2.from(input, encoding) : Buffer2.from(input);
+};
+var init_dist_es3 = __esm(() => {
+  init_dist_es2();
+});
+
+// node_modules/.bun/@smithy+util-utf8@2.3.0/node_modules/@smithy/util-utf8/dist-es/fromUtf8.js
+var fromUtf8 = (input) => {
+  const buf = fromString(input, "utf8");
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+};
+var init_fromUtf8 = __esm(() => {
+  init_dist_es3();
+});
+
+// node_modules/.bun/@smithy+util-utf8@2.3.0/node_modules/@smithy/util-utf8/dist-es/toUint8Array.js
+var init_toUint8Array = __esm(() => {
+  init_fromUtf8();
+});
+
+// node_modules/.bun/@smithy+util-utf8@2.3.0/node_modules/@smithy/util-utf8/dist-es/toUtf8.js
+var 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");
+};
+var init_toUtf8 = __esm(() => {
+  init_dist_es3();
+});
+
+// node_modules/.bun/@smithy+util-utf8@2.3.0/node_modules/@smithy/util-utf8/dist-es/index.js
+var init_dist_es4 = __esm(() => {
+  init_fromUtf8();
+  init_toUint8Array();
+  init_toUtf8();
+});
+
+// node_modules/.bun/@aws-crypto+util@5.2.0/node_modules/@aws-crypto/util/build/module/convertToBuffer.js
+function convertToBuffer(data) {
+  if (data instanceof Uint8Array)
+    return data;
+  if (typeof data === "string") {
+    return fromUtf83(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+  }
+  return new Uint8Array(data);
+}
+var fromUtf83;
+var init_convertToBuffer = __esm(() => {
+  init_dist_es4();
+  fromUtf83 = typeof Buffer !== "undefined" && Buffer.from ? function(input) {
+    return Buffer.from(input, "utf8");
+  } : fromUtf8;
+});
+
+// node_modules/.bun/@aws-crypto+util@5.2.0/node_modules/@aws-crypto/util/build/module/isEmptyData.js
+function isEmptyData(data) {
+  if (typeof data === "string") {
+    return data.length === 0;
+  }
+  return data.byteLength === 0;
+}
+var init_isEmptyData = () => {};
+
+// node_modules/.bun/@aws-crypto+util@5.2.0/node_modules/@aws-crypto/util/build/module/numToUint8.js
+function numToUint8(num) {
+  return new Uint8Array([
+    (num & 4278190080) >> 24,
+    (num & 16711680) >> 16,
+    (num & 65280) >> 8,
+    num & 255
+  ]);
+}
+var init_numToUint8 = () => {};
+
+// node_modules/.bun/@aws-crypto+util@5.2.0/node_modules/@aws-crypto/util/build/module/uint32ArrayFrom.js
+function uint32ArrayFrom(a_lookUpTable) {
+  if (!Uint32Array.from) {
+    var return_array = new Uint32Array(a_lookUpTable.length);
+    var a_index = 0;
+    while (a_index < a_lookUpTable.length) {
+      return_array[a_index] = a_lookUpTable[a_index];
+      a_index += 1;
+    }
+    return return_array;
+  }
+  return Uint32Array.from(a_lookUpTable);
+}
+var init_uint32ArrayFrom = () => {};
+
+// node_modules/.bun/@aws-crypto+util@5.2.0/node_modules/@aws-crypto/util/build/module/index.js
+var init_module = __esm(() => {
+  init_convertToBuffer();
+  init_isEmptyData();
+  init_numToUint8();
+  init_uint32ArrayFrom();
+});
+
+// node_modules/.bun/@aws-crypto+crc32@5.2.0/node_modules/@aws-crypto/crc32/build/module/aws_crc32.js
+var AwsCrc32;
+var init_aws_crc32 = __esm(() => {
+  init_modules();
+  init_module();
+  init_module2();
+  AwsCrc32 = function() {
+    function AwsCrc322() {
+      this.crc32 = new Crc32;
+    }
+    AwsCrc322.prototype.update = function(toHash) {
+      if (isEmptyData(toHash))
+        return;
+      this.crc32.update(convertToBuffer(toHash));
+    };
+    AwsCrc322.prototype.digest = function() {
+      return __awaiter(this, undefined, undefined, function() {
+        return __generator(this, function(_a) {
+          return [2, numToUint8(this.crc32.digest())];
+        });
+      });
+    };
+    AwsCrc322.prototype.reset = function() {
+      this.crc32 = new Crc32;
+    };
+    return AwsCrc322;
+  }();
+});
+
+// node_modules/.bun/@aws-crypto+crc32@5.2.0/node_modules/@aws-crypto/crc32/build/module/index.js
+var Crc32, a_lookUpTable, lookupTable;
+var init_module2 = __esm(() => {
+  init_modules();
+  init_module();
+  init_aws_crc32();
+  Crc32 = function() {
+    function Crc322() {
+      this.checksum = 4294967295;
+    }
+    Crc322.prototype.update = function(data) {
+      var e_1, _a;
+      try {
+        for (var data_1 = __values(data), data_1_1 = data_1.next();!data_1_1.done; data_1_1 = data_1.next()) {
+          var byte = data_1_1.value;
+          this.checksum = this.checksum >>> 8 ^ lookupTable[(this.checksum ^ byte) & 255];
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (data_1_1 && !data_1_1.done && (_a = data_1.return))
+            _a.call(data_1);
+        } finally {
+          if (e_1)
+            throw e_1.error;
+        }
+      }
+      return this;
+    };
+    Crc322.prototype.digest = function() {
+      return (this.checksum ^ 4294967295) >>> 0;
+    };
+    return Crc322;
+  }();
+  a_lookUpTable = [
+    0,
+    1996959894,
+    3993919788,
+    2567524794,
+    124634137,
+    1886057615,
+    3915621685,
+    2657392035,
+    249268274,
+    2044508324,
+    3772115230,
+    2547177864,
+    162941995,
+    2125561021,
+    3887607047,
+    2428444049,
+    498536548,
+    1789927666,
+    4089016648,
+    2227061214,
+    450548861,
+    1843258603,
+    4107580753,
+    2211677639,
+    325883990,
+    1684777152,
+    4251122042,
+    2321926636,
+    335633487,
+    1661365465,
+    4195302755,
+    2366115317,
+    997073096,
+    1281953886,
+    3579855332,
+    2724688242,
+    1006888145,
+    1258607687,
+    3524101629,
+    2768942443,
+    901097722,
+    1119000684,
+    3686517206,
+    2898065728,
+    853044451,
+    1172266101,
+    3705015759,
+    2882616665,
+    651767980,
+    1373503546,
+    3369554304,
+    3218104598,
+    565507253,
+    1454621731,
+    3485111705,
+    3099436303,
+    671266974,
+    1594198024,
+    3322730930,
+    2970347812,
+    795835527,
+    1483230225,
+    3244367275,
+    3060149565,
+    1994146192,
+    31158534,
+    2563907772,
+    4023717930,
+    1907459465,
+    112637215,
+    2680153253,
+    3904427059,
+    2013776290,
+    251722036,
+    2517215374,
+    3775830040,
+    2137656763,
+    141376813,
+    2439277719,
+    3865271297,
+    1802195444,
+    476864866,
+    2238001368,
+    4066508878,
+    1812370925,
+    453092731,
+    2181625025,
+    4111451223,
+    1706088902,
+    314042704,
+    2344532202,
+    4240017532,
+    1658658271,
+    366619977,
+    2362670323,
+    4224994405,
+    1303535960,
+    984961486,
+    2747007092,
+    3569037538,
+    1256170817,
+    1037604311,
+    2765210733,
+    3554079995,
+    1131014506,
+    879679996,
+    2909243462,
+    3663771856,
+    1141124467,
+    855842277,
+    2852801631,
+    3708648649,
+    1342533948,
+    654459306,
+    3188396048,
+    3373015174,
+    1466479909,
+    544179635,
+    3110523913,
+    3462522015,
+    1591671054,
+    702138776,
+    2966460450,
+    3352799412,
+    1504918807,
+    783551873,
+    3082640443,
+    3233442989,
+    3988292384,
+    2596254646,
+    62317068,
+    1957810842,
+    3939845945,
+    2647816111,
+    81470997,
+    1943803523,
+    3814918930,
+    2489596804,
+    225274430,
+    2053790376,
+    3826175755,
+    2466906013,
+    167816743,
+    2097651377,
+    4027552580,
+    2265490386,
+    503444072,
+    1762050814,
+    4150417245,
+    2154129355,
+    426522225,
+    1852507879,
+    4275313526,
+    2312317920,
+    282753626,
+    1742555852,
+    4189708143,
+    2394877945,
+    397917763,
+    1622183637,
+    3604390888,
+    2714866558,
+    953729732,
+    1340076626,
+    3518719985,
+    2797360999,
+    1068828381,
+    1219638859,
+    3624741850,
+    2936675148,
+    906185462,
+    1090812512,
+    3747672003,
+    2825379669,
+    829329135,
+    1181335161,
+    3412177804,
+    3160834842,
+    628085408,
+    1382605366,
+    3423369109,
+    3138078467,
+    570562233,
+    1426400815,
+    3317316542,
+    2998733608,
+    733239954,
+    1555261956,
+    3268935591,
+    3050360625,
+    752459403,
+    1541320221,
+    2607071920,
+    3965973030,
+    1969922972,
+    40735498,
+    2617837225,
+    3943577151,
+    1913087877,
+    83908371,
+    2512341634,
+    3803740692,
+    2075208622,
+    213261112,
+    2463272603,
+    3855990285,
+    2094854071,
+    198958881,
+    2262029012,
+    4057260610,
+    1759359992,
+    534414190,
+    2176718541,
+    4139329115,
+    1873836001,
+    414664567,
+    2282248934,
+    4279200368,
+    1711684554,
+    285281116,
+    2405801727,
+    4167216745,
+    1634467795,
+    376229701,
+    2685067896,
+    3608007406,
+    1308918612,
+    956543938,
+    2808555105,
+    3495958263,
+    1231636301,
+    1047427035,
+    2932959818,
+    3654703836,
+    1088359270,
+    936918000,
+    2847714899,
+    3736837829,
+    1202900863,
+    817233897,
+    3183342108,
+    3401237130,
+    1404277552,
+    615818150,
+    3134207493,
+    3453421203,
+    1423857449,
+    601450431,
+    3009837614,
+    3294710456,
+    1567103746,
+    711928724,
+    3020668471,
+    3272380065,
+    1510334235,
+    755167117
+  ];
+  lookupTable = uint32ArrayFrom(a_lookUpTable);
+});
+
+// node_modules/.bun/@smithy+eventstream-codec@4.2.13/node_modules/@smithy/eventstream-codec/dist-es/Int64.js
+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 > 9223372036854776000 || number < -9223372036854776000) {
+      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(import_util_hex_encoding.toHex(bytes), 16) * (negative ? -1 : 1);
+  }
+  toString() {
+    return String(this.valueOf());
+  }
+}
+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 import_util_hex_encoding;
+var init_Int64 = __esm(() => {
+  import_util_hex_encoding = __toESM(require_dist_cjs2(), 1);
+});
+
+// node_modules/.bun/@smithy+eventstream-codec@4.2.13/node_modules/@smithy/eventstream-codec/dist-es/HeaderMarshaller.js
+class HeaderMarshaller {
+  toUtf8;
+  fromUtf8;
+  constructor(toUtf83, fromUtf84) {
+    this.toUtf8 = toUtf83;
+    this.fromUtf8 = fromUtf84;
+  }
+  format(headers) {
+    const chunks = [];
+    for (const headerName of Object.keys(headers)) {
+      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(import_util_hex_encoding2.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: `${import_util_hex_encoding2.toHex(uuidBytes.subarray(0, 4))}-${import_util_hex_encoding2.toHex(uuidBytes.subarray(4, 6))}-${import_util_hex_encoding2.toHex(uuidBytes.subarray(6, 8))}-${import_util_hex_encoding2.toHex(uuidBytes.subarray(8, 10))}-${import_util_hex_encoding2.toHex(uuidBytes.subarray(10))}`
+          };
+          break;
+        default:
+          throw new Error(`Unrecognized header type tag`);
+      }
+    }
+    return out;
+  }
+}
+var import_util_hex_encoding2, 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;
+var init_HeaderMarshaller = __esm(() => {
+  init_Int64();
+  import_util_hex_encoding2 = __toESM(require_dist_cjs2(), 1);
+  (function(HEADER_VALUE_TYPE2) {
+    HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["boolTrue"] = 0] = "boolTrue";
+    HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["boolFalse"] = 1] = "boolFalse";
+    HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["byte"] = 2] = "byte";
+    HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["short"] = 3] = "short";
+    HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["integer"] = 4] = "integer";
+    HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["long"] = 5] = "long";
+    HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["byteArray"] = 6] = "byteArray";
+    HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["string"] = 7] = "string";
+    HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["timestamp"] = 8] = "timestamp";
+    HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["uuid"] = 9] = "uuid";
+  })(HEADER_VALUE_TYPE || (HEADER_VALUE_TYPE = {}));
+  UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+});
+
+// node_modules/.bun/@smithy+eventstream-codec@4.2.13/node_modules/@smithy/eventstream-codec/dist-es/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 Crc32().update(new Uint8Array(buffer, byteOffset, PRELUDE_LENGTH));
+  if (expectedPreludeChecksum !== checksummer.digest()) {
+    throw new Error(`The prelude checksum specified in the message (${expectedPreludeChecksum}) does not match the calculated CRC32 checksum (${checksummer.digest()})`);
+  }
+  checksummer.update(new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH, byteLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH)));
+  if (expectedMessageChecksum !== checksummer.digest()) {
+    throw new Error(`The message checksum (${checksummer.digest()}) 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 = 4, PRELUDE_LENGTH, CHECKSUM_LENGTH = 4, MINIMUM_MESSAGE_LENGTH;
+var init_splitMessage = __esm(() => {
+  init_module2();
+  PRELUDE_LENGTH = PRELUDE_MEMBER_LENGTH * 2;
+  MINIMUM_MESSAGE_LENGTH = PRELUDE_LENGTH + CHECKSUM_LENGTH * 2;
+});
+
+// node_modules/.bun/@smithy+eventstream-codec@4.2.13/node_modules/@smithy/eventstream-codec/dist-es/EventStreamCodec.js
+class EventStreamCodec {
+  headerMarshaller;
+  messageBuffer;
+  isEndOfStream;
+  constructor(toUtf83, fromUtf84) {
+    this.headerMarshaller = new HeaderMarshaller(toUtf83, fromUtf84);
+    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 Crc32;
+    view.setUint32(0, length, false);
+    view.setUint32(4, headers.byteLength, false);
+    view.setUint32(8, checksum.update(out.subarray(0, 8)).digest(), false);
+    out.set(headers, 12);
+    out.set(body, headers.byteLength + 12);
+    view.setUint32(length - 4, checksum.update(out.subarray(8, length - 4)).digest(), false);
+    return out;
+  }
+  decode(message) {
+    const { headers, body } = splitMessage(message);
+    return { headers: this.headerMarshaller.parse(headers), body };
+  }
+  formatHeaders(rawHeaders) {
+    return this.headerMarshaller.format(rawHeaders);
+  }
+}
+var init_EventStreamCodec = __esm(() => {
+  init_module2();
+  init_HeaderMarshaller();
+  init_splitMessage();
+});
+
+// node_modules/.bun/@smithy+eventstream-codec@4.2.13/node_modules/@smithy/eventstream-codec/dist-es/Message.js
+var init_Message = () => {};
+
+// node_modules/.bun/@smithy+eventstream-codec@4.2.13/node_modules/@smithy/eventstream-codec/dist-es/MessageDecoderStream.js
+var MessageDecoderStream;
+var init_MessageDecoderStream = __esm(() => {
+  MessageDecoderStream = class MessageDecoderStream {
+    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;
+      }
+    }
+  };
+});
+
+// node_modules/.bun/@smithy+eventstream-codec@4.2.13/node_modules/@smithy/eventstream-codec/dist-es/MessageEncoderStream.js
+var MessageEncoderStream;
+var init_MessageEncoderStream = __esm(() => {
+  MessageEncoderStream = class MessageEncoderStream {
+    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);
+      }
+    }
+  };
+});
+
+// node_modules/.bun/@smithy+eventstream-codec@4.2.13/node_modules/@smithy/eventstream-codec/dist-es/SmithyMessageDecoderStream.js
+var SmithyMessageDecoderStream;
+var init_SmithyMessageDecoderStream = __esm(() => {
+  SmithyMessageDecoderStream = class SmithyMessageDecoderStream {
+    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;
+      }
+    }
+  };
+});
+
+// node_modules/.bun/@smithy+eventstream-codec@4.2.13/node_modules/@smithy/eventstream-codec/dist-es/SmithyMessageEncoderStream.js
+var SmithyMessageEncoderStream;
+var init_SmithyMessageEncoderStream = __esm(() => {
+  SmithyMessageEncoderStream = class SmithyMessageEncoderStream {
+    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;
+      }
+    }
+  };
+});
+
+// node_modules/.bun/@smithy+eventstream-codec@4.2.13/node_modules/@smithy/eventstream-codec/dist-es/index.js
+var init_dist_es5 = __esm(() => {
+  init_EventStreamCodec();
+  init_HeaderMarshaller();
+  init_Int64();
+  init_Message();
+  init_MessageDecoderStream();
+  init_MessageEncoderStream();
+  init_SmithyMessageDecoderStream();
+  init_SmithyMessageEncoderStream();
+});
+
+// node_modules/.bun/@smithy+eventstream-serde-universal@4.2.13/node_modules/@smithy/eventstream-serde-universal/dist-es/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 = () => {};
+
+// node_modules/.bun/@smithy+eventstream-serde-universal@4.2.13/node_modules/@smithy/eventstream-serde-universal/dist-es/getUnmarshalledStream.js
+function getMessageUnmarshaller(deserializer, toUtf83) {
+  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(toUtf83(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 = () => {};
+
+// node_modules/.bun/@smithy+eventstream-serde-universal@4.2.13/node_modules/@smithy/eventstream-serde-universal/dist-es/EventStreamMarshaller.js
+class EventStreamMarshaller {
+  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
+    });
+  }
+}
+var init_EventStreamMarshaller = __esm(() => {
+  init_dist_es5();
+  init_getChunkedStream();
+  init_getUnmarshalledStream();
+});
+
+// node_modules/.bun/@smithy+eventstream-serde-universal@4.2.13/node_modules/@smithy/eventstream-serde-universal/dist-es/provider.js
+var init_provider = () => {};
+
+// node_modules/.bun/@smithy+eventstream-serde-universal@4.2.13/node_modules/@smithy/eventstream-serde-universal/dist-es/index.js
+var init_dist_es6 = __esm(() => {
+  init_EventStreamMarshaller();
+  init_provider();
+});
+
+// node_modules/.bun/@aws-sdk+middleware-websocket@3.972.15/node_modules/@aws-sdk/middleware-websocket/dist-es/WebSocketFetchHandler.js
+var init_WebSocketFetchHandler = () => {};
+
+// node_modules/.bun/@aws-sdk+middleware-websocket@3.972.15/node_modules/@aws-sdk/middleware-websocket/dist-es/ws-eventstream/eventStreamPayloadHandlerProvider.js
+var init_eventStreamPayloadHandlerProvider = () => {};
+
+// node_modules/.bun/@aws-sdk+middleware-websocket@3.972.15/node_modules/@aws-sdk/middleware-websocket/dist-es/index.js
+var init_dist_es7 = __esm(() => {
+  init_WebSocketFetchHandler();
+  init_getWebSocketPlugin();
+  init_resolveWebSocketConfig();
+  init_eventStreamPayloadHandlerProvider();
+});
+
+// node_modules/.bun/@smithy+eventstream-serde-config-resolver@4.3.13/node_modules/@smithy/eventstream-serde-config-resolver/dist-es/EventStreamSerdeConfig.js
+var resolveEventStreamSerdeConfig = (input) => Object.assign(input, {
+  eventStreamMarshaller: input.eventStreamSerdeProvider(input)
+});
+var init_EventStreamSerdeConfig = () => {};
+
+// node_modules/.bun/@smithy+eventstream-serde-config-resolver@4.3.13/node_modules/@smithy/eventstream-serde-config-resolver/dist-es/index.js
+var init_dist_es8 = __esm(() => {
+  init_EventStreamSerdeConfig();
+});
+
+// node_modules/.bun/@aws-sdk+eventstream-handler-node@3.972.13/node_modules/@aws-sdk/eventstream-handler-node/dist-es/EventSigningTransformStream.js
+import { Transform } from "stream";
+function getSignatureBinary(signature) {
+  const buf = Buffer.from(signature, "hex");
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+}
+var EventSigningTransformStream;
+var init_EventSigningTransformStream = __esm(() => {
+  EventSigningTransformStream = class EventSigningTransformStream extends Transform {
+    priorSignature;
+    messageSigner;
+    eventStreamCodec;
+    systemClockOffsetProvider;
+    constructor(options) {
+      super({
+        autoDestroy: true,
+        readableObjectMode: true,
+        writableObjectMode: true,
+        ...options
+      });
+      this.priorSignature = options.priorSignature;
+      this.eventStreamCodec = options.eventStreamCodec;
+      this.messageSigner = options.messageSigner;
+      this.systemClockOffsetProvider = options.systemClockOffsetProvider;
+    }
+    async _transform(chunk, encoding, callback) {
+      try {
+        const now = new Date(Date.now() + await this.systemClockOffsetProvider());
+        const dateHeader = {
+          ":date": { type: "timestamp", value: now }
+        };
+        const signedMessage = await this.messageSigner.sign({
+          message: {
+            body: chunk,
+            headers: dateHeader
+          },
+          priorSignature: this.priorSignature
+        }, {
+          signingDate: now
+        });
+        this.priorSignature = signedMessage.signature;
+        const serializedSigned = this.eventStreamCodec.encode({
+          headers: {
+            ...dateHeader,
+            ":chunk-signature": {
+              type: "binary",
+              value: getSignatureBinary(signedMessage.signature)
+            }
+          },
+          body: chunk
+        });
+        this.push(serializedSigned);
+        return callback();
+      } catch (err) {
+        callback(err);
+      }
+    }
+  };
+});
+
+// node_modules/.bun/@aws-sdk+eventstream-handler-node@3.972.13/node_modules/@aws-sdk/eventstream-handler-node/dist-es/EventStreamPayloadHandler.js
+import { PassThrough, pipeline, Readable } from "stream";
+
+class EventStreamPayloadHandler {
+  messageSigner;
+  eventStreamCodec;
+  systemClockOffsetProvider;
+  constructor(options) {
+    this.messageSigner = options.messageSigner;
+    this.eventStreamCodec = new EventStreamCodec(options.utf8Encoder, options.utf8Decoder);
+    this.systemClockOffsetProvider = async () => options.systemClockOffset ?? 0;
+  }
+  async handle(next, args, context = {}) {
+    const request = args.request;
+    const { body: payload, query } = request;
+    if (!(payload instanceof Readable)) {
+      throw new Error("Eventstream payload must be a Readable stream.");
+    }
+    const payloadStream = payload;
+    request.body = new PassThrough({
+      objectMode: true
+    });
+    const match = request.headers?.authorization?.match(/Signature=([\w]+)$/);
+    let priorSignature = match?.[1] ?? query?.["X-Amz-Signature"] ?? "";
+    if (context.__staticSignature) {
+      priorSignature = "";
+    }
+    const signingStream = new EventSigningTransformStream({
+      priorSignature,
+      eventStreamCodec: this.eventStreamCodec,
+      messageSigner: await this.messageSigner(),
+      systemClockOffsetProvider: this.systemClockOffsetProvider
+    });
+    let resolvePipeline;
+    const pipelineError = new Promise((resolve, reject) => {
+      resolvePipeline = () => resolve(undefined);
+      pipeline(payloadStream, signingStream, request.body, (err) => {
+        if (err) {
+          reject(new Error(`Pipeline error in @aws-sdk/eventstream-handler-node: ${err.message}`, { cause: err }));
+        }
+      });
+    });
+    let result;
+    try {
+      result = await Promise.race([next(args), pipelineError]);
+    } catch (e) {
+      request.body.end();
+      throw e;
+    } finally {
+      resolvePipeline();
+    }
+    return result;
+  }
+}
+var init_EventStreamPayloadHandler = __esm(() => {
+  init_dist_es5();
+  init_EventSigningTransformStream();
+});
+
+// node_modules/.bun/@aws-sdk+eventstream-handler-node@3.972.13/node_modules/@aws-sdk/eventstream-handler-node/dist-es/eventStreamPayloadHandlerProvider.js
+var eventStreamPayloadHandlerProvider2 = (options) => new EventStreamPayloadHandler(options);
+var init_eventStreamPayloadHandlerProvider2 = __esm(() => {
+  init_EventStreamPayloadHandler();
+});
+
+// node_modules/.bun/@aws-sdk+eventstream-handler-node@3.972.13/node_modules/@aws-sdk/eventstream-handler-node/dist-es/index.js
+var init_dist_es9 = __esm(() => {
+  init_eventStreamPayloadHandlerProvider2();
+});
+
+// node_modules/.bun/@smithy+eventstream-serde-node@4.2.13/node_modules/@smithy/eventstream-serde-node/dist-es/utils.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 init_utils2 = () => {};
+
+// node_modules/.bun/@smithy+eventstream-serde-node@4.2.13/node_modules/@smithy/eventstream-serde-node/dist-es/EventStreamMarshaller.js
+import { Readable as Readable2 } from "stream";
+
+class EventStreamMarshaller3 {
+  universalMarshaller;
+  constructor({ utf8Encoder, utf8Decoder }) {
+    this.universalMarshaller = new EventStreamMarshaller({
+      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 Readable2.from(this.universalMarshaller.serialize(input, serializer));
+  }
+}
+var init_EventStreamMarshaller2 = __esm(() => {
+  init_dist_es6();
+  init_utils2();
+});
+
+// node_modules/.bun/@smithy+eventstream-serde-node@4.2.13/node_modules/@smithy/eventstream-serde-node/dist-es/provider.js
+var eventStreamSerdeProvider = (options) => new EventStreamMarshaller3(options);
+var init_provider2 = __esm(() => {
+  init_EventStreamMarshaller2();
+});
+
+// node_modules/.bun/@smithy+eventstream-serde-node@4.2.13/node_modules/@smithy/eventstream-serde-node/dist-es/index.js
+var init_dist_es10 = __esm(() => {
+  init_EventStreamMarshaller2();
+  init_provider2();
+});
+
+export { resolveEventStreamConfig, getEventStreamPlugin, init_dist_es, fromArrayBuffer, fromString, init_dist_es3 as init_dist_es1, fromUtf8, toUtf8, init_dist_es4 as init_dist_es2, getWebSocketPlugin, resolveWebSocketConfig, init_dist_es7 as init_dist_es3, resolveEventStreamSerdeConfig, init_dist_es8 as init_dist_es4, eventStreamPayloadHandlerProvider2 as eventStreamPayloadHandlerProvider, init_dist_es9 as init_dist_es5, eventStreamSerdeProvider, init_dist_es10 as init_dist_es6 };