@stacksjs/actions 0.70.9 → 0.70.11

package/dist/chunk-a7k3cdby.js

@@ -0,0 +1,2266 @@
+import {
+  require_dist_cjs
+} from "./chunk-saqpg5nd.js";
+import {
+  __commonJS,
+  __require
+} from "./chunk-9v6qtbez.js";
+
+// ../../../../node_modules/@smithy/protocol-http/dist-cjs/index.js
+var require_dist_cjs2 = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    Field: () => Field,
+    Fields: () => Fields,
+    HttpRequest: () => HttpRequest,
+    HttpResponse: () => HttpResponse,
+    IHttpRequest: () => import_types.HttpRequest,
+    getHttpHandlerExtensionConfiguration: () => getHttpHandlerExtensionConfiguration,
+    isValidHostname: () => isValidHostname,
+    resolveHttpHandlerRuntimeConfig: () => resolveHttpHandlerRuntimeConfig
+  });
+  module.exports = __toCommonJS(src_exports);
+  var getHttpHandlerExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
+    return {
+      setHttpHandler(handler) {
+        runtimeConfig.httpHandler = handler;
+      },
+      httpHandler() {
+        return runtimeConfig.httpHandler;
+      },
+      updateHttpClientConfig(key, value) {
+        runtimeConfig.httpHandler?.updateHttpClientConfig(key, value);
+      },
+      httpHandlerConfigs() {
+        return runtimeConfig.httpHandler.httpHandlerConfigs();
+      }
+    };
+  }, "getHttpHandlerExtensionConfiguration");
+  var resolveHttpHandlerRuntimeConfig = /* @__PURE__ */ __name((httpHandlerExtensionConfiguration) => {
+    return {
+      httpHandler: httpHandlerExtensionConfiguration.httpHandler()
+    };
+  }, "resolveHttpHandlerRuntimeConfig");
+  var import_types = require_dist_cjs();
+  var Field = class {
+    static {
+      __name(this, "Field");
+    }
+    constructor({ name, kind = import_types.FieldPosition.HEADER, values = [] }) {
+      this.name = name;
+      this.kind = kind;
+      this.values = values;
+    }
+    add(value) {
+      this.values.push(value);
+    }
+    set(values) {
+      this.values = values;
+    }
+    remove(value) {
+      this.values = this.values.filter((v) => v !== value);
+    }
+    toString() {
+      return this.values.map((v) => v.includes(",") || v.includes(" ") ? `"${v}"` : v).join(", ");
+    }
+    get() {
+      return this.values;
+    }
+  };
+  var Fields = class {
+    constructor({ fields = [], encoding = "utf-8" }) {
+      this.entries = {};
+      fields.forEach(this.setField.bind(this));
+      this.encoding = encoding;
+    }
+    static {
+      __name(this, "Fields");
+    }
+    setField(field) {
+      this.entries[field.name.toLowerCase()] = field;
+    }
+    getField(name) {
+      return this.entries[name.toLowerCase()];
+    }
+    removeField(name) {
+      delete this.entries[name.toLowerCase()];
+    }
+    getByType(kind) {
+      return Object.values(this.entries).filter((field) => field.kind === kind);
+    }
+  };
+  var HttpRequest = class _HttpRequest {
+    static {
+      __name(this, "HttpRequest");
+    }
+    constructor(options) {
+      this.method = options.method || "GET";
+      this.hostname = options.hostname || "localhost";
+      this.port = options.port;
+      this.query = options.query || {};
+      this.headers = options.headers || {};
+      this.body = options.body;
+      this.protocol = options.protocol ? options.protocol.slice(-1) !== ":" ? `${options.protocol}:` : options.protocol : "https:";
+      this.path = options.path ? options.path.charAt(0) !== "/" ? `/${options.path}` : options.path : "/";
+      this.username = options.username;
+      this.password = options.password;
+      this.fragment = options.fragment;
+    }
+    static clone(request) {
+      const cloned = new _HttpRequest({
+        ...request,
+        headers: { ...request.headers }
+      });
+      if (cloned.query) {
+        cloned.query = cloneQuery(cloned.query);
+      }
+      return cloned;
+    }
+    static isInstance(request) {
+      if (!request) {
+        return false;
+      }
+      const req = request;
+      return "method" in req && "protocol" in req && "hostname" in req && "path" in req && typeof req["query"] === "object" && typeof req["headers"] === "object";
+    }
+    clone() {
+      return _HttpRequest.clone(this);
+    }
+  };
+  function cloneQuery(query) {
+    return Object.keys(query).reduce((carry, paramName) => {
+      const param = query[paramName];
+      return {
+        ...carry,
+        [paramName]: Array.isArray(param) ? [...param] : param
+      };
+    }, {});
+  }
+  __name(cloneQuery, "cloneQuery");
+  var HttpResponse = class {
+    static {
+      __name(this, "HttpResponse");
+    }
+    constructor(options) {
+      this.statusCode = options.statusCode;
+      this.reason = options.reason;
+      this.headers = options.headers || {};
+      this.body = options.body;
+    }
+    static isInstance(response) {
+      if (!response)
+        return false;
+      const resp = response;
+      return typeof resp.statusCode === "number" && typeof resp.headers === "object";
+    }
+  };
+  function isValidHostname(hostname) {
+    const hostPattern = /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/;
+    return hostPattern.test(hostname);
+  }
+  __name(isValidHostname, "isValidHostname");
+});
+
+// ../../../../node_modules/@smithy/util-uri-escape/dist-cjs/index.js
+var require_dist_cjs3 = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    escapeUri: () => escapeUri,
+    escapeUriPath: () => escapeUriPath
+  });
+  module.exports = __toCommonJS(src_exports);
+  var escapeUri = /* @__PURE__ */ __name((uri) => encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode), "escapeUri");
+  var hexEncode = /* @__PURE__ */ __name((c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`, "hexEncode");
+  var escapeUriPath = /* @__PURE__ */ __name((uri) => uri.split("/").map(escapeUri).join("/"), "escapeUriPath");
+});
+
+// ../../../../node_modules/@smithy/querystring-builder/dist-cjs/index.js
+var require_dist_cjs4 = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    buildQueryString: () => buildQueryString
+  });
+  module.exports = __toCommonJS(src_exports);
+  var import_util_uri_escape = require_dist_cjs3();
+  function buildQueryString(query) {
+    const parts = [];
+    for (let key of Object.keys(query).sort()) {
+      const value = query[key];
+      key = (0, import_util_uri_escape.escapeUri)(key);
+      if (Array.isArray(value)) {
+        for (let i = 0, iLen = value.length;i < iLen; i++) {
+          parts.push(`${key}=${(0, import_util_uri_escape.escapeUri)(value[i])}`);
+        }
+      } else {
+        let qsEntry = key;
+        if (value || typeof value === "string") {
+          qsEntry += `=${(0, import_util_uri_escape.escapeUri)(value)}`;
+        }
+        parts.push(qsEntry);
+      }
+    }
+    return parts.join("&");
+  }
+  __name(buildQueryString, "buildQueryString");
+});
+
+// ../../../../node_modules/@smithy/node-http-handler/dist-cjs/index.js
+var require_dist_cjs5 = __commonJS((exports, module) => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    DEFAULT_REQUEST_TIMEOUT: () => DEFAULT_REQUEST_TIMEOUT,
+    NodeHttp2Handler: () => NodeHttp2Handler,
+    NodeHttpHandler: () => NodeHttpHandler,
+    streamCollector: () => streamCollector
+  });
+  module.exports = __toCommonJS(src_exports);
+  var import_protocol_http = require_dist_cjs2();
+  var import_querystring_builder = require_dist_cjs4();
+  var import_http = __require("node:http");
+  var import_https = __require("node:https");
+  var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"];
+  var getTransformedHeaders = /* @__PURE__ */ __name((headers) => {
+    const transformedHeaders = {};
+    for (const name of Object.keys(headers)) {
+      const headerValues = headers[name];
+      transformedHeaders[name] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues;
+    }
+    return transformedHeaders;
+  }, "getTransformedHeaders");
+  var timing = {
+    setTimeout: (cb, ms) => setTimeout(cb, ms),
+    clearTimeout: (timeoutId) => clearTimeout(timeoutId)
+  };
+  var DEFER_EVENT_LISTENER_TIME = 1000;
+  var setConnectionTimeout = /* @__PURE__ */ __name((request, reject, timeoutInMs = 0) => {
+    if (!timeoutInMs) {
+      return -1;
+    }
+    const registerTimeout = /* @__PURE__ */ __name((offset) => {
+      const timeoutId = timing.setTimeout(() => {
+        request.destroy();
+        reject(Object.assign(new Error(`Socket timed out without establishing a connection within ${timeoutInMs} ms`), {
+          name: "TimeoutError"
+        }));
+      }, timeoutInMs - offset);
+      const doWithSocket = /* @__PURE__ */ __name((socket) => {
+        if (socket?.connecting) {
+          socket.on("connect", () => {
+            timing.clearTimeout(timeoutId);
+          });
+        } else {
+          timing.clearTimeout(timeoutId);
+        }
+      }, "doWithSocket");
+      if (request.socket) {
+        doWithSocket(request.socket);
+      } else {
+        request.on("socket", doWithSocket);
+      }
+    }, "registerTimeout");
+    if (timeoutInMs < 2000) {
+      registerTimeout(0);
+      return 0;
+    }
+    return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
+  }, "setConnectionTimeout");
+  var DEFER_EVENT_LISTENER_TIME2 = 3000;
+  var setSocketKeepAlive = /* @__PURE__ */ __name((request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME2) => {
+    if (keepAlive !== true) {
+      return -1;
+    }
+    const registerListener = /* @__PURE__ */ __name(() => {
+      if (request.socket) {
+        request.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+      } else {
+        request.on("socket", (socket) => {
+          socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+        });
+      }
+    }, "registerListener");
+    if (deferTimeMs === 0) {
+      registerListener();
+      return 0;
+    }
+    return timing.setTimeout(registerListener, deferTimeMs);
+  }, "setSocketKeepAlive");
+  var DEFER_EVENT_LISTENER_TIME3 = 3000;
+  var setSocketTimeout = /* @__PURE__ */ __name((request, reject, timeoutInMs = DEFAULT_REQUEST_TIMEOUT) => {
+    const registerTimeout = /* @__PURE__ */ __name((offset) => {
+      const timeout = timeoutInMs - offset;
+      const onTimeout = /* @__PURE__ */ __name(() => {
+        request.destroy();
+        reject(Object.assign(new Error(`Connection timed out after ${timeoutInMs} ms`), { name: "TimeoutError" }));
+      }, "onTimeout");
+      if (request.socket) {
+        request.socket.setTimeout(timeout, onTimeout);
+        request.on("close", () => request.socket?.removeListener("timeout", onTimeout));
+      } else {
+        request.setTimeout(timeout, onTimeout);
+      }
+    }, "registerTimeout");
+    if (0 < timeoutInMs && timeoutInMs < 6000) {
+      registerTimeout(0);
+      return 0;
+    }
+    return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME3), DEFER_EVENT_LISTENER_TIME3);
+  }, "setSocketTimeout");
+  var import_stream = __require("node:stream");
+  var MIN_WAIT_TIME = 6000;
+  async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME) {
+    const headers = request.headers ?? {};
+    const expect = headers["Expect"] || headers["expect"];
+    let timeoutId = -1;
+    let sendBody = true;
+    if (expect === "100-continue") {
+      sendBody = await Promise.race([
+        new Promise((resolve) => {
+          timeoutId = Number(timing.setTimeout(() => resolve(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+        }),
+        new Promise((resolve) => {
+          httpRequest.on("continue", () => {
+            timing.clearTimeout(timeoutId);
+            resolve(true);
+          });
+          httpRequest.on("response", () => {
+            timing.clearTimeout(timeoutId);
+            resolve(false);
+          });
+          httpRequest.on("error", () => {
+            timing.clearTimeout(timeoutId);
+            resolve(false);
+          });
+        })
+      ]);
+    }
+    if (sendBody) {
+      writeBody(httpRequest, request.body);
+    }
+  }
+  __name(writeRequestBody, "writeRequestBody");
+  function writeBody(httpRequest, body) {
+    if (body instanceof import_stream.Readable) {
+      body.pipe(httpRequest);
+      return;
+    }
+    if (body) {
+      if (Buffer.isBuffer(body) || typeof body === "string") {
+        httpRequest.end(body);
+        return;
+      }
+      const uint8 = body;
+      if (typeof uint8 === "object" && uint8.buffer && typeof uint8.byteOffset === "number" && typeof uint8.byteLength === "number") {
+        httpRequest.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength));
+        return;
+      }
+      httpRequest.end(Buffer.from(body));
+      return;
+    }
+    httpRequest.end();
+  }
+  __name(writeBody, "writeBody");
+  var DEFAULT_REQUEST_TIMEOUT = 0;
+  var NodeHttpHandler = class _NodeHttpHandler {
+    constructor(options) {
+      this.socketWarningTimestamp = 0;
+      this.metadata = { handlerProtocol: "http/1.1" };
+      this.configProvider = new Promise((resolve, reject) => {
+        if (typeof options === "function") {
+          options().then((_options) => {
+            resolve(this.resolveDefaultConfig(_options));
+          }).catch(reject);
+        } else {
+          resolve(this.resolveDefaultConfig(options));
+        }
+      });
+    }
+    static {
+      __name(this, "NodeHttpHandler");
+    }
+    static create(instanceOrOptions) {
+      if (typeof instanceOrOptions?.handle === "function") {
+        return instanceOrOptions;
+      }
+      return new _NodeHttpHandler(instanceOrOptions);
+    }
+    static checkSocketUsage(agent, socketWarningTimestamp, logger = console) {
+      const { sockets, requests, maxSockets } = agent;
+      if (typeof maxSockets !== "number" || maxSockets === Infinity) {
+        return socketWarningTimestamp;
+      }
+      const interval = 15000;
+      if (Date.now() - interval < socketWarningTimestamp) {
+        return socketWarningTimestamp;
+      }
+      if (sockets && requests) {
+        for (const origin in sockets) {
+          const socketsInUse = sockets[origin]?.length ?? 0;
+          const requestsEnqueued = requests[origin]?.length ?? 0;
+          if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) {
+            logger?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.
+See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html
+or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`);
+            return Date.now();
+          }
+        }
+      }
+      return socketWarningTimestamp;
+    }
+    resolveDefaultConfig(options) {
+      const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent } = options || {};
+      const keepAlive = true;
+      const maxSockets = 50;
+      return {
+        connectionTimeout,
+        requestTimeout: requestTimeout ?? socketTimeout,
+        socketAcquisitionWarningTimeout,
+        httpAgent: (() => {
+          if (httpAgent instanceof import_http.Agent || typeof httpAgent?.destroy === "function") {
+            return httpAgent;
+          }
+          return new import_http.Agent({ keepAlive, maxSockets, ...httpAgent });
+        })(),
+        httpsAgent: (() => {
+          if (httpsAgent instanceof import_https.Agent || typeof httpsAgent?.destroy === "function") {
+            return httpsAgent;
+          }
+          return new import_https.Agent({ keepAlive, maxSockets, ...httpsAgent });
+        })(),
+        logger: console
+      };
+    }
+    destroy() {
+      this.config?.httpAgent?.destroy();
+      this.config?.httpsAgent?.destroy();
+    }
+    async handle(request, { abortSignal } = {}) {
+      if (!this.config) {
+        this.config = await this.configProvider;
+      }
+      return new Promise((_resolve, _reject) => {
+        let writeRequestBodyPromise = undefined;
+        const timeouts = [];
+        const resolve = /* @__PURE__ */ __name(async (arg) => {
+          await writeRequestBodyPromise;
+          timeouts.forEach(timing.clearTimeout);
+          _resolve(arg);
+        }, "resolve");
+        const reject = /* @__PURE__ */ __name(async (arg) => {
+          await writeRequestBodyPromise;
+          timeouts.forEach(timing.clearTimeout);
+          _reject(arg);
+        }, "reject");
+        if (!this.config) {
+          throw new Error("Node HTTP request handler config is not resolved");
+        }
+        if (abortSignal?.aborted) {
+          const abortError = new Error("Request aborted");
+          abortError.name = "AbortError";
+          reject(abortError);
+          return;
+        }
+        const isSSL = request.protocol === "https:";
+        const agent = isSSL ? this.config.httpsAgent : this.config.httpAgent;
+        timeouts.push(timing.setTimeout(() => {
+          this.socketWarningTimestamp = _NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, this.config.logger);
+        }, this.config.socketAcquisitionWarningTimeout ?? (this.config.requestTimeout ?? 2000) + (this.config.connectionTimeout ?? 1000)));
+        const queryString = (0, import_querystring_builder.buildQueryString)(request.query || {});
+        let auth = undefined;
+        if (request.username != null || request.password != null) {
+          const username = request.username ?? "";
+          const password = request.password ?? "";
+          auth = `${username}:${password}`;
+        }
+        let path = request.path;
+        if (queryString) {
+          path += `?${queryString}`;
+        }
+        if (request.fragment) {
+          path += `#${request.fragment}`;
+        }
+        let hostname = request.hostname ?? "";
+        if (hostname[0] === "[" && hostname.endsWith("]")) {
+          hostname = request.hostname.slice(1, -1);
+        } else {
+          hostname = request.hostname;
+        }
+        const nodeHttpsOptions = {
+          headers: request.headers,
+          host: hostname,
+          method: request.method,
+          path,
+          port: request.port,
+          agent,
+          auth
+        };
+        const requestFunc = isSSL ? import_https.request : import_http.request;
+        const req = requestFunc(nodeHttpsOptions, (res) => {
+          const httpResponse = new import_protocol_http.HttpResponse({
+            statusCode: res.statusCode || -1,
+            reason: res.statusMessage,
+            headers: getTransformedHeaders(res.headers),
+            body: res
+          });
+          resolve({ response: httpResponse });
+        });
+        req.on("error", (err) => {
+          if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
+            reject(Object.assign(err, { name: "TimeoutError" }));
+          } else {
+            reject(err);
+          }
+        });
+        if (abortSignal) {
+          const onAbort = /* @__PURE__ */ __name(() => {
+            req.destroy();
+            const abortError = new Error("Request aborted");
+            abortError.name = "AbortError";
+            reject(abortError);
+          }, "onAbort");
+          if (typeof abortSignal.addEventListener === "function") {
+            const signal = abortSignal;
+            signal.addEventListener("abort", onAbort, { once: true });
+            req.once("close", () => signal.removeEventListener("abort", onAbort));
+          } else {
+            abortSignal.onabort = onAbort;
+          }
+        }
+        timeouts.push(setConnectionTimeout(req, reject, this.config.connectionTimeout));
+        timeouts.push(setSocketTimeout(req, reject, this.config.requestTimeout));
+        const httpAgent = nodeHttpsOptions.agent;
+        if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
+          timeouts.push(setSocketKeepAlive(req, {
+            keepAlive: httpAgent.keepAlive,
+            keepAliveMsecs: httpAgent.keepAliveMsecs
+          }));
+        }
+        writeRequestBodyPromise = writeRequestBody(req, request, this.config.requestTimeout).catch((e) => {
+          timeouts.forEach(timing.clearTimeout);
+          return _reject(e);
+        });
+      });
+    }
+    updateHttpClientConfig(key, value) {
+      this.config = undefined;
+      this.configProvider = this.configProvider.then((config) => {
+        return {
+          ...config,
+          [key]: value
+        };
+      });
+    }
+    httpHandlerConfigs() {
+      return this.config ?? {};
+    }
+  };
+  var import_http22 = __require("node:http2");
+  var import_http2 = __toESM(__require("node:http2"));
+  var NodeHttp2ConnectionPool = class {
+    constructor(sessions) {
+      this.sessions = [];
+      this.sessions = sessions ?? [];
+    }
+    static {
+      __name(this, "NodeHttp2ConnectionPool");
+    }
+    poll() {
+      if (this.sessions.length > 0) {
+        return this.sessions.shift();
+      }
+    }
+    offerLast(session) {
+      this.sessions.push(session);
+    }
+    contains(session) {
+      return this.sessions.includes(session);
+    }
+    remove(session) {
+      this.sessions = this.sessions.filter((s) => s !== session);
+    }
+    [Symbol.iterator]() {
+      return this.sessions[Symbol.iterator]();
+    }
+    destroy(connection) {
+      for (const session of this.sessions) {
+        if (session === connection) {
+          if (!session.destroyed) {
+            session.destroy();
+          }
+        }
+      }
+    }
+  };
+  var NodeHttp2ConnectionManager = class {
+    constructor(config) {
+      this.sessionCache = /* @__PURE__ */ new Map;
+      this.config = config;
+      if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) {
+        throw new RangeError("maxConcurrency must be greater than zero.");
+      }
+    }
+    static {
+      __name(this, "NodeHttp2ConnectionManager");
+    }
+    lease(requestContext, connectionConfiguration) {
+      const url = this.getUrlString(requestContext);
+      const existingPool = this.sessionCache.get(url);
+      if (existingPool) {
+        const existingSession = existingPool.poll();
+        if (existingSession && !this.config.disableConcurrency) {
+          return existingSession;
+        }
+      }
+      const session = import_http2.default.connect(url);
+      if (this.config.maxConcurrency) {
+        session.settings({ maxConcurrentStreams: this.config.maxConcurrency }, (err) => {
+          if (err) {
+            throw new Error("Fail to set maxConcurrentStreams to " + this.config.maxConcurrency + "when creating new session for " + requestContext.destination.toString());
+          }
+        });
+      }
+      session.unref();
+      const destroySessionCb = /* @__PURE__ */ __name(() => {
+        session.destroy();
+        this.deleteSession(url, session);
+      }, "destroySessionCb");
+      session.on("goaway", destroySessionCb);
+      session.on("error", destroySessionCb);
+      session.on("frameError", destroySessionCb);
+      session.on("close", () => this.deleteSession(url, session));
+      if (connectionConfiguration.requestTimeout) {
+        session.setTimeout(connectionConfiguration.requestTimeout, destroySessionCb);
+      }
+      const connectionPool = this.sessionCache.get(url) || new NodeHttp2ConnectionPool;
+      connectionPool.offerLast(session);
+      this.sessionCache.set(url, connectionPool);
+      return session;
+    }
+    deleteSession(authority, session) {
+      const existingConnectionPool = this.sessionCache.get(authority);
+      if (!existingConnectionPool) {
+        return;
+      }
+      if (!existingConnectionPool.contains(session)) {
+        return;
+      }
+      existingConnectionPool.remove(session);
+      this.sessionCache.set(authority, existingConnectionPool);
+    }
+    release(requestContext, session) {
+      const cacheKey = this.getUrlString(requestContext);
+      this.sessionCache.get(cacheKey)?.offerLast(session);
+    }
+    destroy() {
+      for (const [key, connectionPool] of this.sessionCache) {
+        for (const session of connectionPool) {
+          if (!session.destroyed) {
+            session.destroy();
+          }
+          connectionPool.remove(session);
+        }
+        this.sessionCache.delete(key);
+      }
+    }
+    setMaxConcurrentStreams(maxConcurrentStreams) {
+      if (maxConcurrentStreams && maxConcurrentStreams <= 0) {
+        throw new RangeError("maxConcurrentStreams must be greater than zero.");
+      }
+      this.config.maxConcurrency = maxConcurrentStreams;
+    }
+    setDisableConcurrentStreams(disableConcurrentStreams) {
+      this.config.disableConcurrency = disableConcurrentStreams;
+    }
+    getUrlString(request) {
+      return request.destination.toString();
+    }
+  };
+  var NodeHttp2Handler = class _NodeHttp2Handler {
+    constructor(options) {
+      this.metadata = { handlerProtocol: "h2" };
+      this.connectionManager = new NodeHttp2ConnectionManager({});
+      this.configProvider = new Promise((resolve, reject) => {
+        if (typeof options === "function") {
+          options().then((opts) => {
+            resolve(opts || {});
+          }).catch(reject);
+        } else {
+          resolve(options || {});
+        }
+      });
+    }
+    static {
+      __name(this, "NodeHttp2Handler");
+    }
+    static create(instanceOrOptions) {
+      if (typeof instanceOrOptions?.handle === "function") {
+        return instanceOrOptions;
+      }
+      return new _NodeHttp2Handler(instanceOrOptions);
+    }
+    destroy() {
+      this.connectionManager.destroy();
+    }
+    async handle(request, { abortSignal } = {}) {
+      if (!this.config) {
+        this.config = await this.configProvider;
+        this.connectionManager.setDisableConcurrentStreams(this.config.disableConcurrentStreams || false);
+        if (this.config.maxConcurrentStreams) {
+          this.connectionManager.setMaxConcurrentStreams(this.config.maxConcurrentStreams);
+        }
+      }
+      const { requestTimeout, disableConcurrentStreams } = this.config;
+      return new Promise((_resolve, _reject) => {
+        let fulfilled = false;
+        let writeRequestBodyPromise = undefined;
+        const resolve = /* @__PURE__ */ __name(async (arg) => {
+          await writeRequestBodyPromise;
+          _resolve(arg);
+        }, "resolve");
+        const reject = /* @__PURE__ */ __name(async (arg) => {
+          await writeRequestBodyPromise;
+          _reject(arg);
+        }, "reject");
+        if (abortSignal?.aborted) {
+          fulfilled = true;
+          const abortError = new Error("Request aborted");
+          abortError.name = "AbortError";
+          reject(abortError);
+          return;
+        }
+        const { hostname, method, port, protocol, query } = request;
+        let auth = "";
+        if (request.username != null || request.password != null) {
+          const username = request.username ?? "";
+          const password = request.password ?? "";
+          auth = `${username}:${password}@`;
+        }
+        const authority = `${protocol}//${auth}${hostname}${port ? `:${port}` : ""}`;
+        const requestContext = { destination: new URL(authority) };
+        const session = this.connectionManager.lease(requestContext, {
+          requestTimeout: this.config?.sessionTimeout,
+          disableConcurrentStreams: disableConcurrentStreams || false
+        });
+        const rejectWithDestroy = /* @__PURE__ */ __name((err) => {
+          if (disableConcurrentStreams) {
+            this.destroySession(session);
+          }
+          fulfilled = true;
+          reject(err);
+        }, "rejectWithDestroy");
+        const queryString = (0, import_querystring_builder.buildQueryString)(query || {});
+        let path = request.path;
+        if (queryString) {
+          path += `?${queryString}`;
+        }
+        if (request.fragment) {
+          path += `#${request.fragment}`;
+        }
+        const req = session.request({
+          ...request.headers,
+          [import_http22.constants.HTTP2_HEADER_PATH]: path,
+          [import_http22.constants.HTTP2_HEADER_METHOD]: method
+        });
+        session.ref();
+        req.on("response", (headers) => {
+          const httpResponse = new import_protocol_http.HttpResponse({
+            statusCode: headers[":status"] || -1,
+            headers: getTransformedHeaders(headers),
+            body: req
+          });
+          fulfilled = true;
+          resolve({ response: httpResponse });
+          if (disableConcurrentStreams) {
+            session.close();
+            this.connectionManager.deleteSession(authority, session);
+          }
+        });
+        if (requestTimeout) {
+          req.setTimeout(requestTimeout, () => {
+            req.close();
+            const timeoutError = new Error(`Stream timed out because of no activity for ${requestTimeout} ms`);
+            timeoutError.name = "TimeoutError";
+            rejectWithDestroy(timeoutError);
+          });
+        }
+        if (abortSignal) {
+          const onAbort = /* @__PURE__ */ __name(() => {
+            req.close();
+            const abortError = new Error("Request aborted");
+            abortError.name = "AbortError";
+            rejectWithDestroy(abortError);
+          }, "onAbort");
+          if (typeof abortSignal.addEventListener === "function") {
+            const signal = abortSignal;
+            signal.addEventListener("abort", onAbort, { once: true });
+            req.once("close", () => signal.removeEventListener("abort", onAbort));
+          } else {
+            abortSignal.onabort = onAbort;
+          }
+        }
+        req.on("frameError", (type, code, id) => {
+          rejectWithDestroy(new Error(`Frame type id ${type} in stream id ${id} has failed with code ${code}.`));
+        });
+        req.on("error", rejectWithDestroy);
+        req.on("aborted", () => {
+          rejectWithDestroy(new Error(`HTTP/2 stream is abnormally aborted in mid-communication with result code ${req.rstCode}.`));
+        });
+        req.on("close", () => {
+          session.unref();
+          if (disableConcurrentStreams) {
+            session.destroy();
+          }
+          if (!fulfilled) {
+            rejectWithDestroy(new Error("Unexpected error: http2 request did not get a response"));
+          }
+        });
+        writeRequestBodyPromise = writeRequestBody(req, request, requestTimeout);
+      });
+    }
+    updateHttpClientConfig(key, value) {
+      this.config = undefined;
+      this.configProvider = this.configProvider.then((config) => {
+        return {
+          ...config,
+          [key]: value
+        };
+      });
+    }
+    httpHandlerConfigs() {
+      return this.config ?? {};
+    }
+    destroySession(session) {
+      if (!session.destroyed) {
+        session.destroy();
+      }
+    }
+  };
+  var Collector = class extends import_stream.Writable {
+    constructor() {
+      super(...arguments);
+      this.bufferedBytes = [];
+    }
+    static {
+      __name(this, "Collector");
+    }
+    _write(chunk, encoding, callback) {
+      this.bufferedBytes.push(chunk);
+      callback();
+    }
+  };
+  var streamCollector = /* @__PURE__ */ __name((stream) => {
+    if (isReadableStreamInstance(stream)) {
+      return collectReadableStream(stream);
+    }
+    return new Promise((resolve, reject) => {
+      const collector = new Collector;
+      stream.pipe(collector);
+      stream.on("error", (err) => {
+        collector.end();
+        reject(err);
+      });
+      collector.on("error", reject);
+      collector.on("finish", function() {
+        const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
+        resolve(bytes);
+      });
+    });
+  }, "streamCollector");
+  var isReadableStreamInstance = /* @__PURE__ */ __name((stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream, "isReadableStreamInstance");
+  async function collectReadableStream(stream) {
+    const chunks = [];
+    const reader = stream.getReader();
+    let isDone = false;
+    let length = 0;
+    while (!isDone) {
+      const { done, value } = await reader.read();
+      if (value) {
+        chunks.push(value);
+        length += value.length;
+      }
+      isDone = done;
+    }
+    const collected = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+      collected.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return collected;
+  }
+  __name(collectReadableStream, "collectReadableStream");
+});
+
+// ../../../../node_modules/@smithy/is-array-buffer/dist-cjs/index.js
+var require_dist_cjs6 = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    isArrayBuffer: () => isArrayBuffer
+  });
+  module.exports = __toCommonJS(src_exports);
+  var isArrayBuffer = /* @__PURE__ */ __name((arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]", "isArrayBuffer");
+});
+
+// ../../../../node_modules/@smithy/util-buffer-from/dist-cjs/index.js
+var require_dist_cjs7 = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    fromArrayBuffer: () => fromArrayBuffer,
+    fromString: () => fromString
+  });
+  module.exports = __toCommonJS(src_exports);
+  var import_is_array_buffer = require_dist_cjs6();
+  var import_buffer = __require("node:buffer");
+  var fromArrayBuffer = /* @__PURE__ */ __name((input, offset = 0, length = input.byteLength - offset) => {
+    if (!(0, import_is_array_buffer.isArrayBuffer)(input)) {
+      throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
+    }
+    return import_buffer.Buffer.from(input, offset, length);
+  }, "fromArrayBuffer");
+  var fromString = /* @__PURE__ */ __name((input, encoding) => {
+    if (typeof input !== "string") {
+      throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
+    }
+    return encoding ? import_buffer.Buffer.from(input, encoding) : import_buffer.Buffer.from(input);
+  }, "fromString");
+});
+
+// ../../../../node_modules/@smithy/util-base64/dist-cjs/fromBase64.js
+var require_fromBase64 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromBase64 = undefined;
+  var util_buffer_from_1 = require_dist_cjs7();
+  var BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
+  var fromBase642 = (input) => {
+    if (input.length * 3 % 4 !== 0) {
+      throw new TypeError(`Incorrect padding on base64 string.`);
+    }
+    if (!BASE64_REGEX.exec(input)) {
+      throw new TypeError(`Invalid base64 string.`);
+    }
+    const buffer = (0, util_buffer_from_1.fromString)(input, "base64");
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  };
+  exports.fromBase64 = fromBase642;
+});
+
+// ../../../../node_modules/@smithy/util-utf8/dist-cjs/index.js
+var require_dist_cjs8 = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    fromUtf8: () => fromUtf8,
+    toUint8Array: () => toUint8Array,
+    toUtf8: () => toUtf8
+  });
+  module.exports = __toCommonJS(src_exports);
+  var import_util_buffer_from = require_dist_cjs7();
+  var fromUtf8 = /* @__PURE__ */ __name((input) => {
+    const buf = (0, import_util_buffer_from.fromString)(input, "utf8");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+  }, "fromUtf8");
+  var toUint8Array = /* @__PURE__ */ __name((data) => {
+    if (typeof data === "string") {
+      return fromUtf8(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+    }
+    return new Uint8Array(data);
+  }, "toUint8Array");
+  var toUtf8 = /* @__PURE__ */ __name((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 (0, import_util_buffer_from.fromArrayBuffer)(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
+  }, "toUtf8");
+});
+
+// ../../../../node_modules/@smithy/util-base64/dist-cjs/toBase64.js
+var require_toBase64 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.toBase64 = undefined;
+  var util_buffer_from_1 = require_dist_cjs7();
+  var util_utf8_1 = require_dist_cjs8();
+  var toBase642 = (_input) => {
+    let input;
+    if (typeof _input === "string") {
+      input = (0, util_utf8_1.fromUtf8)(_input);
+    } else {
+      input = _input;
+    }
+    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+      throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
+    }
+    return (0, util_buffer_from_1.fromArrayBuffer)(input.buffer, input.byteOffset, input.byteLength).toString("base64");
+  };
+  exports.toBase64 = toBase642;
+});
+
+// ../../../../node_modules/@smithy/util-base64/dist-cjs/index.js
+var require_dist_cjs9 = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  module.exports = __toCommonJS(src_exports);
+  __reExport(src_exports, require_fromBase64(), module.exports);
+  __reExport(src_exports, require_toBase64(), module.exports);
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/checksum/ChecksumStream.js
+var require_ChecksumStream = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ChecksumStream = undefined;
+  var util_base64_1 = require_dist_cjs9();
+  var stream_1 = __require("node:stream");
+
+  class ChecksumStream2 extends stream_1.Duplex {
+    constructor({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder }) {
+      var _a, _b;
+      super();
+      if (typeof source.pipe === "function") {
+        this.source = source;
+      } else {
+        throw new Error(`@smithy/util-stream: unsupported source type ${(_b = (_a = source === null || source === undefined ? undefined : source.constructor) === null || _a === undefined ? undefined : _a.name) !== null && _b !== undefined ? _b : source} in ChecksumStream.`);
+      }
+      this.base64Encoder = base64Encoder !== null && base64Encoder !== undefined ? base64Encoder : util_base64_1.toBase64;
+      this.expectedChecksum = expectedChecksum;
+      this.checksum = checksum;
+      this.checksumSourceLocation = checksumSourceLocation;
+      this.source.pipe(this);
+    }
+    _read(size) {}
+    _write(chunk, encoding, callback) {
+      try {
+        this.checksum.update(chunk);
+        this.push(chunk);
+      } catch (e) {
+        return callback(e);
+      }
+      return callback();
+    }
+    async _final(callback) {
+      try {
+        const digest = await this.checksum.digest();
+        const received = this.base64Encoder(digest);
+        if (this.expectedChecksum !== received) {
+          return callback(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${received}"` + ` in response header "${this.checksumSourceLocation}".`));
+        }
+      } catch (e) {
+        return callback(e);
+      }
+      this.push(null);
+      return callback();
+    }
+  }
+  exports.ChecksumStream = ChecksumStream2;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/stream-type-check.js
+var require_stream_type_check = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isBlob = exports.isReadableStream = undefined;
+  var isReadableStream2 = (stream) => {
+    var _a;
+    return typeof ReadableStream === "function" && (((_a = stream === null || stream === undefined ? undefined : stream.constructor) === null || _a === undefined ? undefined : _a.name) === ReadableStream.name || stream instanceof ReadableStream);
+  };
+  exports.isReadableStream = isReadableStream2;
+  var isBlob2 = (blob) => {
+    var _a;
+    return typeof Blob === "function" && (((_a = blob === null || blob === undefined ? undefined : blob.constructor) === null || _a === undefined ? undefined : _a.name) === Blob.name || blob instanceof Blob);
+  };
+  exports.isBlob = isBlob2;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/checksum/ChecksumStream.browser.js
+var require_ChecksumStream_browser = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ChecksumStream = undefined;
+  var ReadableStreamRef = typeof ReadableStream === "function" ? ReadableStream : function() {};
+
+  class ChecksumStream2 extends ReadableStreamRef {
+  }
+  exports.ChecksumStream = ChecksumStream2;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/checksum/createChecksumStream.browser.js
+var require_createChecksumStream_browser = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createChecksumStream = undefined;
+  var util_base64_1 = require_dist_cjs9();
+  var stream_type_check_1 = require_stream_type_check();
+  var ChecksumStream_browser_1 = require_ChecksumStream_browser();
+  var createChecksumStream2 = ({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder }) => {
+    var _a, _b;
+    if (!(0, stream_type_check_1.isReadableStream)(source)) {
+      throw new Error(`@smithy/util-stream: unsupported source type ${(_b = (_a = source === null || source === undefined ? undefined : source.constructor) === null || _a === undefined ? undefined : _a.name) !== null && _b !== undefined ? _b : source} in ChecksumStream.`);
+    }
+    const encoder = base64Encoder !== null && base64Encoder !== undefined ? base64Encoder : util_base64_1.toBase64;
+    if (typeof TransformStream !== "function") {
+      throw new Error("@smithy/util-stream: unable to instantiate ChecksumStream because API unavailable: ReadableStream/TransformStream.");
+    }
+    const transform = new TransformStream({
+      start() {},
+      async transform(chunk, controller) {
+        checksum.update(chunk);
+        controller.enqueue(chunk);
+      },
+      async flush(controller) {
+        const digest = await checksum.digest();
+        const received = encoder(digest);
+        if (expectedChecksum !== received) {
+          const error = new Error(`Checksum mismatch: expected "${expectedChecksum}" but received "${received}"` + ` in response header "${checksumSourceLocation}".`);
+          controller.error(error);
+        } else {
+          controller.terminate();
+        }
+      }
+    });
+    source.pipeThrough(transform);
+    const readable = transform.readable;
+    Object.setPrototypeOf(readable, ChecksumStream_browser_1.ChecksumStream.prototype);
+    return readable;
+  };
+  exports.createChecksumStream = createChecksumStream2;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/checksum/createChecksumStream.js
+var require_createChecksumStream = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createChecksumStream = undefined;
+  var stream_type_check_1 = require_stream_type_check();
+  var ChecksumStream_1 = require_ChecksumStream();
+  var createChecksumStream_browser_1 = require_createChecksumStream_browser();
+  function createChecksumStream2(init) {
+    if (typeof ReadableStream === "function" && (0, stream_type_check_1.isReadableStream)(init.source)) {
+      return (0, createChecksumStream_browser_1.createChecksumStream)(init);
+    }
+    return new ChecksumStream_1.ChecksumStream(init);
+  }
+  exports.createChecksumStream = createChecksumStream2;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/ByteArrayCollector.js
+var require_ByteArrayCollector = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ByteArrayCollector = undefined;
+
+  class ByteArrayCollector {
+    constructor(allocByteArray) {
+      this.allocByteArray = allocByteArray;
+      this.byteLength = 0;
+      this.byteArrays = [];
+    }
+    push(byteArray) {
+      this.byteArrays.push(byteArray);
+      this.byteLength += byteArray.byteLength;
+    }
+    flush() {
+      if (this.byteArrays.length === 1) {
+        const bytes = this.byteArrays[0];
+        this.reset();
+        return bytes;
+      }
+      const aggregation = this.allocByteArray(this.byteLength);
+      let cursor = 0;
+      for (let i = 0;i < this.byteArrays.length; ++i) {
+        const bytes = this.byteArrays[i];
+        aggregation.set(bytes, cursor);
+        cursor += bytes.byteLength;
+      }
+      this.reset();
+      return aggregation;
+    }
+    reset() {
+      this.byteArrays = [];
+      this.byteLength = 0;
+    }
+  }
+  exports.ByteArrayCollector = ByteArrayCollector;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/createBufferedReadableStream.js
+var require_createBufferedReadableStream = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.modeOf = exports.sizeOf = exports.flush = exports.merge = exports.createBufferedReadable = exports.createBufferedReadableStream = undefined;
+  var ByteArrayCollector_1 = require_ByteArrayCollector();
+  function createBufferedReadableStream(upstream, size, logger) {
+    const reader = upstream.getReader();
+    let streamBufferingLoggedWarning = false;
+    let bytesSeen = 0;
+    const buffers = ["", new ByteArrayCollector_1.ByteArrayCollector((size2) => new Uint8Array(size2))];
+    let mode = -1;
+    const pull = async (controller) => {
+      const { value, done } = await reader.read();
+      const chunk = value;
+      if (done) {
+        if (mode !== -1) {
+          const remainder = flush(buffers, mode);
+          if (sizeOf(remainder) > 0) {
+            controller.enqueue(remainder);
+          }
+        }
+        controller.close();
+      } else {
+        const chunkMode = modeOf(chunk, false);
+        if (mode !== chunkMode) {
+          if (mode >= 0) {
+            controller.enqueue(flush(buffers, mode));
+          }
+          mode = chunkMode;
+        }
+        if (mode === -1) {
+          controller.enqueue(chunk);
+          return;
+        }
+        const chunkSize = sizeOf(chunk);
+        bytesSeen += chunkSize;
+        const bufferSize = sizeOf(buffers[mode]);
+        if (chunkSize >= size && bufferSize === 0) {
+          controller.enqueue(chunk);
+        } else {
+          const newSize = merge(buffers, mode, chunk);
+          if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
+            streamBufferingLoggedWarning = true;
+            logger === null || logger === undefined || logger.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
+          }
+          if (newSize >= size) {
+            controller.enqueue(flush(buffers, mode));
+          } else {
+            await pull(controller);
+          }
+        }
+      }
+    };
+    return new ReadableStream({
+      pull
+    });
+  }
+  exports.createBufferedReadableStream = createBufferedReadableStream;
+  exports.createBufferedReadable = createBufferedReadableStream;
+  function merge(buffers, mode, chunk) {
+    switch (mode) {
+      case 0:
+        buffers[0] += chunk;
+        return sizeOf(buffers[0]);
+      case 1:
+      case 2:
+        buffers[mode].push(chunk);
+        return sizeOf(buffers[mode]);
+    }
+  }
+  exports.merge = merge;
+  function flush(buffers, mode) {
+    switch (mode) {
+      case 0:
+        const s = buffers[0];
+        buffers[0] = "";
+        return s;
+      case 1:
+      case 2:
+        return buffers[mode].flush();
+    }
+    throw new Error(`@smithy/util-stream - invalid index ${mode} given to flush()`);
+  }
+  exports.flush = flush;
+  function sizeOf(chunk) {
+    var _a, _b;
+    return (_b = (_a = chunk === null || chunk === undefined ? undefined : chunk.byteLength) !== null && _a !== undefined ? _a : chunk === null || chunk === undefined ? undefined : chunk.length) !== null && _b !== undefined ? _b : 0;
+  }
+  exports.sizeOf = sizeOf;
+  function modeOf(chunk, allowBuffer = true) {
+    if (allowBuffer && typeof Buffer !== "undefined" && chunk instanceof Buffer) {
+      return 2;
+    }
+    if (chunk instanceof Uint8Array) {
+      return 1;
+    }
+    if (typeof chunk === "string") {
+      return 0;
+    }
+    return -1;
+  }
+  exports.modeOf = modeOf;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/createBufferedReadable.js
+var require_createBufferedReadable = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createBufferedReadable = undefined;
+  var node_stream_1 = __require("node:stream");
+  var ByteArrayCollector_1 = require_ByteArrayCollector();
+  var createBufferedReadableStream_1 = require_createBufferedReadableStream();
+  var stream_type_check_1 = require_stream_type_check();
+  function createBufferedReadable2(upstream, size, logger) {
+    if ((0, stream_type_check_1.isReadableStream)(upstream)) {
+      return (0, createBufferedReadableStream_1.createBufferedReadableStream)(upstream, size, logger);
+    }
+    const downstream = new node_stream_1.Readable({ read() {} });
+    let streamBufferingLoggedWarning = false;
+    let bytesSeen = 0;
+    const buffers = [
+      "",
+      new ByteArrayCollector_1.ByteArrayCollector((size2) => new Uint8Array(size2)),
+      new ByteArrayCollector_1.ByteArrayCollector((size2) => Buffer.from(new Uint8Array(size2)))
+    ];
+    let mode = -1;
+    upstream.on("data", (chunk) => {
+      const chunkMode = (0, createBufferedReadableStream_1.modeOf)(chunk, true);
+      if (mode !== chunkMode) {
+        if (mode >= 0) {
+          downstream.push((0, createBufferedReadableStream_1.flush)(buffers, mode));
+        }
+        mode = chunkMode;
+      }
+      if (mode === -1) {
+        downstream.push(chunk);
+        return;
+      }
+      const chunkSize = (0, createBufferedReadableStream_1.sizeOf)(chunk);
+      bytesSeen += chunkSize;
+      const bufferSize = (0, createBufferedReadableStream_1.sizeOf)(buffers[mode]);
+      if (chunkSize >= size && bufferSize === 0) {
+        downstream.push(chunk);
+      } else {
+        const newSize = (0, createBufferedReadableStream_1.merge)(buffers, mode, chunk);
+        if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
+          streamBufferingLoggedWarning = true;
+          logger === null || logger === undefined || logger.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
+        }
+        if (newSize >= size) {
+          downstream.push((0, createBufferedReadableStream_1.flush)(buffers, mode));
+        }
+      }
+    });
+    upstream.on("end", () => {
+      if (mode !== -1) {
+        const remainder = (0, createBufferedReadableStream_1.flush)(buffers, mode);
+        if ((0, createBufferedReadableStream_1.sizeOf)(remainder) > 0) {
+          downstream.push(remainder);
+        }
+      }
+      downstream.push(null);
+    });
+    return downstream;
+  }
+  exports.createBufferedReadable = createBufferedReadable2;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/getAwsChunkedEncodingStream.js
+var require_getAwsChunkedEncodingStream = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getAwsChunkedEncodingStream = undefined;
+  var stream_1 = __require("node:stream");
+  var getAwsChunkedEncodingStream2 = (readableStream, options) => {
+    const { base64Encoder, bodyLengthChecker, checksumAlgorithmFn, checksumLocationName, streamHasher } = options;
+    const checksumRequired = base64Encoder !== undefined && checksumAlgorithmFn !== undefined && checksumLocationName !== undefined && streamHasher !== undefined;
+    const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readableStream) : undefined;
+    const awsChunkedEncodingStream = new stream_1.Readable({ read: () => {} });
+    readableStream.on("data", (data) => {
+      const length = bodyLengthChecker(data) || 0;
+      awsChunkedEncodingStream.push(`${length.toString(16)}\r
+`);
+      awsChunkedEncodingStream.push(data);
+      awsChunkedEncodingStream.push(`\r
+`);
+    });
+    readableStream.on("end", async () => {
+      awsChunkedEncodingStream.push(`0\r
+`);
+      if (checksumRequired) {
+        const checksum = base64Encoder(await digest);
+        awsChunkedEncodingStream.push(`${checksumLocationName}:${checksum}\r
+`);
+        awsChunkedEncodingStream.push(`\r
+`);
+      }
+      awsChunkedEncodingStream.push(null);
+    });
+    return awsChunkedEncodingStream;
+  };
+  exports.getAwsChunkedEncodingStream = getAwsChunkedEncodingStream2;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/headStream.browser.js
+var require_headStream_browser = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.headStream = undefined;
+  async function headStream2(stream, bytes) {
+    var _a;
+    let byteLengthCounter = 0;
+    const chunks = [];
+    const reader = stream.getReader();
+    let isDone = false;
+    while (!isDone) {
+      const { done, value } = await reader.read();
+      if (value) {
+        chunks.push(value);
+        byteLengthCounter += (_a = value === null || value === undefined ? undefined : value.byteLength) !== null && _a !== undefined ? _a : 0;
+      }
+      if (byteLengthCounter >= bytes) {
+        break;
+      }
+      isDone = done;
+    }
+    reader.releaseLock();
+    const collected = new Uint8Array(Math.min(bytes, byteLengthCounter));
+    let offset = 0;
+    for (const chunk of chunks) {
+      if (chunk.byteLength > collected.byteLength - offset) {
+        collected.set(chunk.subarray(0, collected.byteLength - offset), offset);
+        break;
+      } else {
+        collected.set(chunk, offset);
+      }
+      offset += chunk.length;
+    }
+    return collected;
+  }
+  exports.headStream = headStream2;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/headStream.js
+var require_headStream = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.headStream = undefined;
+  var stream_1 = __require("node:stream");
+  var headStream_browser_1 = require_headStream_browser();
+  var stream_type_check_1 = require_stream_type_check();
+  var headStream2 = (stream, bytes) => {
+    if ((0, stream_type_check_1.isReadableStream)(stream)) {
+      return (0, headStream_browser_1.headStream)(stream, bytes);
+    }
+    return new Promise((resolve, reject) => {
+      const collector = new Collector;
+      collector.limit = bytes;
+      stream.pipe(collector);
+      stream.on("error", (err) => {
+        collector.end();
+        reject(err);
+      });
+      collector.on("error", reject);
+      collector.on("finish", function() {
+        const bytes2 = new Uint8Array(Buffer.concat(this.buffers));
+        resolve(bytes2);
+      });
+    });
+  };
+  exports.headStream = headStream2;
+
+  class Collector extends stream_1.Writable {
+    constructor() {
+      super(...arguments);
+      this.buffers = [];
+      this.limit = Infinity;
+      this.bytesBuffered = 0;
+    }
+    _write(chunk, encoding, callback) {
+      var _a;
+      this.buffers.push(chunk);
+      this.bytesBuffered += (_a = chunk.byteLength) !== null && _a !== undefined ? _a : 0;
+      if (this.bytesBuffered >= this.limit) {
+        const excess = this.bytesBuffered - this.limit;
+        const tailBuffer = this.buffers[this.buffers.length - 1];
+        this.buffers[this.buffers.length - 1] = tailBuffer.subarray(0, tailBuffer.byteLength - excess);
+        this.emit("finish");
+      }
+      callback();
+    }
+  }
+});
+
+// ../../../../node_modules/@smithy/fetch-http-handler/dist-cjs/index.js
+var require_dist_cjs10 = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    FetchHttpHandler: () => FetchHttpHandler,
+    keepAliveSupport: () => keepAliveSupport,
+    streamCollector: () => streamCollector
+  });
+  module.exports = __toCommonJS(src_exports);
+  var import_protocol_http = require_dist_cjs2();
+  var import_querystring_builder = require_dist_cjs4();
+  function createRequest(url, requestOptions) {
+    return new Request(url, requestOptions);
+  }
+  __name(createRequest, "createRequest");
+  function requestTimeout(timeoutInMs = 0) {
+    return new Promise((resolve, reject) => {
+      if (timeoutInMs) {
+        setTimeout(() => {
+          const timeoutError = new Error(`Request did not complete within ${timeoutInMs} ms`);
+          timeoutError.name = "TimeoutError";
+          reject(timeoutError);
+        }, timeoutInMs);
+      }
+    });
+  }
+  __name(requestTimeout, "requestTimeout");
+  var keepAliveSupport = {
+    supported: undefined
+  };
+  var FetchHttpHandler = class _FetchHttpHandler {
+    static {
+      __name(this, "FetchHttpHandler");
+    }
+    static create(instanceOrOptions) {
+      if (typeof instanceOrOptions?.handle === "function") {
+        return instanceOrOptions;
+      }
+      return new _FetchHttpHandler(instanceOrOptions);
+    }
+    constructor(options) {
+      if (typeof options === "function") {
+        this.configProvider = options().then((opts) => opts || {});
+      } else {
+        this.config = options ?? {};
+        this.configProvider = Promise.resolve(this.config);
+      }
+      if (keepAliveSupport.supported === undefined) {
+        keepAliveSupport.supported = Boolean(typeof Request !== "undefined" && "keepalive" in createRequest("https://[::1]"));
+      }
+    }
+    destroy() {}
+    async handle(request, { abortSignal } = {}) {
+      if (!this.config) {
+        this.config = await this.configProvider;
+      }
+      const requestTimeoutInMs = this.config.requestTimeout;
+      const keepAlive = this.config.keepAlive === true;
+      const credentials = this.config.credentials;
+      if (abortSignal?.aborted) {
+        const abortError = new Error("Request aborted");
+        abortError.name = "AbortError";
+        return Promise.reject(abortError);
+      }
+      let path = request.path;
+      const queryString = (0, import_querystring_builder.buildQueryString)(request.query || {});
+      if (queryString) {
+        path += `?${queryString}`;
+      }
+      if (request.fragment) {
+        path += `#${request.fragment}`;
+      }
+      let auth = "";
+      if (request.username != null || request.password != null) {
+        const username = request.username ?? "";
+        const password = request.password ?? "";
+        auth = `${username}:${password}@`;
+      }
+      const { port, method } = request;
+      const url = `${request.protocol}//${auth}${request.hostname}${port ? `:${port}` : ""}${path}`;
+      const body = method === "GET" || method === "HEAD" ? undefined : request.body;
+      const requestOptions = {
+        body,
+        headers: new Headers(request.headers),
+        method,
+        credentials
+      };
+      if (this.config?.cache) {
+        requestOptions.cache = this.config.cache;
+      }
+      if (body) {
+        requestOptions.duplex = "half";
+      }
+      if (typeof AbortController !== "undefined") {
+        requestOptions.signal = abortSignal;
+      }
+      if (keepAliveSupport.supported) {
+        requestOptions.keepalive = keepAlive;
+      }
+      if (typeof this.config.requestInit === "function") {
+        Object.assign(requestOptions, this.config.requestInit(request));
+      }
+      let removeSignalEventListener = /* @__PURE__ */ __name(() => {}, "removeSignalEventListener");
+      const fetchRequest = createRequest(url, requestOptions);
+      const raceOfPromises = [
+        fetch(fetchRequest).then((response) => {
+          const fetchHeaders = response.headers;
+          const transformedHeaders = {};
+          for (const pair of fetchHeaders.entries()) {
+            transformedHeaders[pair[0]] = pair[1];
+          }
+          const hasReadableStream = response.body != null;
+          if (!hasReadableStream) {
+            return response.blob().then((body2) => ({
+              response: new import_protocol_http.HttpResponse({
+                headers: transformedHeaders,
+                reason: response.statusText,
+                statusCode: response.status,
+                body: body2
+              })
+            }));
+          }
+          return {
+            response: new import_protocol_http.HttpResponse({
+              headers: transformedHeaders,
+              reason: response.statusText,
+              statusCode: response.status,
+              body: response.body
+            })
+          };
+        }),
+        requestTimeout(requestTimeoutInMs)
+      ];
+      if (abortSignal) {
+        raceOfPromises.push(new Promise((resolve, reject) => {
+          const onAbort = /* @__PURE__ */ __name(() => {
+            const abortError = new Error("Request aborted");
+            abortError.name = "AbortError";
+            reject(abortError);
+          }, "onAbort");
+          if (typeof abortSignal.addEventListener === "function") {
+            const signal = abortSignal;
+            signal.addEventListener("abort", onAbort, { once: true });
+            removeSignalEventListener = /* @__PURE__ */ __name(() => signal.removeEventListener("abort", onAbort), "removeSignalEventListener");
+          } else {
+            abortSignal.onabort = onAbort;
+          }
+        }));
+      }
+      return Promise.race(raceOfPromises).finally(removeSignalEventListener);
+    }
+    updateHttpClientConfig(key, value) {
+      this.config = undefined;
+      this.configProvider = this.configProvider.then((config) => {
+        config[key] = value;
+        return config;
+      });
+    }
+    httpHandlerConfigs() {
+      return this.config ?? {};
+    }
+  };
+  var import_util_base64 = require_dist_cjs9();
+  var streamCollector = /* @__PURE__ */ __name(async (stream) => {
+    if (typeof Blob === "function" && stream instanceof Blob || stream.constructor?.name === "Blob") {
+      if (Blob.prototype.arrayBuffer !== undefined) {
+        return new Uint8Array(await stream.arrayBuffer());
+      }
+      return collectBlob(stream);
+    }
+    return collectStream(stream);
+  }, "streamCollector");
+  async function collectBlob(blob) {
+    const base64 = await readToBase64(blob);
+    const arrayBuffer = (0, import_util_base64.fromBase64)(base64);
+    return new Uint8Array(arrayBuffer);
+  }
+  __name(collectBlob, "collectBlob");
+  async function collectStream(stream) {
+    const chunks = [];
+    const reader = stream.getReader();
+    let isDone = false;
+    let length = 0;
+    while (!isDone) {
+      const { done, value } = await reader.read();
+      if (value) {
+        chunks.push(value);
+        length += value.length;
+      }
+      isDone = done;
+    }
+    const collected = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+      collected.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return collected;
+  }
+  __name(collectStream, "collectStream");
+  function readToBase64(blob) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader;
+      reader.onloadend = () => {
+        if (reader.readyState !== 2) {
+          return reject(new Error("Reader aborted too early"));
+        }
+        const result = reader.result ?? "";
+        const commaIndex = result.indexOf(",");
+        const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
+        resolve(result.substring(dataOffset));
+      };
+      reader.onabort = () => reject(new Error("Read aborted"));
+      reader.onerror = () => reject(reader.error);
+      reader.readAsDataURL(blob);
+    });
+  }
+  __name(readToBase64, "readToBase64");
+});
+
+// ../../../../node_modules/@smithy/util-hex-encoding/dist-cjs/index.js
+var require_dist_cjs11 = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    fromHex: () => fromHex,
+    toHex: () => toHex
+  });
+  module.exports = __toCommonJS(src_exports);
+  var SHORT_TO_HEX = {};
+  var HEX_TO_SHORT = {};
+  for (let i = 0;i < 256; i++) {
+    let encodedByte = i.toString(16).toLowerCase();
+    if (encodedByte.length === 1) {
+      encodedByte = `0${encodedByte}`;
+    }
+    SHORT_TO_HEX[i] = encodedByte;
+    HEX_TO_SHORT[encodedByte] = i;
+  }
+  function fromHex(encoded) {
+    if (encoded.length % 2 !== 0) {
+      throw new Error("Hex encoded strings must have an even number length");
+    }
+    const out = new Uint8Array(encoded.length / 2);
+    for (let i = 0;i < encoded.length; i += 2) {
+      const encodedByte = encoded.slice(i, i + 2).toLowerCase();
+      if (encodedByte in HEX_TO_SHORT) {
+        out[i / 2] = HEX_TO_SHORT[encodedByte];
+      } else {
+        throw new Error(`Cannot decode unrecognized sequence ${encodedByte} as hexadecimal`);
+      }
+    }
+    return out;
+  }
+  __name(fromHex, "fromHex");
+  function toHex(bytes) {
+    let out = "";
+    for (let i = 0;i < bytes.byteLength; i++) {
+      out += SHORT_TO_HEX[bytes[i]];
+    }
+    return out;
+  }
+  __name(toHex, "toHex");
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/sdk-stream-mixin.browser.js
+var require_sdk_stream_mixin_browser = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.sdkStreamMixin = undefined;
+  var fetch_http_handler_1 = require_dist_cjs10();
+  var util_base64_1 = require_dist_cjs9();
+  var util_hex_encoding_1 = require_dist_cjs11();
+  var util_utf8_1 = require_dist_cjs8();
+  var stream_type_check_1 = require_stream_type_check();
+  var ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
+  var sdkStreamMixin2 = (stream) => {
+    var _a, _b;
+    if (!isBlobInstance(stream) && !(0, stream_type_check_1.isReadableStream)(stream)) {
+      const name = ((_b = (_a = stream === null || stream === undefined ? undefined : stream.__proto__) === null || _a === undefined ? undefined : _a.constructor) === null || _b === undefined ? undefined : _b.name) || stream;
+      throw new Error(`Unexpected stream implementation, expect Blob or ReadableStream, got ${name}`);
+    }
+    let transformed = false;
+    const transformToByteArray = async () => {
+      if (transformed) {
+        throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+      }
+      transformed = true;
+      return await (0, fetch_http_handler_1.streamCollector)(stream);
+    };
+    const blobToWebStream = (blob) => {
+      if (typeof blob.stream !== "function") {
+        throw new Error(`Cannot transform payload Blob to web stream. Please make sure the Blob.stream() is polyfilled.
+` + "If you are using React Native, this API is not yet supported, see: https://react-native.canny.io/feature-requests/p/fetch-streaming-body");
+      }
+      return blob.stream();
+    };
+    return Object.assign(stream, {
+      transformToByteArray,
+      transformToString: async (encoding) => {
+        const buf = await transformToByteArray();
+        if (encoding === "base64") {
+          return (0, util_base64_1.toBase64)(buf);
+        } else if (encoding === "hex") {
+          return (0, util_hex_encoding_1.toHex)(buf);
+        } else if (encoding === undefined || encoding === "utf8" || encoding === "utf-8") {
+          return (0, util_utf8_1.toUtf8)(buf);
+        } else if (typeof TextDecoder === "function") {
+          return new TextDecoder(encoding).decode(buf);
+        } else {
+          throw new Error("TextDecoder is not available, please make sure polyfill is provided.");
+        }
+      },
+      transformToWebStream: () => {
+        if (transformed) {
+          throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+        }
+        transformed = true;
+        if (isBlobInstance(stream)) {
+          return blobToWebStream(stream);
+        } else if ((0, stream_type_check_1.isReadableStream)(stream)) {
+          return stream;
+        } else {
+          throw new Error(`Cannot transform payload to web stream, got ${stream}`);
+        }
+      }
+    });
+  };
+  exports.sdkStreamMixin = sdkStreamMixin2;
+  var isBlobInstance = (stream) => typeof Blob === "function" && stream instanceof Blob;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/sdk-stream-mixin.js
+var require_sdk_stream_mixin = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.sdkStreamMixin = undefined;
+  var node_http_handler_1 = require_dist_cjs5();
+  var util_buffer_from_1 = require_dist_cjs7();
+  var stream_1 = __require("node:stream");
+  var sdk_stream_mixin_browser_1 = require_sdk_stream_mixin_browser();
+  var ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
+  var sdkStreamMixin2 = (stream) => {
+    var _a, _b;
+    if (!(stream instanceof stream_1.Readable)) {
+      try {
+        return (0, sdk_stream_mixin_browser_1.sdkStreamMixin)(stream);
+      } catch (e) {
+        const name = ((_b = (_a = stream === null || stream === undefined ? undefined : stream.__proto__) === null || _a === undefined ? undefined : _a.constructor) === null || _b === undefined ? undefined : _b.name) || stream;
+        throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${name}`);
+      }
+    }
+    let transformed = false;
+    const transformToByteArray = async () => {
+      if (transformed) {
+        throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+      }
+      transformed = true;
+      return await (0, node_http_handler_1.streamCollector)(stream);
+    };
+    return Object.assign(stream, {
+      transformToByteArray,
+      transformToString: async (encoding) => {
+        const buf = await transformToByteArray();
+        if (encoding === undefined || Buffer.isEncoding(encoding)) {
+          return (0, util_buffer_from_1.fromArrayBuffer)(buf.buffer, buf.byteOffset, buf.byteLength).toString(encoding);
+        } else {
+          const decoder = new TextDecoder(encoding);
+          return decoder.decode(buf);
+        }
+      },
+      transformToWebStream: () => {
+        if (transformed) {
+          throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+        }
+        if (stream.readableFlowing !== null) {
+          throw new Error("The stream has been consumed by other callbacks.");
+        }
+        if (typeof stream_1.Readable.toWeb !== "function") {
+          throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available.");
+        }
+        transformed = true;
+        return stream_1.Readable.toWeb(stream);
+      }
+    });
+  };
+  exports.sdkStreamMixin = sdkStreamMixin2;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/splitStream.browser.js
+var require_splitStream_browser = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.splitStream = undefined;
+  async function splitStream2(stream) {
+    if (typeof stream.stream === "function") {
+      stream = stream.stream();
+    }
+    const readableStream = stream;
+    return readableStream.tee();
+  }
+  exports.splitStream = splitStream2;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/splitStream.js
+var require_splitStream = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.splitStream = undefined;
+  var stream_1 = __require("node:stream");
+  var splitStream_browser_1 = require_splitStream_browser();
+  var stream_type_check_1 = require_stream_type_check();
+  async function splitStream2(stream) {
+    if ((0, stream_type_check_1.isReadableStream)(stream) || (0, stream_type_check_1.isBlob)(stream)) {
+      return (0, splitStream_browser_1.splitStream)(stream);
+    }
+    const stream1 = new stream_1.PassThrough;
+    const stream2 = new stream_1.PassThrough;
+    stream.pipe(stream1);
+    stream.pipe(stream2);
+    return [stream1, stream2];
+  }
+  exports.splitStream = splitStream2;
+});
+
+// ../../../../node_modules/@smithy/util-stream/dist-cjs/index.js
+var require_dist_cjs12 = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    Uint8ArrayBlobAdapter: () => Uint8ArrayBlobAdapter
+  });
+  module.exports = __toCommonJS(src_exports);
+  var import_util_base64 = require_dist_cjs9();
+  var import_util_utf8 = require_dist_cjs8();
+  function transformToString(payload, encoding = "utf-8") {
+    if (encoding === "base64") {
+      return (0, import_util_base64.toBase64)(payload);
+    }
+    return (0, import_util_utf8.toUtf8)(payload);
+  }
+  __name(transformToString, "transformToString");
+  function transformFromString(str, encoding) {
+    if (encoding === "base64") {
+      return Uint8ArrayBlobAdapter.mutate((0, import_util_base64.fromBase64)(str));
+    }
+    return Uint8ArrayBlobAdapter.mutate((0, import_util_utf8.fromUtf8)(str));
+  }
+  __name(transformFromString, "transformFromString");
+  var Uint8ArrayBlobAdapter = class _Uint8ArrayBlobAdapter extends Uint8Array {
+    static {
+      __name(this, "Uint8ArrayBlobAdapter");
+    }
+    static fromString(source, encoding = "utf-8") {
+      switch (typeof source) {
+        case "string":
+          return transformFromString(source, encoding);
+        default:
+          throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
+      }
+    }
+    static mutate(source) {
+      Object.setPrototypeOf(source, _Uint8ArrayBlobAdapter.prototype);
+      return source;
+    }
+    transformToString(encoding = "utf-8") {
+      return transformToString(this, encoding);
+    }
+  };
+  __reExport(src_exports, require_ChecksumStream(), module.exports);
+  __reExport(src_exports, require_createChecksumStream(), module.exports);
+  __reExport(src_exports, require_createBufferedReadable(), module.exports);
+  __reExport(src_exports, require_getAwsChunkedEncodingStream(), module.exports);
+  __reExport(src_exports, require_headStream(), module.exports);
+  __reExport(src_exports, require_sdk_stream_mixin(), module.exports);
+  __reExport(src_exports, require_splitStream(), module.exports);
+  __reExport(src_exports, require_stream_type_check(), module.exports);
+});
+
+// ../../../../node_modules/@smithy/core/dist-cjs/submodules/protocols/index.js
+var require_protocols = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var protocols_exports = {};
+  __export(protocols_exports, {
+    RequestBuilder: () => RequestBuilder,
+    collectBody: () => collectBody,
+    extendedEncodeURIComponent: () => extendedEncodeURIComponent,
+    requestBuilder: () => requestBuilder,
+    resolvedPath: () => resolvedPath
+  });
+  module.exports = __toCommonJS(protocols_exports);
+  var import_util_stream = require_dist_cjs12();
+  var collectBody = async (streamBody = new Uint8Array, context) => {
+    if (streamBody instanceof Uint8Array) {
+      return import_util_stream.Uint8ArrayBlobAdapter.mutate(streamBody);
+    }
+    if (!streamBody) {
+      return import_util_stream.Uint8ArrayBlobAdapter.mutate(new Uint8Array);
+    }
+    const fromContext = context.streamCollector(streamBody);
+    return import_util_stream.Uint8ArrayBlobAdapter.mutate(await fromContext);
+  };
+  function extendedEncodeURIComponent(str) {
+    return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
+      return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+    });
+  }
+  var import_protocol_http = require_dist_cjs2();
+  var resolvedPath = (resolvedPath2, input, memberName, labelValueProvider, uriLabel, isGreedyLabel) => {
+    if (input != null && input[memberName] !== undefined) {
+      const labelValue = labelValueProvider();
+      if (labelValue.length <= 0) {
+        throw new Error("Empty value provided for input HTTP label: " + memberName + ".");
+      }
+      resolvedPath2 = resolvedPath2.replace(uriLabel, isGreedyLabel ? labelValue.split("/").map((segment) => extendedEncodeURIComponent(segment)).join("/") : extendedEncodeURIComponent(labelValue));
+    } else {
+      throw new Error("No value provided for input HTTP label: " + memberName + ".");
+    }
+    return resolvedPath2;
+  };
+  function requestBuilder(input, context) {
+    return new RequestBuilder(input, context);
+  }
+  var RequestBuilder = class {
+    constructor(input, context) {
+      this.input = input;
+      this.context = context;
+      this.query = {};
+      this.method = "";
+      this.headers = {};
+      this.path = "";
+      this.body = null;
+      this.hostname = "";
+      this.resolvePathStack = [];
+    }
+    async build() {
+      const { hostname, protocol = "https", port, path: basePath } = await this.context.endpoint();
+      this.path = basePath;
+      for (const resolvePath of this.resolvePathStack) {
+        resolvePath(this.path);
+      }
+      return new import_protocol_http.HttpRequest({
+        protocol,
+        hostname: this.hostname || hostname,
+        port,
+        method: this.method,
+        path: this.path,
+        query: this.query,
+        body: this.body,
+        headers: this.headers
+      });
+    }
+    hn(hostname) {
+      this.hostname = hostname;
+      return this;
+    }
+    bp(uriLabel) {
+      this.resolvePathStack.push((basePath) => {
+        this.path = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + uriLabel;
+      });
+      return this;
+    }
+    p(memberName, labelValueProvider, uriLabel, isGreedyLabel) {
+      this.resolvePathStack.push((path) => {
+        this.path = resolvedPath(path, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel);
+      });
+      return this;
+    }
+    h(headers) {
+      this.headers = headers;
+      return this;
+    }
+    q(query) {
+      this.query = query;
+      return this;
+    }
+    b(body) {
+      this.body = body;
+      return this;
+    }
+    m(method) {
+      this.method = method;
+      return this;
+    }
+  };
+});
+
+export { require_dist_cjs2 as require_dist_cjs, require_dist_cjs6 as require_dist_cjs1, require_dist_cjs7 as require_dist_cjs2, require_dist_cjs8 as require_dist_cjs3, require_dist_cjs9 as require_dist_cjs4, require_dist_cjs3 as require_dist_cjs5, require_dist_cjs5 as require_dist_cjs6, require_dist_cjs11 as require_dist_cjs7, require_dist_cjs12 as require_dist_cjs8, require_protocols };