@layerzerolabs/vm-tooling 0.2.5 → 0.2.7

package/dist/Q5L3QIKZ.cjs

@@ -0,0 +1,825 @@
+'use strict';
+
+var FDH37YWR_cjs = require('./FDH37YWR.cjs');
+var _24WEKBY3_cjs = require('./24WEKBY3.cjs');
+var http = require('http');
+var https = require('https');
+var stream = require('stream');
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/node-http-handler.js
+_24WEKBY3_cjs.init_cjs_shims();
+
+// ../../node_modules/.pnpm/@smithy+protocol-http@5.3.5/node_modules/@smithy/protocol-http/dist-es/httpRequest.js
+_24WEKBY3_cjs.init_cjs_shims();
+var HttpRequest = class _HttpRequest {
+  static {
+    _24WEKBY3_cjs.__name(this, "HttpRequest");
+  }
+  method;
+  protocol;
+  hostname;
+  port;
+  path;
+  query;
+  headers;
+  username;
+  password;
+  fragment;
+  body;
+  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
+    };
+  }, {});
+}
+_24WEKBY3_cjs.__name(cloneQuery, "cloneQuery");
+
+// ../../node_modules/.pnpm/@smithy+protocol-http@5.3.5/node_modules/@smithy/protocol-http/dist-es/httpResponse.js
+_24WEKBY3_cjs.init_cjs_shims();
+var HttpResponse = class {
+  static {
+    _24WEKBY3_cjs.__name(this, "HttpResponse");
+  }
+  statusCode;
+  reason;
+  headers;
+  body;
+  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";
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+querystring-builder@4.2.5/node_modules/@smithy/querystring-builder/dist-es/index.js
+_24WEKBY3_cjs.init_cjs_shims();
+
+// ../../node_modules/.pnpm/@smithy+util-uri-escape@4.2.0/node_modules/@smithy/util-uri-escape/dist-es/escape-uri.js
+_24WEKBY3_cjs.init_cjs_shims();
+var escapeUri = /* @__PURE__ */ _24WEKBY3_cjs.__name((uri) => encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode), "escapeUri");
+var hexEncode = /* @__PURE__ */ _24WEKBY3_cjs.__name((c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`, "hexEncode");
+
+// ../../node_modules/.pnpm/@smithy+querystring-builder@4.2.5/node_modules/@smithy/querystring-builder/dist-es/index.js
+function buildQueryString(query) {
+  const parts = [];
+  for (let key of Object.keys(query).sort()) {
+    const value = query[key];
+    key = escapeUri(key);
+    if (Array.isArray(value)) {
+      for (let i = 0, iLen = value.length; i < iLen; i++) {
+        parts.push(`${key}=${escapeUri(value[i])}`);
+      }
+    } else {
+      let qsEntry = key;
+      if (value || typeof value === "string") {
+        qsEntry += `=${escapeUri(value)}`;
+      }
+      parts.push(qsEntry);
+    }
+  }
+  return parts.join("&");
+}
+_24WEKBY3_cjs.__name(buildQueryString, "buildQueryString");
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/constants.js
+_24WEKBY3_cjs.init_cjs_shims();
+var NODEJS_TIMEOUT_ERROR_CODES = [
+  "ECONNRESET",
+  "EPIPE",
+  "ETIMEDOUT"
+];
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/get-transformed-headers.js
+_24WEKBY3_cjs.init_cjs_shims();
+var getTransformedHeaders = /* @__PURE__ */ _24WEKBY3_cjs.__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");
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/set-connection-timeout.js
+_24WEKBY3_cjs.init_cjs_shims();
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/timing.js
+_24WEKBY3_cjs.init_cjs_shims();
+var timing = {
+  setTimeout: /* @__PURE__ */ _24WEKBY3_cjs.__name((cb, ms) => setTimeout(cb, ms), "setTimeout"),
+  clearTimeout: /* @__PURE__ */ _24WEKBY3_cjs.__name((timeoutId) => clearTimeout(timeoutId), "clearTimeout")
+};
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/set-connection-timeout.js
+var DEFER_EVENT_LISTENER_TIME = 1e3;
+var setConnectionTimeout = /* @__PURE__ */ _24WEKBY3_cjs.__name((request, reject, timeoutInMs = 0) => {
+  if (!timeoutInMs) {
+    return -1;
+  }
+  const registerTimeout = /* @__PURE__ */ _24WEKBY3_cjs.__name((offset) => {
+    const timeoutId = timing.setTimeout(() => {
+      request.destroy();
+      reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket did not establish a connection with the server within the configured timeout of ${timeoutInMs} ms.`), {
+        name: "TimeoutError"
+      }));
+    }, timeoutInMs - offset);
+    const doWithSocket = /* @__PURE__ */ _24WEKBY3_cjs.__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 < 2e3) {
+    registerTimeout(0);
+    return 0;
+  }
+  return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
+}, "setConnectionTimeout");
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/set-request-timeout.js
+_24WEKBY3_cjs.init_cjs_shims();
+var setRequestTimeout = /* @__PURE__ */ _24WEKBY3_cjs.__name((req, reject, timeoutInMs = 0, throwOnRequestTimeout, logger2) => {
+  if (timeoutInMs) {
+    return timing.setTimeout(() => {
+      let msg = `@smithy/node-http-handler - [${throwOnRequestTimeout ? "ERROR" : "WARN"}] a request has exceeded the configured ${timeoutInMs} ms requestTimeout.`;
+      if (throwOnRequestTimeout) {
+        const error = Object.assign(new Error(msg), {
+          name: "TimeoutError",
+          code: "ETIMEDOUT"
+        });
+        req.destroy(error);
+        reject(error);
+      } else {
+        msg += ` Init client requestHandler with throwOnRequestTimeout=true to turn this into an error.`;
+        logger2?.warn?.(msg);
+      }
+    }, timeoutInMs);
+  }
+  return -1;
+}, "setRequestTimeout");
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/set-socket-keep-alive.js
+_24WEKBY3_cjs.init_cjs_shims();
+var DEFER_EVENT_LISTENER_TIME2 = 3e3;
+var setSocketKeepAlive = /* @__PURE__ */ _24WEKBY3_cjs.__name((request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME2) => {
+  if (keepAlive !== true) {
+    return -1;
+  }
+  const registerListener = /* @__PURE__ */ _24WEKBY3_cjs.__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");
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/set-socket-timeout.js
+_24WEKBY3_cjs.init_cjs_shims();
+var DEFER_EVENT_LISTENER_TIME3 = 3e3;
+var setSocketTimeout = /* @__PURE__ */ _24WEKBY3_cjs.__name((request, reject, timeoutInMs = 0) => {
+  const registerTimeout = /* @__PURE__ */ _24WEKBY3_cjs.__name((offset) => {
+    const timeout = timeoutInMs - offset;
+    const onTimeout = /* @__PURE__ */ _24WEKBY3_cjs.__name(() => {
+      request.destroy();
+      reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket timed out after ${timeoutInMs} ms of inactivity (configured by client requestHandler).`), {
+        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 < 6e3) {
+    registerTimeout(0);
+    return 0;
+  }
+  return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME3), DEFER_EVENT_LISTENER_TIME3);
+}, "setSocketTimeout");
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/write-request-body.js
+_24WEKBY3_cjs.init_cjs_shims();
+var MIN_WAIT_TIME = 6e3;
+async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME, externalAgent = false) {
+  const headers = request.headers ?? {};
+  const expect = headers.Expect || headers.expect;
+  let timeoutId = -1;
+  let sendBody = true;
+  if (!externalAgent && 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);
+  }
+}
+_24WEKBY3_cjs.__name(writeRequestBody, "writeRequestBody");
+function writeBody(httpRequest, body) {
+  if (body instanceof 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();
+}
+_24WEKBY3_cjs.__name(writeBody, "writeBody");
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/node-http-handler.js
+var NodeHttpHandler = class _NodeHttpHandler {
+  static {
+    _24WEKBY3_cjs.__name(this, "NodeHttpHandler");
+  }
+  config;
+  configProvider;
+  socketWarningTimestamp = 0;
+  externalAgent = false;
+  metadata = {
+    handlerProtocol: "http/1.1"
+  };
+  static create(instanceOrOptions) {
+    if (typeof instanceOrOptions?.handle === "function") {
+      return instanceOrOptions;
+    }
+    return new _NodeHttpHandler(instanceOrOptions);
+  }
+  static checkSocketUsage(agent, socketWarningTimestamp, logger2 = console) {
+    const { sockets, requests, maxSockets } = agent;
+    if (typeof maxSockets !== "number" || maxSockets === Infinity) {
+      return socketWarningTimestamp;
+    }
+    const interval = 15e3;
+    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) {
+          logger2?.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;
+  }
+  constructor(options) {
+    this.configProvider = new Promise((resolve, reject) => {
+      if (typeof options === "function") {
+        options().then((_options) => {
+          resolve(this.resolveDefaultConfig(_options));
+        }).catch(reject);
+      } else {
+        resolve(this.resolveDefaultConfig(options));
+      }
+    });
+  }
+  resolveDefaultConfig(options) {
+    const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent, throwOnRequestTimeout } = options || {};
+    const keepAlive = true;
+    const maxSockets = 50;
+    return {
+      connectionTimeout,
+      requestTimeout,
+      socketTimeout,
+      socketAcquisitionWarningTimeout,
+      throwOnRequestTimeout,
+      httpAgent: (() => {
+        if (httpAgent instanceof http.Agent || typeof httpAgent?.destroy === "function") {
+          this.externalAgent = true;
+          return httpAgent;
+        }
+        return new http.Agent({
+          keepAlive,
+          maxSockets,
+          ...httpAgent
+        });
+      })(),
+      httpsAgent: (() => {
+        if (httpsAgent instanceof https.Agent || typeof httpsAgent?.destroy === "function") {
+          this.externalAgent = true;
+          return httpsAgent;
+        }
+        return new https.Agent({
+          keepAlive,
+          maxSockets,
+          ...httpsAgent
+        });
+      })(),
+      logger: console
+    };
+  }
+  destroy() {
+    this.config?.httpAgent?.destroy();
+    this.config?.httpsAgent?.destroy();
+  }
+  async handle(request, { abortSignal, requestTimeout } = {}) {
+    if (!this.config) {
+      this.config = await this.configProvider;
+    }
+    return new Promise((_resolve, _reject) => {
+      const config = this.config;
+      let writeRequestBodyPromise = void 0;
+      const timeouts = [];
+      const resolve = /* @__PURE__ */ _24WEKBY3_cjs.__name(async (arg) => {
+        await writeRequestBodyPromise;
+        timeouts.forEach(timing.clearTimeout);
+        _resolve(arg);
+      }, "resolve");
+      const reject = /* @__PURE__ */ _24WEKBY3_cjs.__name(async (arg) => {
+        await writeRequestBodyPromise;
+        timeouts.forEach(timing.clearTimeout);
+        _reject(arg);
+      }, "reject");
+      if (abortSignal?.aborted) {
+        const abortError = new Error("Request aborted");
+        abortError.name = "AbortError";
+        reject(abortError);
+        return;
+      }
+      const isSSL = request.protocol === "https:";
+      const headers = request.headers ?? {};
+      const expectContinue = (headers.Expect ?? headers.expect) === "100-continue";
+      let agent = isSSL ? config.httpsAgent : config.httpAgent;
+      if (expectContinue && !this.externalAgent) {
+        agent = new (isSSL ? https.Agent : http.Agent)({
+          keepAlive: false,
+          maxSockets: Infinity
+        });
+      }
+      timeouts.push(timing.setTimeout(() => {
+        this.socketWarningTimestamp = _NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, config.logger);
+      }, config.socketAcquisitionWarningTimeout ?? (config.requestTimeout ?? 2e3) + (config.connectionTimeout ?? 1e3)));
+      const queryString = buildQueryString(request.query || {});
+      let auth = void 0;
+      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 ? https.request : http.request;
+      const req = requestFunc(nodeHttpsOptions, (res) => {
+        const httpResponse = new 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__ */ _24WEKBY3_cjs.__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;
+        }
+      }
+      const effectiveRequestTimeout = requestTimeout ?? config.requestTimeout;
+      timeouts.push(setConnectionTimeout(req, reject, config.connectionTimeout));
+      timeouts.push(setRequestTimeout(req, reject, effectiveRequestTimeout, config.throwOnRequestTimeout, config.logger ?? console));
+      timeouts.push(setSocketTimeout(req, reject, config.socketTimeout));
+      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, effectiveRequestTimeout, this.externalAgent).catch((e) => {
+        timeouts.forEach(timing.clearTimeout);
+        return _reject(e);
+      });
+    });
+  }
+  updateHttpClientConfig(key, value) {
+    this.config = void 0;
+    this.configProvider = this.configProvider.then((config) => {
+      return {
+        ...config,
+        [key]: value
+      };
+    });
+  }
+  httpHandlerConfigs() {
+    return this.config ?? {};
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/stream-collector/index.js
+_24WEKBY3_cjs.init_cjs_shims();
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/stream-collector/collector.js
+_24WEKBY3_cjs.init_cjs_shims();
+var Collector = class extends stream.Writable {
+  static {
+    _24WEKBY3_cjs.__name(this, "Collector");
+  }
+  bufferedBytes = [];
+  _write(chunk, encoding, callback) {
+    this.bufferedBytes.push(chunk);
+    callback();
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+node-http-handler@4.4.5/node_modules/@smithy/node-http-handler/dist-es/stream-collector/index.js
+var streamCollector = /* @__PURE__ */ _24WEKBY3_cjs.__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__ */ _24WEKBY3_cjs.__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;
+}
+_24WEKBY3_cjs.__name(collectReadableStream, "collectReadableStream");
+
+// ../../node_modules/.pnpm/@smithy+core@3.18.5/node_modules/@smithy/core/dist-es/submodules/serde/parse-utils.js
+_24WEKBY3_cjs.init_cjs_shims();
+var expectNumber = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const parsed = parseFloat(value);
+    if (!Number.isNaN(parsed)) {
+      if (String(parsed) !== String(value)) {
+        logger.warn(stackTraceWarning(`Expected number but observed string: ${value}`));
+      }
+      return parsed;
+    }
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  throw new TypeError(`Expected number, got ${typeof value}: ${value}`);
+}, "expectNumber");
+var MAX_FLOAT = Math.ceil(2 ** 127 * (2 - 2 ** -23));
+var expectFloat32 = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => {
+  const expected = expectNumber(value);
+  if (expected !== void 0 && !Number.isNaN(expected) && expected !== Infinity && expected !== -Infinity) {
+    if (Math.abs(expected) > MAX_FLOAT) {
+      throw new TypeError(`Expected 32-bit float, got ${value}`);
+    }
+  }
+  return expected;
+}, "expectFloat32");
+var expectLong = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (Number.isInteger(value) && !Number.isNaN(value)) {
+    return value;
+  }
+  throw new TypeError(`Expected integer, got ${typeof value}: ${value}`);
+}, "expectLong");
+var expectInt32 = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => expectSizedInt(value, 32), "expectInt32");
+var expectShort = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => expectSizedInt(value, 16), "expectShort");
+var expectByte = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => expectSizedInt(value, 8), "expectByte");
+var expectSizedInt = /* @__PURE__ */ _24WEKBY3_cjs.__name((value, size) => {
+  const expected = expectLong(value);
+  if (expected !== void 0 && castInt(expected, size) !== expected) {
+    throw new TypeError(`Expected ${size}-bit integer, got ${value}`);
+  }
+  return expected;
+}, "expectSizedInt");
+var castInt = /* @__PURE__ */ _24WEKBY3_cjs.__name((value, size) => {
+  switch (size) {
+    case 32:
+      return Int32Array.of(value)[0];
+    case 16:
+      return Int16Array.of(value)[0];
+    case 8:
+      return Int8Array.of(value)[0];
+  }
+}, "castInt");
+var expectNonNull = /* @__PURE__ */ _24WEKBY3_cjs.__name((value, location) => {
+  if (value === null || value === void 0) {
+    if (location) {
+      throw new TypeError(`Expected a non-null value for ${location}`);
+    }
+    throw new TypeError("Expected a non-null value");
+  }
+  return value;
+}, "expectNonNull");
+var expectObject = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  const receivedType = Array.isArray(value) ? "array" : typeof value;
+  throw new TypeError(`Expected object, got ${receivedType}: ${value}`);
+}, "expectObject");
+var expectString = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if ([
+    "boolean",
+    "number",
+    "bigint"
+  ].includes(typeof value)) {
+    logger.warn(stackTraceWarning(`Expected string, got ${typeof value}: ${value}`));
+    return String(value);
+  }
+  throw new TypeError(`Expected string, got ${typeof value}: ${value}`);
+}, "expectString");
+var strictParseFloat32 = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => {
+  if (typeof value == "string") {
+    return expectFloat32(parseNumber(value));
+  }
+  return expectFloat32(value);
+}, "strictParseFloat32");
+var NUMBER_REGEX = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g;
+var parseNumber = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => {
+  const matches = value.match(NUMBER_REGEX);
+  if (matches === null || matches[0].length !== value.length) {
+    throw new TypeError(`Expected real number, got implicit NaN`);
+  }
+  return parseFloat(value);
+}, "parseNumber");
+var strictParseInt32 = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => {
+  if (typeof value === "string") {
+    return expectInt32(parseNumber(value));
+  }
+  return expectInt32(value);
+}, "strictParseInt32");
+var strictParseShort = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => {
+  if (typeof value === "string") {
+    return expectShort(parseNumber(value));
+  }
+  return expectShort(value);
+}, "strictParseShort");
+var strictParseByte = /* @__PURE__ */ _24WEKBY3_cjs.__name((value) => {
+  if (typeof value === "string") {
+    return expectByte(parseNumber(value));
+  }
+  return expectByte(value);
+}, "strictParseByte");
+var stackTraceWarning = /* @__PURE__ */ _24WEKBY3_cjs.__name((message) => {
+  return String(new TypeError(message).stack || message).split("\n").slice(0, 5).filter((s) => !s.includes("stackTraceWarning")).join("\n");
+}, "stackTraceWarning");
+var logger = {
+  warn: console.warn
+};
+
+// ../../node_modules/.pnpm/@smithy+util-base64@4.3.0/node_modules/@smithy/util-base64/dist-es/fromBase64.js
+_24WEKBY3_cjs.init_cjs_shims();
+var BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
+var fromBase64 = /* @__PURE__ */ _24WEKBY3_cjs.__name((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 = FDH37YWR_cjs.fromString(input, "base64");
+  return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+}, "fromBase64");
+
+// ../../node_modules/.pnpm/@smithy+util-base64@4.3.0/node_modules/@smithy/util-base64/dist-es/toBase64.js
+_24WEKBY3_cjs.init_cjs_shims();
+var toBase64 = /* @__PURE__ */ _24WEKBY3_cjs.__name((_input) => {
+  let input;
+  if (typeof _input === "string") {
+    input = FDH37YWR_cjs.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 FDH37YWR_cjs.fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("base64");
+}, "toBase64");
+
+// ../../node_modules/.pnpm/@smithy+util-hex-encoding@4.2.0/node_modules/@smithy/util-hex-encoding/dist-es/index.js
+_24WEKBY3_cjs.init_cjs_shims();
+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;
+}
+_24WEKBY3_cjs.__name(fromHex, "fromHex");
+function toHex(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    out += SHORT_TO_HEX[bytes[i]];
+  }
+  return out;
+}
+_24WEKBY3_cjs.__name(toHex, "toHex");
+
+exports.HttpRequest = HttpRequest;
+exports.HttpResponse = HttpResponse;
+exports.NodeHttpHandler = NodeHttpHandler;
+exports.escapeUri = escapeUri;
+exports.expectInt32 = expectInt32;
+exports.expectNonNull = expectNonNull;
+exports.expectObject = expectObject;
+exports.expectString = expectString;
+exports.fromBase64 = fromBase64;
+exports.fromHex = fromHex;
+exports.streamCollector = streamCollector;
+exports.strictParseByte = strictParseByte;
+exports.strictParseFloat32 = strictParseFloat32;
+exports.strictParseInt32 = strictParseInt32;
+exports.strictParseShort = strictParseShort;
+exports.toBase64 = toBase64;
+exports.toHex = toHex;
+//# sourceMappingURL=Q5L3QIKZ.cjs.map
+//# sourceMappingURL=Q5L3QIKZ.cjs.map