@cloudflare/vitest-pool-workers 0.12.21 → 0.13.1

package/dist/worker/lib/cloudflare/mock-agent.cjs

@@ -1,3433 +0,0 @@
-"use strict";
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/core/symbols.js
-var require_symbols = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/core/symbols.js"(exports2, module2) {
-    "use strict";
-    module2.exports = {
-      kClose: /* @__PURE__ */ Symbol("close"),
-      kDestroy: /* @__PURE__ */ Symbol("destroy"),
-      kDispatch: /* @__PURE__ */ Symbol("dispatch"),
-      kUrl: /* @__PURE__ */ Symbol("url"),
-      kWriting: /* @__PURE__ */ Symbol("writing"),
-      kResuming: /* @__PURE__ */ Symbol("resuming"),
-      kQueue: /* @__PURE__ */ Symbol("queue"),
-      kConnect: /* @__PURE__ */ Symbol("connect"),
-      kConnecting: /* @__PURE__ */ Symbol("connecting"),
-      kKeepAliveDefaultTimeout: /* @__PURE__ */ Symbol("default keep alive timeout"),
-      kKeepAliveMaxTimeout: /* @__PURE__ */ Symbol("max keep alive timeout"),
-      kKeepAliveTimeoutThreshold: /* @__PURE__ */ Symbol("keep alive timeout threshold"),
-      kKeepAliveTimeoutValue: /* @__PURE__ */ Symbol("keep alive timeout"),
-      kKeepAlive: /* @__PURE__ */ Symbol("keep alive"),
-      kHeadersTimeout: /* @__PURE__ */ Symbol("headers timeout"),
-      kBodyTimeout: /* @__PURE__ */ Symbol("body timeout"),
-      kServerName: /* @__PURE__ */ Symbol("server name"),
-      kLocalAddress: /* @__PURE__ */ Symbol("local address"),
-      kHost: /* @__PURE__ */ Symbol("host"),
-      kNoRef: /* @__PURE__ */ Symbol("no ref"),
-      kBodyUsed: /* @__PURE__ */ Symbol("used"),
-      kBody: /* @__PURE__ */ Symbol("abstracted request body"),
-      kRunning: /* @__PURE__ */ Symbol("running"),
-      kBlocking: /* @__PURE__ */ Symbol("blocking"),
-      kPending: /* @__PURE__ */ Symbol("pending"),
-      kSize: /* @__PURE__ */ Symbol("size"),
-      kBusy: /* @__PURE__ */ Symbol("busy"),
-      kQueued: /* @__PURE__ */ Symbol("queued"),
-      kFree: /* @__PURE__ */ Symbol("free"),
-      kConnected: /* @__PURE__ */ Symbol("connected"),
-      kClosed: /* @__PURE__ */ Symbol("closed"),
-      kNeedDrain: /* @__PURE__ */ Symbol("need drain"),
-      kReset: /* @__PURE__ */ Symbol("reset"),
-      kDestroyed: /* @__PURE__ */ Symbol.for("nodejs.stream.destroyed"),
-      kResume: /* @__PURE__ */ Symbol("resume"),
-      kOnError: /* @__PURE__ */ Symbol("on error"),
-      kMaxHeadersSize: /* @__PURE__ */ Symbol("max headers size"),
-      kRunningIdx: /* @__PURE__ */ Symbol("running index"),
-      kPendingIdx: /* @__PURE__ */ Symbol("pending index"),
-      kError: /* @__PURE__ */ Symbol("error"),
-      kClients: /* @__PURE__ */ Symbol("clients"),
-      kClient: /* @__PURE__ */ Symbol("client"),
-      kParser: /* @__PURE__ */ Symbol("parser"),
-      kOnDestroyed: /* @__PURE__ */ Symbol("destroy callbacks"),
-      kPipelining: /* @__PURE__ */ Symbol("pipelining"),
-      kSocket: /* @__PURE__ */ Symbol("socket"),
-      kHostHeader: /* @__PURE__ */ Symbol("host header"),
-      kConnector: /* @__PURE__ */ Symbol("connector"),
-      kStrictContentLength: /* @__PURE__ */ Symbol("strict content length"),
-      kMaxRedirections: /* @__PURE__ */ Symbol("maxRedirections"),
-      kMaxRequests: /* @__PURE__ */ Symbol("maxRequestsPerClient"),
-      kProxy: /* @__PURE__ */ Symbol("proxy agent options"),
-      kCounter: /* @__PURE__ */ Symbol("socket request counter"),
-      kMaxResponseSize: /* @__PURE__ */ Symbol("max response size"),
-      kHTTP2Session: /* @__PURE__ */ Symbol("http2Session"),
-      kHTTP2SessionState: /* @__PURE__ */ Symbol("http2Session state"),
-      kRetryHandlerDefaultRetry: /* @__PURE__ */ Symbol("retry agent default retry"),
-      kConstruct: /* @__PURE__ */ Symbol("constructable"),
-      kListeners: /* @__PURE__ */ Symbol("listeners"),
-      kHTTPContext: /* @__PURE__ */ Symbol("http context"),
-      kMaxConcurrentStreams: /* @__PURE__ */ Symbol("max concurrent streams"),
-      kEnableConnectProtocol: /* @__PURE__ */ Symbol("http2session connect protocol"),
-      kRemoteSettings: /* @__PURE__ */ Symbol("http2session remote settings"),
-      kHTTP2Stream: /* @__PURE__ */ Symbol("http2session client stream"),
-      kNoProxyAgent: /* @__PURE__ */ Symbol("no proxy agent"),
-      kHttpProxyAgent: /* @__PURE__ */ Symbol("http proxy agent"),
-      kHttpsProxyAgent: /* @__PURE__ */ Symbol("https proxy agent")
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/core/errors.js
-var require_errors = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/core/errors.js"(exports2, module2) {
-    "use strict";
-    var kUndiciError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR");
-    var UndiciError = class extends Error {
-      constructor(message, options) {
-        super(message, options);
-        this.name = "UndiciError";
-        this.code = "UND_ERR";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kUndiciError] === true;
-      }
-      get [kUndiciError]() {
-        return true;
-      }
-    };
-    var kConnectTimeoutError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_CONNECT_TIMEOUT");
-    var ConnectTimeoutError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "ConnectTimeoutError";
-        this.message = message || "Connect Timeout Error";
-        this.code = "UND_ERR_CONNECT_TIMEOUT";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kConnectTimeoutError] === true;
-      }
-      get [kConnectTimeoutError]() {
-        return true;
-      }
-    };
-    var kHeadersTimeoutError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HEADERS_TIMEOUT");
-    var HeadersTimeoutError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "HeadersTimeoutError";
-        this.message = message || "Headers Timeout Error";
-        this.code = "UND_ERR_HEADERS_TIMEOUT";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kHeadersTimeoutError] === true;
-      }
-      get [kHeadersTimeoutError]() {
-        return true;
-      }
-    };
-    var kHeadersOverflowError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HEADERS_OVERFLOW");
-    var HeadersOverflowError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "HeadersOverflowError";
-        this.message = message || "Headers Overflow Error";
-        this.code = "UND_ERR_HEADERS_OVERFLOW";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kHeadersOverflowError] === true;
-      }
-      get [kHeadersOverflowError]() {
-        return true;
-      }
-    };
-    var kBodyTimeoutError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_BODY_TIMEOUT");
-    var BodyTimeoutError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "BodyTimeoutError";
-        this.message = message || "Body Timeout Error";
-        this.code = "UND_ERR_BODY_TIMEOUT";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kBodyTimeoutError] === true;
-      }
-      get [kBodyTimeoutError]() {
-        return true;
-      }
-    };
-    var kInvalidArgumentError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_INVALID_ARG");
-    var InvalidArgumentError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "InvalidArgumentError";
-        this.message = message || "Invalid Argument Error";
-        this.code = "UND_ERR_INVALID_ARG";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kInvalidArgumentError] === true;
-      }
-      get [kInvalidArgumentError]() {
-        return true;
-      }
-    };
-    var kInvalidReturnValueError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_INVALID_RETURN_VALUE");
-    var InvalidReturnValueError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "InvalidReturnValueError";
-        this.message = message || "Invalid Return Value Error";
-        this.code = "UND_ERR_INVALID_RETURN_VALUE";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kInvalidReturnValueError] === true;
-      }
-      get [kInvalidReturnValueError]() {
-        return true;
-      }
-    };
-    var kAbortError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_ABORT");
-    var AbortError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "AbortError";
-        this.message = message || "The operation was aborted";
-        this.code = "UND_ERR_ABORT";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kAbortError] === true;
-      }
-      get [kAbortError]() {
-        return true;
-      }
-    };
-    var kRequestAbortedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_ABORTED");
-    var RequestAbortedError = class extends AbortError {
-      constructor(message) {
-        super(message);
-        this.name = "AbortError";
-        this.message = message || "Request aborted";
-        this.code = "UND_ERR_ABORTED";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kRequestAbortedError] === true;
-      }
-      get [kRequestAbortedError]() {
-        return true;
-      }
-    };
-    var kInformationalError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_INFO");
-    var InformationalError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "InformationalError";
-        this.message = message || "Request information";
-        this.code = "UND_ERR_INFO";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kInformationalError] === true;
-      }
-      get [kInformationalError]() {
-        return true;
-      }
-    };
-    var kRequestContentLengthMismatchError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH");
-    var RequestContentLengthMismatchError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "RequestContentLengthMismatchError";
-        this.message = message || "Request body length does not match content-length header";
-        this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kRequestContentLengthMismatchError] === true;
-      }
-      get [kRequestContentLengthMismatchError]() {
-        return true;
-      }
-    };
-    var kResponseContentLengthMismatchError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH");
-    var ResponseContentLengthMismatchError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "ResponseContentLengthMismatchError";
-        this.message = message || "Response body length does not match content-length header";
-        this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kResponseContentLengthMismatchError] === true;
-      }
-      get [kResponseContentLengthMismatchError]() {
-        return true;
-      }
-    };
-    var kClientDestroyedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_DESTROYED");
-    var ClientDestroyedError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "ClientDestroyedError";
-        this.message = message || "The client is destroyed";
-        this.code = "UND_ERR_DESTROYED";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kClientDestroyedError] === true;
-      }
-      get [kClientDestroyedError]() {
-        return true;
-      }
-    };
-    var kClientClosedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_CLOSED");
-    var ClientClosedError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "ClientClosedError";
-        this.message = message || "The client is closed";
-        this.code = "UND_ERR_CLOSED";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kClientClosedError] === true;
-      }
-      get [kClientClosedError]() {
-        return true;
-      }
-    };
-    var kSocketError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_SOCKET");
-    var SocketError = class extends UndiciError {
-      constructor(message, socket) {
-        super(message);
-        this.name = "SocketError";
-        this.message = message || "Socket error";
-        this.code = "UND_ERR_SOCKET";
-        this.socket = socket;
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kSocketError] === true;
-      }
-      get [kSocketError]() {
-        return true;
-      }
-    };
-    var kNotSupportedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_NOT_SUPPORTED");
-    var NotSupportedError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "NotSupportedError";
-        this.message = message || "Not supported error";
-        this.code = "UND_ERR_NOT_SUPPORTED";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kNotSupportedError] === true;
-      }
-      get [kNotSupportedError]() {
-        return true;
-      }
-    };
-    var kBalancedPoolMissingUpstreamError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_BPL_MISSING_UPSTREAM");
-    var BalancedPoolMissingUpstreamError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "MissingUpstreamError";
-        this.message = message || "No upstream has been added to the BalancedPool";
-        this.code = "UND_ERR_BPL_MISSING_UPSTREAM";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kBalancedPoolMissingUpstreamError] === true;
-      }
-      get [kBalancedPoolMissingUpstreamError]() {
-        return true;
-      }
-    };
-    var kHTTPParserError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HTTP_PARSER");
-    var HTTPParserError = class extends Error {
-      constructor(message, code, data) {
-        super(message);
-        this.name = "HTTPParserError";
-        this.code = code ? `HPE_${code}` : void 0;
-        this.data = data ? data.toString() : void 0;
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kHTTPParserError] === true;
-      }
-      get [kHTTPParserError]() {
-        return true;
-      }
-    };
-    var kResponseExceededMaxSizeError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE");
-    var ResponseExceededMaxSizeError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "ResponseExceededMaxSizeError";
-        this.message = message || "Response content exceeded max size";
-        this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kResponseExceededMaxSizeError] === true;
-      }
-      get [kResponseExceededMaxSizeError]() {
-        return true;
-      }
-    };
-    var kRequestRetryError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_REQ_RETRY");
-    var RequestRetryError = class extends UndiciError {
-      constructor(message, code, { headers, data }) {
-        super(message);
-        this.name = "RequestRetryError";
-        this.message = message || "Request retry error";
-        this.code = "UND_ERR_REQ_RETRY";
-        this.statusCode = code;
-        this.data = data;
-        this.headers = headers;
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kRequestRetryError] === true;
-      }
-      get [kRequestRetryError]() {
-        return true;
-      }
-    };
-    var kResponseError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RESPONSE");
-    var ResponseError = class extends UndiciError {
-      constructor(message, code, { headers, body }) {
-        super(message);
-        this.name = "ResponseError";
-        this.message = message || "Response error";
-        this.code = "UND_ERR_RESPONSE";
-        this.statusCode = code;
-        this.body = body;
-        this.headers = headers;
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kResponseError] === true;
-      }
-      get [kResponseError]() {
-        return true;
-      }
-    };
-    var kSecureProxyConnectionError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_PRX_TLS");
-    var SecureProxyConnectionError = class extends UndiciError {
-      constructor(cause, message, options = {}) {
-        super(message, { cause, ...options });
-        this.name = "SecureProxyConnectionError";
-        this.message = message || "Secure Proxy Connection failed";
-        this.code = "UND_ERR_PRX_TLS";
-        this.cause = cause;
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kSecureProxyConnectionError] === true;
-      }
-      get [kSecureProxyConnectionError]() {
-        return true;
-      }
-    };
-    var kMaxOriginsReachedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_MAX_ORIGINS_REACHED");
-    var MaxOriginsReachedError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "MaxOriginsReachedError";
-        this.message = message || "Maximum allowed origins reached";
-        this.code = "UND_ERR_MAX_ORIGINS_REACHED";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kMaxOriginsReachedError] === true;
-      }
-      get [kMaxOriginsReachedError]() {
-        return true;
-      }
-    };
-    module2.exports = {
-      AbortError,
-      HTTPParserError,
-      UndiciError,
-      HeadersTimeoutError,
-      HeadersOverflowError,
-      BodyTimeoutError,
-      RequestContentLengthMismatchError,
-      ConnectTimeoutError,
-      InvalidArgumentError,
-      InvalidReturnValueError,
-      RequestAbortedError,
-      ClientDestroyedError,
-      ClientClosedError,
-      InformationalError,
-      SocketError,
-      NotSupportedError,
-      ResponseContentLengthMismatchError,
-      BalancedPoolMissingUpstreamError,
-      ResponseExceededMaxSizeError,
-      RequestRetryError,
-      ResponseError,
-      SecureProxyConnectionError,
-      MaxOriginsReachedError
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/handler/wrap-handler.js
-var require_wrap_handler = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/handler/wrap-handler.js"(exports2, module2) {
-    "use strict";
-    var { InvalidArgumentError } = require_errors();
-    module2.exports = class WrapHandler {
-      #handler;
-      constructor(handler) {
-        this.#handler = handler;
-      }
-      static wrap(handler) {
-        return handler.onRequestStart ? handler : new WrapHandler(handler);
-      }
-      // Unwrap Interface
-      onConnect(abort, context) {
-        return this.#handler.onConnect?.(abort, context);
-      }
-      onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-        return this.#handler.onHeaders?.(statusCode, rawHeaders, resume, statusMessage);
-      }
-      onUpgrade(statusCode, rawHeaders, socket) {
-        return this.#handler.onUpgrade?.(statusCode, rawHeaders, socket);
-      }
-      onData(data) {
-        return this.#handler.onData?.(data);
-      }
-      onComplete(trailers) {
-        return this.#handler.onComplete?.(trailers);
-      }
-      onError(err) {
-        if (!this.#handler.onError) {
-          throw err;
-        }
-        return this.#handler.onError?.(err);
-      }
-      // Wrap Interface
-      onRequestStart(controller, context) {
-        this.#handler.onConnect?.((reason) => controller.abort(reason), context);
-      }
-      onRequestUpgrade(controller, statusCode, headers, socket) {
-        const rawHeaders = [];
-        for (const [key, val] of Object.entries(headers)) {
-          rawHeaders.push(Buffer.from(key), Array.isArray(val) ? val.map((v) => Buffer.from(v)) : Buffer.from(val));
-        }
-        this.#handler.onUpgrade?.(statusCode, rawHeaders, socket);
-      }
-      onResponseStart(controller, statusCode, headers, statusMessage) {
-        const rawHeaders = [];
-        for (const [key, val] of Object.entries(headers)) {
-          rawHeaders.push(Buffer.from(key), Array.isArray(val) ? val.map((v) => Buffer.from(v)) : Buffer.from(val));
-        }
-        if (this.#handler.onHeaders?.(statusCode, rawHeaders, () => controller.resume(), statusMessage) === false) {
-          controller.pause();
-        }
-      }
-      onResponseData(controller, data) {
-        if (this.#handler.onData?.(data) === false) {
-          controller.pause();
-        }
-      }
-      onResponseEnd(controller, trailers) {
-        const rawTrailers = [];
-        for (const [key, val] of Object.entries(trailers)) {
-          rawTrailers.push(Buffer.from(key), Array.isArray(val) ? val.map((v) => Buffer.from(v)) : Buffer.from(val));
-        }
-        this.#handler.onComplete?.(rawTrailers);
-      }
-      onResponseError(controller, err) {
-        if (!this.#handler.onError) {
-          throw new InvalidArgumentError("invalid onError method");
-        }
-        this.#handler.onError?.(err);
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/dispatcher/dispatcher.js
-var require_dispatcher = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/dispatcher/dispatcher.js"(exports2, module2) {
-    "use strict";
-    var EventEmitter = require("node:events");
-    var WrapHandler = require_wrap_handler();
-    var wrapInterceptor = (dispatch) => (opts, handler) => dispatch(opts, WrapHandler.wrap(handler));
-    var Dispatcher = class extends EventEmitter {
-      dispatch() {
-        throw new Error("not implemented");
-      }
-      close() {
-        throw new Error("not implemented");
-      }
-      destroy() {
-        throw new Error("not implemented");
-      }
-      compose(...args) {
-        const interceptors = Array.isArray(args[0]) ? args[0] : args;
-        let dispatch = this.dispatch.bind(this);
-        for (const interceptor of interceptors) {
-          if (interceptor == null) {
-            continue;
-          }
-          if (typeof interceptor !== "function") {
-            throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`);
-          }
-          dispatch = interceptor(dispatch);
-          dispatch = wrapInterceptor(dispatch);
-          if (dispatch == null || typeof dispatch !== "function" || dispatch.length !== 2) {
-            throw new TypeError("invalid interceptor");
-          }
-        }
-        return new Proxy(this, {
-          get: (target, key) => key === "dispatch" ? dispatch : target[key]
-        });
-      }
-    };
-    module2.exports = Dispatcher;
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/util/timers.js
-var require_timers = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/util/timers.js"(exports2, module2) {
-    "use strict";
-    var fastNow = 0;
-    var RESOLUTION_MS = 1e3;
-    var TICK_MS = (RESOLUTION_MS >> 1) - 1;
-    var fastNowTimeout;
-    var kFastTimer = /* @__PURE__ */ Symbol("kFastTimer");
-    var fastTimers = [];
-    var NOT_IN_LIST = -2;
-    var TO_BE_CLEARED = -1;
-    var PENDING = 0;
-    var ACTIVE = 1;
-    function onTick() {
-      fastNow += TICK_MS;
-      let idx = 0;
-      let len = fastTimers.length;
-      while (idx < len) {
-        const timer = fastTimers[idx];
-        if (timer._state === PENDING) {
-          timer._idleStart = fastNow - TICK_MS;
-          timer._state = ACTIVE;
-        } else if (timer._state === ACTIVE && fastNow >= timer._idleStart + timer._idleTimeout) {
-          timer._state = TO_BE_CLEARED;
-          timer._idleStart = -1;
-          timer._onTimeout(timer._timerArg);
-        }
-        if (timer._state === TO_BE_CLEARED) {
-          timer._state = NOT_IN_LIST;
-          if (--len !== 0) {
-            fastTimers[idx] = fastTimers[len];
-          }
-        } else {
-          ++idx;
-        }
-      }
-      fastTimers.length = len;
-      if (fastTimers.length !== 0) {
-        refreshTimeout();
-      }
-    }
-    function refreshTimeout() {
-      if (fastNowTimeout?.refresh) {
-        fastNowTimeout.refresh();
-      } else {
-        clearTimeout(fastNowTimeout);
-        fastNowTimeout = setTimeout(onTick, TICK_MS);
-        fastNowTimeout?.unref();
-      }
-    }
-    var FastTimer = class {
-      [kFastTimer] = true;
-      /**
-       * The state of the timer, which can be one of the following:
-       * - NOT_IN_LIST (-2)
-       * - TO_BE_CLEARED (-1)
-       * - PENDING (0)
-       * - ACTIVE (1)
-       *
-       * @type {-2|-1|0|1}
-       * @private
-       */
-      _state = NOT_IN_LIST;
-      /**
-       * The number of milliseconds to wait before calling the callback.
-       *
-       * @type {number}
-       * @private
-       */
-      _idleTimeout = -1;
-      /**
-       * The time in milliseconds when the timer was started. This value is used to
-       * calculate when the timer should expire.
-       *
-       * @type {number}
-       * @default -1
-       * @private
-       */
-      _idleStart = -1;
-      /**
-       * The function to be executed when the timer expires.
-       * @type {Function}
-       * @private
-       */
-      _onTimeout;
-      /**
-       * The argument to be passed to the callback when the timer expires.
-       *
-       * @type {*}
-       * @private
-       */
-      _timerArg;
-      /**
-       * @constructor
-       * @param {Function} callback A function to be executed after the timer
-       * expires.
-       * @param {number} delay The time, in milliseconds that the timer should wait
-       * before the specified function or code is executed.
-       * @param {*} arg
-       */
-      constructor(callback, delay, arg) {
-        this._onTimeout = callback;
-        this._idleTimeout = delay;
-        this._timerArg = arg;
-        this.refresh();
-      }
-      /**
-       * Sets the timer's start time to the current time, and reschedules the timer
-       * to call its callback at the previously specified duration adjusted to the
-       * current time.
-       * Using this on a timer that has already called its callback will reactivate
-       * the timer.
-       *
-       * @returns {void}
-       */
-      refresh() {
-        if (this._state === NOT_IN_LIST) {
-          fastTimers.push(this);
-        }
-        if (!fastNowTimeout || fastTimers.length === 1) {
-          refreshTimeout();
-        }
-        this._state = PENDING;
-      }
-      /**
-       * The `clear` method cancels the timer, preventing it from executing.
-       *
-       * @returns {void}
-       * @private
-       */
-      clear() {
-        this._state = TO_BE_CLEARED;
-        this._idleStart = -1;
-      }
-    };
-    module2.exports = {
-      /**
-       * The setTimeout() method sets a timer which executes a function once the
-       * timer expires.
-       * @param {Function} callback A function to be executed after the timer
-       * expires.
-       * @param {number} delay The time, in milliseconds that the timer should
-       * wait before the specified function or code is executed.
-       * @param {*} [arg] An optional argument to be passed to the callback function
-       * when the timer expires.
-       * @returns {NodeJS.Timeout|FastTimer}
-       */
-      setTimeout(callback, delay, arg) {
-        return delay <= RESOLUTION_MS ? setTimeout(callback, delay, arg) : new FastTimer(callback, delay, arg);
-      },
-      /**
-       * The clearTimeout method cancels an instantiated Timer previously created
-       * by calling setTimeout.
-       *
-       * @param {NodeJS.Timeout|FastTimer} timeout
-       */
-      clearTimeout(timeout) {
-        if (timeout[kFastTimer]) {
-          timeout.clear();
-        } else {
-          clearTimeout(timeout);
-        }
-      },
-      /**
-       * The setFastTimeout() method sets a fastTimer which executes a function once
-       * the timer expires.
-       * @param {Function} callback A function to be executed after the timer
-       * expires.
-       * @param {number} delay The time, in milliseconds that the timer should
-       * wait before the specified function or code is executed.
-       * @param {*} [arg] An optional argument to be passed to the callback function
-       * when the timer expires.
-       * @returns {FastTimer}
-       */
-      setFastTimeout(callback, delay, arg) {
-        return new FastTimer(callback, delay, arg);
-      },
-      /**
-       * The clearTimeout method cancels an instantiated FastTimer previously
-       * created by calling setFastTimeout.
-       *
-       * @param {FastTimer} timeout
-       */
-      clearFastTimeout(timeout) {
-        timeout.clear();
-      },
-      /**
-       * The now method returns the value of the internal fast timer clock.
-       *
-       * @returns {number}
-       */
-      now() {
-        return fastNow;
-      },
-      /**
-       * Trigger the onTick function to process the fastTimers array.
-       * Exported for testing purposes only.
-       * Marking as deprecated to discourage any use outside of testing.
-       * @deprecated
-       * @param {number} [delay=0] The delay in milliseconds to add to the now value.
-       */
-      tick(delay = 0) {
-        fastNow += delay - RESOLUTION_MS + 1;
-        onTick();
-        onTick();
-      },
-      /**
-       * Reset FastTimers.
-       * Exported for testing purposes only.
-       * Marking as deprecated to discourage any use outside of testing.
-       * @deprecated
-       */
-      reset() {
-        fastNow = 0;
-        fastTimers.length = 0;
-        clearTimeout(fastNowTimeout);
-        fastNowTimeout = null;
-      },
-      /**
-       * Exporting for testing purposes only.
-       * Marking as deprecated to discourage any use outside of testing.
-       * @deprecated
-       */
-      kFastTimer
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/core/constants.js
-var require_constants = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/core/constants.js"(exports2, module2) {
-    "use strict";
-    var wellknownHeaderNames = (
-      /** @type {const} */
-      [
-        "Accept",
-        "Accept-Encoding",
-        "Accept-Language",
-        "Accept-Ranges",
-        "Access-Control-Allow-Credentials",
-        "Access-Control-Allow-Headers",
-        "Access-Control-Allow-Methods",
-        "Access-Control-Allow-Origin",
-        "Access-Control-Expose-Headers",
-        "Access-Control-Max-Age",
-        "Access-Control-Request-Headers",
-        "Access-Control-Request-Method",
-        "Age",
-        "Allow",
-        "Alt-Svc",
-        "Alt-Used",
-        "Authorization",
-        "Cache-Control",
-        "Clear-Site-Data",
-        "Connection",
-        "Content-Disposition",
-        "Content-Encoding",
-        "Content-Language",
-        "Content-Length",
-        "Content-Location",
-        "Content-Range",
-        "Content-Security-Policy",
-        "Content-Security-Policy-Report-Only",
-        "Content-Type",
-        "Cookie",
-        "Cross-Origin-Embedder-Policy",
-        "Cross-Origin-Opener-Policy",
-        "Cross-Origin-Resource-Policy",
-        "Date",
-        "Device-Memory",
-        "Downlink",
-        "ECT",
-        "ETag",
-        "Expect",
-        "Expect-CT",
-        "Expires",
-        "Forwarded",
-        "From",
-        "Host",
-        "If-Match",
-        "If-Modified-Since",
-        "If-None-Match",
-        "If-Range",
-        "If-Unmodified-Since",
-        "Keep-Alive",
-        "Last-Modified",
-        "Link",
-        "Location",
-        "Max-Forwards",
-        "Origin",
-        "Permissions-Policy",
-        "Pragma",
-        "Proxy-Authenticate",
-        "Proxy-Authorization",
-        "RTT",
-        "Range",
-        "Referer",
-        "Referrer-Policy",
-        "Refresh",
-        "Retry-After",
-        "Sec-WebSocket-Accept",
-        "Sec-WebSocket-Extensions",
-        "Sec-WebSocket-Key",
-        "Sec-WebSocket-Protocol",
-        "Sec-WebSocket-Version",
-        "Server",
-        "Server-Timing",
-        "Service-Worker-Allowed",
-        "Service-Worker-Navigation-Preload",
-        "Set-Cookie",
-        "SourceMap",
-        "Strict-Transport-Security",
-        "Supports-Loading-Mode",
-        "TE",
-        "Timing-Allow-Origin",
-        "Trailer",
-        "Transfer-Encoding",
-        "Upgrade",
-        "Upgrade-Insecure-Requests",
-        "User-Agent",
-        "Vary",
-        "Via",
-        "WWW-Authenticate",
-        "X-Content-Type-Options",
-        "X-DNS-Prefetch-Control",
-        "X-Frame-Options",
-        "X-Permitted-Cross-Domain-Policies",
-        "X-Powered-By",
-        "X-Requested-With",
-        "X-XSS-Protection"
-      ]
-    );
-    var headerNameLowerCasedRecord = {};
-    Object.setPrototypeOf(headerNameLowerCasedRecord, null);
-    var wellknownHeaderNameBuffers = {};
-    Object.setPrototypeOf(wellknownHeaderNameBuffers, null);
-    function getHeaderNameAsBuffer(header) {
-      let buffer = wellknownHeaderNameBuffers[header];
-      if (buffer === void 0) {
-        buffer = Buffer.from(header);
-      }
-      return buffer;
-    }
-    for (let i = 0; i < wellknownHeaderNames.length; ++i) {
-      const key = wellknownHeaderNames[i];
-      const lowerCasedKey = key.toLowerCase();
-      headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey;
-    }
-    module2.exports = {
-      wellknownHeaderNames,
-      headerNameLowerCasedRecord,
-      getHeaderNameAsBuffer
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/core/tree.js
-var require_tree = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/core/tree.js"(exports2, module2) {
-    "use strict";
-    var {
-      wellknownHeaderNames,
-      headerNameLowerCasedRecord
-    } = require_constants();
-    var TstNode = class _TstNode {
-      /** @type {any} */
-      value = null;
-      /** @type {null | TstNode} */
-      left = null;
-      /** @type {null | TstNode} */
-      middle = null;
-      /** @type {null | TstNode} */
-      right = null;
-      /** @type {number} */
-      code;
-      /**
-       * @param {string} key
-       * @param {any} value
-       * @param {number} index
-       */
-      constructor(key, value, index) {
-        if (index === void 0 || index >= key.length) {
-          throw new TypeError("Unreachable");
-        }
-        const code = this.code = key.charCodeAt(index);
-        if (code > 127) {
-          throw new TypeError("key must be ascii string");
-        }
-        if (key.length !== ++index) {
-          this.middle = new _TstNode(key, value, index);
-        } else {
-          this.value = value;
-        }
-      }
-      /**
-       * @param {string} key
-       * @param {any} value
-       * @returns {void}
-       */
-      add(key, value) {
-        const length = key.length;
-        if (length === 0) {
-          throw new TypeError("Unreachable");
-        }
-        let index = 0;
-        let node = this;
-        while (true) {
-          const code = key.charCodeAt(index);
-          if (code > 127) {
-            throw new TypeError("key must be ascii string");
-          }
-          if (node.code === code) {
-            if (length === ++index) {
-              node.value = value;
-              break;
-            } else if (node.middle !== null) {
-              node = node.middle;
-            } else {
-              node.middle = new _TstNode(key, value, index);
-              break;
-            }
-          } else if (node.code < code) {
-            if (node.left !== null) {
-              node = node.left;
-            } else {
-              node.left = new _TstNode(key, value, index);
-              break;
-            }
-          } else if (node.right !== null) {
-            node = node.right;
-          } else {
-            node.right = new _TstNode(key, value, index);
-            break;
-          }
-        }
-      }
-      /**
-       * @param {Uint8Array} key
-       * @returns {TstNode | null}
-       */
-      search(key) {
-        const keylength = key.length;
-        let index = 0;
-        let node = this;
-        while (node !== null && index < keylength) {
-          let code = key[index];
-          if (code <= 90 && code >= 65) {
-            code |= 32;
-          }
-          while (node !== null) {
-            if (code === node.code) {
-              if (keylength === ++index) {
-                return node;
-              }
-              node = node.middle;
-              break;
-            }
-            node = node.code < code ? node.left : node.right;
-          }
-        }
-        return null;
-      }
-    };
-    var TernarySearchTree = class {
-      /** @type {TstNode | null} */
-      node = null;
-      /**
-       * @param {string} key
-       * @param {any} value
-       * @returns {void}
-       * */
-      insert(key, value) {
-        if (this.node === null) {
-          this.node = new TstNode(key, value, 0);
-        } else {
-          this.node.add(key, value);
-        }
-      }
-      /**
-       * @param {Uint8Array} key
-       * @returns {any}
-       */
-      lookup(key) {
-        return this.node?.search(key)?.value ?? null;
-      }
-    };
-    var tree = new TernarySearchTree();
-    for (let i = 0; i < wellknownHeaderNames.length; ++i) {
-      const key = headerNameLowerCasedRecord[wellknownHeaderNames[i]];
-      tree.insert(key, key);
-    }
-    module2.exports = {
-      TernarySearchTree,
-      tree
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/core/util.js
-var require_util = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/core/util.js"(exports2, module2) {
-    "use strict";
-    var assert = require("node:assert");
-    var { kDestroyed, kBodyUsed, kListeners, kBody } = require_symbols();
-    var { IncomingMessage } = require("node:http");
-    var stream = require("node:stream");
-    var net = require("node:net");
-    var { stringify } = require("node:querystring");
-    var { EventEmitter: EE } = require("node:events");
-    var timers = require_timers();
-    var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
-    var { headerNameLowerCasedRecord } = require_constants();
-    var { tree } = require_tree();
-    var [nodeMajor, nodeMinor] = process.versions.node.split(".", 2).map((v) => Number(v));
-    var BodyAsyncIterable = class {
-      constructor(body) {
-        this[kBody] = body;
-        this[kBodyUsed] = false;
-      }
-      async *[Symbol.asyncIterator]() {
-        assert(!this[kBodyUsed], "disturbed");
-        this[kBodyUsed] = true;
-        yield* this[kBody];
-      }
-    };
-    function noop() {
-    }
-    function wrapRequestBody(body) {
-      if (isStream(body)) {
-        if (bodyLength(body) === 0) {
-          body.on("data", function() {
-            assert(false);
-          });
-        }
-        if (typeof body.readableDidRead !== "boolean") {
-          body[kBodyUsed] = false;
-          EE.prototype.on.call(body, "data", function() {
-            this[kBodyUsed] = true;
-          });
-        }
-        return body;
-      } else if (body && typeof body.pipeTo === "function") {
-        return new BodyAsyncIterable(body);
-      } else if (body && typeof body !== "string" && !ArrayBuffer.isView(body) && isIterable(body)) {
-        return new BodyAsyncIterable(body);
-      } else {
-        return body;
-      }
-    }
-    function isStream(obj) {
-      return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function";
-    }
-    function isBlobLike(object) {
-      if (object === null) {
-        return false;
-      } else if (object instanceof Blob) {
-        return true;
-      } else if (typeof object !== "object") {
-        return false;
-      } else {
-        const sTag = object[Symbol.toStringTag];
-        return (sTag === "Blob" || sTag === "File") && ("stream" in object && typeof object.stream === "function" || "arrayBuffer" in object && typeof object.arrayBuffer === "function");
-      }
-    }
-    function pathHasQueryOrFragment(url) {
-      return url.includes("?") || url.includes("#");
-    }
-    function serializePathWithQuery(url, queryParams) {
-      if (pathHasQueryOrFragment(url)) {
-        throw new Error('Query params cannot be passed when url already contains "?" or "#".');
-      }
-      const stringified = stringify(queryParams);
-      if (stringified) {
-        url += "?" + stringified;
-      }
-      return url;
-    }
-    function isValidPort(port) {
-      const value = parseInt(port, 10);
-      return value === Number(port) && value >= 0 && value <= 65535;
-    }
-    function isHttpOrHttpsPrefixed(value) {
-      return value != null && value[0] === "h" && value[1] === "t" && value[2] === "t" && value[3] === "p" && (value[4] === ":" || value[4] === "s" && value[5] === ":");
-    }
-    function parseURL(url) {
-      if (typeof url === "string") {
-        url = new URL(url);
-        if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
-          throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
-        }
-        return url;
-      }
-      if (!url || typeof url !== "object") {
-        throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object.");
-      }
-      if (!(url instanceof URL)) {
-        if (url.port != null && url.port !== "" && isValidPort(url.port) === false) {
-          throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer.");
-        }
-        if (url.path != null && typeof url.path !== "string") {
-          throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined.");
-        }
-        if (url.pathname != null && typeof url.pathname !== "string") {
-          throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined.");
-        }
-        if (url.hostname != null && typeof url.hostname !== "string") {
-          throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined.");
-        }
-        if (url.origin != null && typeof url.origin !== "string") {
-          throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined.");
-        }
-        if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
-          throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
-        }
-        const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
-        let origin = url.origin != null ? url.origin : `${url.protocol || ""}//${url.hostname || ""}:${port}`;
-        let path = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
-        if (origin[origin.length - 1] === "/") {
-          origin = origin.slice(0, origin.length - 1);
-        }
-        if (path && path[0] !== "/") {
-          path = `/${path}`;
-        }
-        return new URL(`${origin}${path}`);
-      }
-      if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
-        throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
-      }
-      return url;
-    }
-    function parseOrigin(url) {
-      url = parseURL(url);
-      if (url.pathname !== "/" || url.search || url.hash) {
-        throw new InvalidArgumentError("invalid url");
-      }
-      return url;
-    }
-    function getHostname(host) {
-      if (host[0] === "[") {
-        const idx2 = host.indexOf("]");
-        assert(idx2 !== -1);
-        return host.substring(1, idx2);
-      }
-      const idx = host.indexOf(":");
-      if (idx === -1) return host;
-      return host.substring(0, idx);
-    }
-    function getServerName(host) {
-      if (!host) {
-        return null;
-      }
-      assert(typeof host === "string");
-      const servername = getHostname(host);
-      if (net.isIP(servername)) {
-        return "";
-      }
-      return servername;
-    }
-    function deepClone(obj) {
-      return JSON.parse(JSON.stringify(obj));
-    }
-    function isAsyncIterable(obj) {
-      return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function");
-    }
-    function isIterable(obj) {
-      return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function"));
-    }
-    function bodyLength(body) {
-      if (body == null) {
-        return 0;
-      } else if (isStream(body)) {
-        const state = body._readableState;
-        return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null;
-      } else if (isBlobLike(body)) {
-        return body.size != null ? body.size : null;
-      } else if (isBuffer(body)) {
-        return body.byteLength;
-      }
-      return null;
-    }
-    function isDestroyed(body) {
-      return body && !!(body.destroyed || body[kDestroyed] || stream.isDestroyed?.(body));
-    }
-    function destroy(stream2, err) {
-      if (stream2 == null || !isStream(stream2) || isDestroyed(stream2)) {
-        return;
-      }
-      if (typeof stream2.destroy === "function") {
-        if (Object.getPrototypeOf(stream2).constructor === IncomingMessage) {
-          stream2.socket = null;
-        }
-        stream2.destroy(err);
-      } else if (err) {
-        queueMicrotask(() => {
-          stream2.emit("error", err);
-        });
-      }
-      if (stream2.destroyed !== true) {
-        stream2[kDestroyed] = true;
-      }
-    }
-    var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/;
-    function parseKeepAliveTimeout(val) {
-      const m = val.match(KEEPALIVE_TIMEOUT_EXPR);
-      return m ? parseInt(m[1], 10) * 1e3 : null;
-    }
-    function headerNameToString(value) {
-      return typeof value === "string" ? headerNameLowerCasedRecord[value] ?? value.toLowerCase() : tree.lookup(value) ?? value.toString("latin1").toLowerCase();
-    }
-    function bufferToLowerCasedHeaderName(value) {
-      return tree.lookup(value) ?? value.toString("latin1").toLowerCase();
-    }
-    function parseHeaders(headers, obj) {
-      if (obj === void 0) obj = {};
-      for (let i = 0; i < headers.length; i += 2) {
-        const key = headerNameToString(headers[i]);
-        let val = obj[key];
-        if (val) {
-          if (typeof val === "string") {
-            val = [val];
-            obj[key] = val;
-          }
-          val.push(headers[i + 1].toString("utf8"));
-        } else {
-          const headersValue = headers[i + 1];
-          if (typeof headersValue === "string") {
-            obj[key] = headersValue;
-          } else {
-            obj[key] = Array.isArray(headersValue) ? headersValue.map((x) => x.toString("utf8")) : headersValue.toString("utf8");
-          }
-        }
-      }
-      if ("content-length" in obj && "content-disposition" in obj) {
-        obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1");
-      }
-      return obj;
-    }
-    function parseRawHeaders(headers) {
-      const headersLength = headers.length;
-      const ret = new Array(headersLength);
-      let hasContentLength = false;
-      let contentDispositionIdx = -1;
-      let key;
-      let val;
-      let kLen = 0;
-      for (let n = 0; n < headersLength; n += 2) {
-        key = headers[n];
-        val = headers[n + 1];
-        typeof key !== "string" && (key = key.toString());
-        typeof val !== "string" && (val = val.toString("utf8"));
-        kLen = key.length;
-        if (kLen === 14 && key[7] === "-" && (key === "content-length" || key.toLowerCase() === "content-length")) {
-          hasContentLength = true;
-        } else if (kLen === 19 && key[7] === "-" && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) {
-          contentDispositionIdx = n + 1;
-        }
-        ret[n] = key;
-        ret[n + 1] = val;
-      }
-      if (hasContentLength && contentDispositionIdx !== -1) {
-        ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1");
-      }
-      return ret;
-    }
-    function encodeRawHeaders(headers) {
-      if (!Array.isArray(headers)) {
-        throw new TypeError("expected headers to be an array");
-      }
-      return headers.map((x) => Buffer.from(x));
-    }
-    function isBuffer(buffer) {
-      return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
-    }
-    function assertRequestHandler(handler, method, upgrade) {
-      if (!handler || typeof handler !== "object") {
-        throw new InvalidArgumentError("handler must be an object");
-      }
-      if (typeof handler.onRequestStart === "function") {
-        return;
-      }
-      if (typeof handler.onConnect !== "function") {
-        throw new InvalidArgumentError("invalid onConnect method");
-      }
-      if (typeof handler.onError !== "function") {
-        throw new InvalidArgumentError("invalid onError method");
-      }
-      if (typeof handler.onBodySent !== "function" && handler.onBodySent !== void 0) {
-        throw new InvalidArgumentError("invalid onBodySent method");
-      }
-      if (upgrade || method === "CONNECT") {
-        if (typeof handler.onUpgrade !== "function") {
-          throw new InvalidArgumentError("invalid onUpgrade method");
-        }
-      } else {
-        if (typeof handler.onHeaders !== "function") {
-          throw new InvalidArgumentError("invalid onHeaders method");
-        }
-        if (typeof handler.onData !== "function") {
-          throw new InvalidArgumentError("invalid onData method");
-        }
-        if (typeof handler.onComplete !== "function") {
-          throw new InvalidArgumentError("invalid onComplete method");
-        }
-      }
-    }
-    function isDisturbed(body) {
-      return !!(body && (stream.isDisturbed(body) || body[kBodyUsed]));
-    }
-    function getSocketInfo(socket) {
-      return {
-        localAddress: socket.localAddress,
-        localPort: socket.localPort,
-        remoteAddress: socket.remoteAddress,
-        remotePort: socket.remotePort,
-        remoteFamily: socket.remoteFamily,
-        timeout: socket.timeout,
-        bytesWritten: socket.bytesWritten,
-        bytesRead: socket.bytesRead
-      };
-    }
-    function ReadableStreamFrom(iterable) {
-      let iterator;
-      return new ReadableStream(
-        {
-          start() {
-            iterator = iterable[Symbol.asyncIterator]();
-          },
-          pull(controller) {
-            return iterator.next().then(({ done, value }) => {
-              if (done) {
-                return queueMicrotask(() => {
-                  controller.close();
-                  controller.byobRequest?.respond(0);
-                });
-              } else {
-                const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
-                if (buf.byteLength) {
-                  return controller.enqueue(new Uint8Array(buf));
-                } else {
-                  return this.pull(controller);
-                }
-              }
-            });
-          },
-          cancel() {
-            return iterator.return();
-          },
-          type: "bytes"
-        }
-      );
-    }
-    function isFormDataLike(object) {
-      return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData";
-    }
-    function addAbortListener(signal, listener) {
-      if ("addEventListener" in signal) {
-        signal.addEventListener("abort", listener, { once: true });
-        return () => signal.removeEventListener("abort", listener);
-      }
-      signal.once("abort", listener);
-      return () => signal.removeListener("abort", listener);
-    }
-    var validTokenChars = new Uint8Array([
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 0-15
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 16-31
-      0,
-      1,
-      0,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      0,
-      1,
-      1,
-      0,
-      1,
-      1,
-      0,
-      // 32-47 (!"#$%&'()*+,-./)
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 48-63 (0-9:;<=>?)
-      0,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      // 64-79 (@A-O)
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      0,
-      0,
-      1,
-      1,
-      // 80-95 (P-Z[\]^_)
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      // 96-111 (`a-o)
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      1,
-      0,
-      1,
-      0,
-      // 112-127 (p-z{|}~)
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 128-143
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 144-159
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 160-175
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 176-191
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 192-207
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 208-223
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      // 224-239
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0
-      // 240-255
-    ]);
-    function isTokenCharCode(c) {
-      return validTokenChars[c] === 1;
-    }
-    var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
-    function isValidHTTPToken(characters) {
-      if (characters.length >= 12) return tokenRegExp.test(characters);
-      if (characters.length === 0) return false;
-      for (let i = 0; i < characters.length; i++) {
-        if (validTokenChars[characters.charCodeAt(i)] !== 1) {
-          return false;
-        }
-      }
-      return true;
-    }
-    var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
-    function isValidHeaderValue(characters) {
-      return !headerCharRegex.test(characters);
-    }
-    var rangeHeaderRegex = /^bytes (\d+)-(\d+)\/(\d+)?$/;
-    function parseRangeHeader(range) {
-      if (range == null || range === "") return { start: 0, end: null, size: null };
-      const m = range ? range.match(rangeHeaderRegex) : null;
-      return m ? {
-        start: parseInt(m[1]),
-        end: m[2] ? parseInt(m[2]) : null,
-        size: m[3] ? parseInt(m[3]) : null
-      } : null;
-    }
-    function addListener(obj, name, listener) {
-      const listeners = obj[kListeners] ??= [];
-      listeners.push([name, listener]);
-      obj.on(name, listener);
-      return obj;
-    }
-    function removeAllListeners(obj) {
-      if (obj[kListeners] != null) {
-        for (const [name, listener] of obj[kListeners]) {
-          obj.removeListener(name, listener);
-        }
-        obj[kListeners] = null;
-      }
-      return obj;
-    }
-    function errorRequest(client, request, err) {
-      try {
-        request.onError(err);
-        assert(request.aborted);
-      } catch (err2) {
-        client.emit("error", err2);
-      }
-    }
-    var setupConnectTimeout = process.platform === "win32" ? (socketWeakRef, opts) => {
-      if (!opts.timeout) {
-        return noop;
-      }
-      let s1 = null;
-      let s2 = null;
-      const fastTimer = timers.setFastTimeout(() => {
-        s1 = setImmediate(() => {
-          s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts));
-        });
-      }, opts.timeout);
-      return () => {
-        timers.clearFastTimeout(fastTimer);
-        clearImmediate(s1);
-        clearImmediate(s2);
-      };
-    } : (socketWeakRef, opts) => {
-      if (!opts.timeout) {
-        return noop;
-      }
-      let s1 = null;
-      const fastTimer = timers.setFastTimeout(() => {
-        s1 = setImmediate(() => {
-          onConnectTimeout(socketWeakRef.deref(), opts);
-        });
-      }, opts.timeout);
-      return () => {
-        timers.clearFastTimeout(fastTimer);
-        clearImmediate(s1);
-      };
-    };
-    function onConnectTimeout(socket, opts) {
-      if (socket == null) {
-        return;
-      }
-      let message = "Connect Timeout Error";
-      if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
-        message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(", ")},`;
-      } else {
-        message += ` (attempted address: ${opts.hostname}:${opts.port},`;
-      }
-      message += ` timeout: ${opts.timeout}ms)`;
-      destroy(socket, new ConnectTimeoutError(message));
-    }
-    function getProtocolFromUrlString(urlString) {
-      if (urlString[0] === "h" && urlString[1] === "t" && urlString[2] === "t" && urlString[3] === "p") {
-        switch (urlString[4]) {
-          case ":":
-            return "http:";
-          case "s":
-            if (urlString[5] === ":") {
-              return "https:";
-            }
-        }
-      }
-      return urlString.slice(0, urlString.indexOf(":") + 1);
-    }
-    var kEnumerableProperty = /* @__PURE__ */ Object.create(null);
-    kEnumerableProperty.enumerable = true;
-    var normalizedMethodRecordsBase = {
-      delete: "DELETE",
-      DELETE: "DELETE",
-      get: "GET",
-      GET: "GET",
-      head: "HEAD",
-      HEAD: "HEAD",
-      options: "OPTIONS",
-      OPTIONS: "OPTIONS",
-      post: "POST",
-      POST: "POST",
-      put: "PUT",
-      PUT: "PUT"
-    };
-    var normalizedMethodRecords = {
-      ...normalizedMethodRecordsBase,
-      patch: "patch",
-      PATCH: "PATCH"
-    };
-    Object.setPrototypeOf(normalizedMethodRecordsBase, null);
-    Object.setPrototypeOf(normalizedMethodRecords, null);
-    module2.exports = {
-      kEnumerableProperty,
-      isDisturbed,
-      isBlobLike,
-      parseOrigin,
-      parseURL,
-      getServerName,
-      isStream,
-      isIterable,
-      isAsyncIterable,
-      isDestroyed,
-      headerNameToString,
-      bufferToLowerCasedHeaderName,
-      addListener,
-      removeAllListeners,
-      errorRequest,
-      parseRawHeaders,
-      encodeRawHeaders,
-      parseHeaders,
-      parseKeepAliveTimeout,
-      destroy,
-      bodyLength,
-      deepClone,
-      ReadableStreamFrom,
-      isBuffer,
-      assertRequestHandler,
-      getSocketInfo,
-      isFormDataLike,
-      pathHasQueryOrFragment,
-      serializePathWithQuery,
-      addAbortListener,
-      isValidHTTPToken,
-      isValidHeaderValue,
-      isTokenCharCode,
-      parseRangeHeader,
-      normalizedMethodRecordsBase,
-      normalizedMethodRecords,
-      isValidPort,
-      isHttpOrHttpsPrefixed,
-      nodeMajor,
-      nodeMinor,
-      safeHTTPMethods: Object.freeze(["GET", "HEAD", "OPTIONS", "TRACE"]),
-      wrapRequestBody,
-      setupConnectTimeout,
-      getProtocolFromUrlString
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/handler/unwrap-handler.js
-var require_unwrap_handler = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/handler/unwrap-handler.js"(exports2, module2) {
-    "use strict";
-    var { parseHeaders } = require_util();
-    var { InvalidArgumentError } = require_errors();
-    var kResume = /* @__PURE__ */ Symbol("resume");
-    var UnwrapController = class {
-      #paused = false;
-      #reason = null;
-      #aborted = false;
-      #abort;
-      [kResume] = null;
-      constructor(abort) {
-        this.#abort = abort;
-      }
-      pause() {
-        this.#paused = true;
-      }
-      resume() {
-        if (this.#paused) {
-          this.#paused = false;
-          this[kResume]?.();
-        }
-      }
-      abort(reason) {
-        if (!this.#aborted) {
-          this.#aborted = true;
-          this.#reason = reason;
-          this.#abort(reason);
-        }
-      }
-      get aborted() {
-        return this.#aborted;
-      }
-      get reason() {
-        return this.#reason;
-      }
-      get paused() {
-        return this.#paused;
-      }
-    };
-    module2.exports = class UnwrapHandler {
-      #handler;
-      #controller;
-      constructor(handler) {
-        this.#handler = handler;
-      }
-      static unwrap(handler) {
-        return !handler.onRequestStart ? handler : new UnwrapHandler(handler);
-      }
-      onConnect(abort, context) {
-        this.#controller = new UnwrapController(abort);
-        this.#handler.onRequestStart?.(this.#controller, context);
-      }
-      onUpgrade(statusCode, rawHeaders, socket) {
-        this.#handler.onRequestUpgrade?.(this.#controller, statusCode, parseHeaders(rawHeaders), socket);
-      }
-      onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-        this.#controller[kResume] = resume;
-        this.#handler.onResponseStart?.(this.#controller, statusCode, parseHeaders(rawHeaders), statusMessage);
-        return !this.#controller.paused;
-      }
-      onData(data) {
-        this.#handler.onResponseData?.(this.#controller, data);
-        return !this.#controller.paused;
-      }
-      onComplete(rawTrailers) {
-        this.#handler.onResponseEnd?.(this.#controller, parseHeaders(rawTrailers));
-      }
-      onError(err) {
-        if (!this.#handler.onResponseError) {
-          throw new InvalidArgumentError("invalid onError method");
-        }
-        this.#handler.onResponseError?.(this.#controller, err);
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/dispatcher/dispatcher-base.js
-var require_dispatcher_base = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/dispatcher/dispatcher-base.js"(exports2, module2) {
-    "use strict";
-    var Dispatcher = require_dispatcher();
-    var UnwrapHandler = require_unwrap_handler();
-    var {
-      ClientDestroyedError,
-      ClientClosedError,
-      InvalidArgumentError
-    } = require_errors();
-    var { kDestroy, kClose, kClosed, kDestroyed, kDispatch } = require_symbols();
-    var kOnDestroyed = /* @__PURE__ */ Symbol("onDestroyed");
-    var kOnClosed = /* @__PURE__ */ Symbol("onClosed");
-    var DispatcherBase = class extends Dispatcher {
-      /** @type {boolean} */
-      [kDestroyed] = false;
-      /** @type {Array<Function|null} */
-      [kOnDestroyed] = null;
-      /** @type {boolean} */
-      [kClosed] = false;
-      /** @type {Array<Function>|null} */
-      [kOnClosed] = null;
-      /** @returns {boolean} */
-      get destroyed() {
-        return this[kDestroyed];
-      }
-      /** @returns {boolean} */
-      get closed() {
-        return this[kClosed];
-      }
-      close(callback) {
-        if (callback === void 0) {
-          return new Promise((resolve, reject) => {
-            this.close((err, data) => {
-              return err ? reject(err) : resolve(data);
-            });
-          });
-        }
-        if (typeof callback !== "function") {
-          throw new InvalidArgumentError("invalid callback");
-        }
-        if (this[kDestroyed]) {
-          const err = new ClientDestroyedError();
-          queueMicrotask(() => callback(err, null));
-          return;
-        }
-        if (this[kClosed]) {
-          if (this[kOnClosed]) {
-            this[kOnClosed].push(callback);
-          } else {
-            queueMicrotask(() => callback(null, null));
-          }
-          return;
-        }
-        this[kClosed] = true;
-        this[kOnClosed] ??= [];
-        this[kOnClosed].push(callback);
-        const onClosed = () => {
-          const callbacks = this[kOnClosed];
-          this[kOnClosed] = null;
-          for (let i = 0; i < callbacks.length; i++) {
-            callbacks[i](null, null);
-          }
-        };
-        this[kClose]().then(() => this.destroy()).then(() => queueMicrotask(onClosed));
-      }
-      destroy(err, callback) {
-        if (typeof err === "function") {
-          callback = err;
-          err = null;
-        }
-        if (callback === void 0) {
-          return new Promise((resolve, reject) => {
-            this.destroy(err, (err2, data) => {
-              return err2 ? reject(err2) : resolve(data);
-            });
-          });
-        }
-        if (typeof callback !== "function") {
-          throw new InvalidArgumentError("invalid callback");
-        }
-        if (this[kDestroyed]) {
-          if (this[kOnDestroyed]) {
-            this[kOnDestroyed].push(callback);
-          } else {
-            queueMicrotask(() => callback(null, null));
-          }
-          return;
-        }
-        if (!err) {
-          err = new ClientDestroyedError();
-        }
-        this[kDestroyed] = true;
-        this[kOnDestroyed] ??= [];
-        this[kOnDestroyed].push(callback);
-        const onDestroyed = () => {
-          const callbacks = this[kOnDestroyed];
-          this[kOnDestroyed] = null;
-          for (let i = 0; i < callbacks.length; i++) {
-            callbacks[i](null, null);
-          }
-        };
-        this[kDestroy](err).then(() => queueMicrotask(onDestroyed));
-      }
-      dispatch(opts, handler) {
-        if (!handler || typeof handler !== "object") {
-          throw new InvalidArgumentError("handler must be an object");
-        }
-        handler = UnwrapHandler.unwrap(handler);
-        try {
-          if (!opts || typeof opts !== "object") {
-            throw new InvalidArgumentError("opts must be an object.");
-          }
-          if (this[kDestroyed] || this[kOnDestroyed]) {
-            throw new ClientDestroyedError();
-          }
-          if (this[kClosed]) {
-            throw new ClientClosedError();
-          }
-          return this[kDispatch](opts, handler);
-        } catch (err) {
-          if (typeof handler.onError !== "function") {
-            throw err;
-          }
-          handler.onError(err);
-          return false;
-        }
-      }
-    };
-    module2.exports = DispatcherBase;
-  }
-});
-
-// src/mock-agent/pool.cjs
-var require_pool = __commonJS({
-  "src/mock-agent/pool.cjs"(exports2, module2) {
-    var assert = require("node:assert");
-    module2.exports = class Pool {
-      constructor() {
-        assert.fail("Pool is not implemented in worker");
-      }
-    };
-  }
-});
-
-// src/mock-agent/dispatcher.cjs
-var require_dispatcher2 = __commonJS({
-  "src/mock-agent/dispatcher.cjs"(exports2, module2) {
-    "use strict";
-    var dispatcher;
-    module2.exports = {
-      getDispatcher() {
-        return dispatcher;
-      },
-      setDispatcher(newDispatcher) {
-        dispatcher = newDispatcher;
-      }
-    };
-  }
-});
-
-// src/mock-agent/client.cjs
-var require_client = __commonJS({
-  "src/mock-agent/client.cjs"(exports2, module2) {
-    var assert = require("node:assert");
-    var DispatcherBase = require_dispatcher_base();
-    var { kDispatch, kClose, kDestroy } = require_symbols();
-    var { getDispatcher } = require_dispatcher2();
-    module2.exports = class Client extends DispatcherBase {
-      [kDispatch](opts, handler) {
-        const dispatcher = getDispatcher();
-        if (dispatcher === void 0) {
-          assert.fail("setDispatcher() must be called before Client#[kDispatch]()");
-        }
-        dispatcher(opts, handler);
-        return true;
-      }
-      async [kClose]() {
-      }
-      async [kDestroy](_err) {
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/dispatcher/agent.js
-var require_agent = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/dispatcher/agent.js"(exports2, module2) {
-    "use strict";
-    var { InvalidArgumentError, MaxOriginsReachedError } = require_errors();
-    var { kClients: kClients2, kRunning, kClose, kDestroy, kDispatch, kUrl } = require_symbols();
-    var DispatcherBase = require_dispatcher_base();
-    var Pool = require_pool();
-    var Client = require_client();
-    var util = require_util();
-    var kOnConnect = /* @__PURE__ */ Symbol("onConnect");
-    var kOnDisconnect = /* @__PURE__ */ Symbol("onDisconnect");
-    var kOnConnectionError = /* @__PURE__ */ Symbol("onConnectionError");
-    var kOnDrain = /* @__PURE__ */ Symbol("onDrain");
-    var kFactory = /* @__PURE__ */ Symbol("factory");
-    var kOptions = /* @__PURE__ */ Symbol("options");
-    var kOrigins = /* @__PURE__ */ Symbol("origins");
-    function defaultFactory(origin, opts) {
-      return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
-    }
-    var Agent = class extends DispatcherBase {
-      constructor({ factory = defaultFactory, maxOrigins = Infinity, connect, ...options } = {}) {
-        if (typeof factory !== "function") {
-          throw new InvalidArgumentError("factory must be a function.");
-        }
-        if (connect != null && typeof connect !== "function" && typeof connect !== "object") {
-          throw new InvalidArgumentError("connect must be a function or an object");
-        }
-        if (typeof maxOrigins !== "number" || Number.isNaN(maxOrigins) || maxOrigins <= 0) {
-          throw new InvalidArgumentError("maxOrigins must be a number greater than 0");
-        }
-        super();
-        if (connect && typeof connect !== "function") {
-          connect = { ...connect };
-        }
-        this[kOptions] = { ...util.deepClone(options), maxOrigins, connect };
-        this[kFactory] = factory;
-        this[kClients2] = /* @__PURE__ */ new Map();
-        this[kOrigins] = /* @__PURE__ */ new Set();
-        this[kOnDrain] = (origin, targets) => {
-          this.emit("drain", origin, [this, ...targets]);
-        };
-        this[kOnConnect] = (origin, targets) => {
-          this.emit("connect", origin, [this, ...targets]);
-        };
-        this[kOnDisconnect] = (origin, targets, err) => {
-          this.emit("disconnect", origin, [this, ...targets], err);
-        };
-        this[kOnConnectionError] = (origin, targets, err) => {
-          this.emit("connectionError", origin, [this, ...targets], err);
-        };
-      }
-      get [kRunning]() {
-        let ret = 0;
-        for (const { dispatcher } of this[kClients2].values()) {
-          ret += dispatcher[kRunning];
-        }
-        return ret;
-      }
-      [kDispatch](opts, handler) {
-        let key;
-        if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) {
-          key = String(opts.origin);
-        } else {
-          throw new InvalidArgumentError("opts.origin must be a non-empty string or URL.");
-        }
-        if (this[kOrigins].size >= this[kOptions].maxOrigins && !this[kOrigins].has(key)) {
-          throw new MaxOriginsReachedError();
-        }
-        const result = this[kClients2].get(key);
-        let dispatcher = result && result.dispatcher;
-        if (!dispatcher) {
-          const closeClientIfUnused = (connected) => {
-            const result2 = this[kClients2].get(key);
-            if (result2) {
-              if (connected) result2.count -= 1;
-              if (result2.count <= 0) {
-                this[kClients2].delete(key);
-                result2.dispatcher.close();
-              }
-              this[kOrigins].delete(key);
-            }
-          };
-          dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", (origin, targets) => {
-            const result2 = this[kClients2].get(key);
-            if (result2) {
-              result2.count += 1;
-            }
-            this[kOnConnect](origin, targets);
-          }).on("disconnect", (origin, targets, err) => {
-            closeClientIfUnused(true);
-            this[kOnDisconnect](origin, targets, err);
-          }).on("connectionError", (origin, targets, err) => {
-            closeClientIfUnused(false);
-            this[kOnConnectionError](origin, targets, err);
-          });
-          this[kClients2].set(key, { count: 0, dispatcher });
-          this[kOrigins].add(key);
-        }
-        return dispatcher.dispatch(opts, handler);
-      }
-      [kClose]() {
-        const closePromises = [];
-        for (const { dispatcher } of this[kClients2].values()) {
-          closePromises.push(dispatcher.close());
-        }
-        this[kClients2].clear();
-        return Promise.all(closePromises);
-      }
-      [kDestroy](err) {
-        const destroyPromises = [];
-        for (const { dispatcher } of this[kClients2].values()) {
-          destroyPromises.push(dispatcher.destroy(err));
-        }
-        this[kClients2].clear();
-        return Promise.all(destroyPromises);
-      }
-      get stats() {
-        const allClientStats = {};
-        for (const { dispatcher } of this[kClients2].values()) {
-          if (dispatcher.stats) {
-            allClientStats[dispatcher[kUrl].origin] = dispatcher.stats;
-          }
-        }
-        return allClientStats;
-      }
-    };
-    module2.exports = Agent;
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-symbols.js
-var require_mock_symbols = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-symbols.js"(exports2, module2) {
-    "use strict";
-    module2.exports = {
-      kAgent: /* @__PURE__ */ Symbol("agent"),
-      kOptions: /* @__PURE__ */ Symbol("options"),
-      kFactory: /* @__PURE__ */ Symbol("factory"),
-      kDispatches: /* @__PURE__ */ Symbol("dispatches"),
-      kDispatchKey: /* @__PURE__ */ Symbol("dispatch key"),
-      kDefaultHeaders: /* @__PURE__ */ Symbol("default headers"),
-      kDefaultTrailers: /* @__PURE__ */ Symbol("default trailers"),
-      kContentLength: /* @__PURE__ */ Symbol("content length"),
-      kMockAgent: /* @__PURE__ */ Symbol("mock agent"),
-      kMockAgentSet: /* @__PURE__ */ Symbol("mock agent set"),
-      kMockAgentGet: /* @__PURE__ */ Symbol("mock agent get"),
-      kMockDispatch: /* @__PURE__ */ Symbol("mock dispatch"),
-      kClose: /* @__PURE__ */ Symbol("close"),
-      kOriginalClose: /* @__PURE__ */ Symbol("original agent close"),
-      kOriginalDispatch: /* @__PURE__ */ Symbol("original dispatch"),
-      kOrigin: /* @__PURE__ */ Symbol("origin"),
-      kIsMockActive: /* @__PURE__ */ Symbol("is mock active"),
-      kNetConnect: /* @__PURE__ */ Symbol("net connect"),
-      kGetNetConnect: /* @__PURE__ */ Symbol("get net connect"),
-      kConnected: /* @__PURE__ */ Symbol("connected"),
-      kIgnoreTrailingSlash: /* @__PURE__ */ Symbol("ignore trailing slash"),
-      kMockAgentMockCallHistoryInstance: /* @__PURE__ */ Symbol("mock agent mock call history name"),
-      kMockAgentRegisterCallHistory: /* @__PURE__ */ Symbol("mock agent register mock call history"),
-      kMockAgentAddCallHistoryLog: /* @__PURE__ */ Symbol("mock agent add call history log"),
-      kMockAgentIsCallHistoryEnabled: /* @__PURE__ */ Symbol("mock agent is call history enabled"),
-      kMockAgentAcceptsNonStandardSearchParameters: /* @__PURE__ */ Symbol("mock agent accepts non standard search parameters"),
-      kMockCallHistoryAddLog: /* @__PURE__ */ Symbol("mock call history add log")
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-errors.js
-var require_mock_errors = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-errors.js"(exports2, module2) {
-    "use strict";
-    var { UndiciError } = require_errors();
-    var kMockNotMatchedError = /* @__PURE__ */ Symbol.for("undici.error.UND_MOCK_ERR_MOCK_NOT_MATCHED");
-    var MockNotMatchedError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "MockNotMatchedError";
-        this.message = message || "The request does not match any registered mock dispatches";
-        this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kMockNotMatchedError] === true;
-      }
-      get [kMockNotMatchedError]() {
-        return true;
-      }
-    };
-    module2.exports = {
-      MockNotMatchedError
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-utils.js
-var require_mock_utils = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-utils.js"(exports2, module2) {
-    "use strict";
-    var { MockNotMatchedError } = require_mock_errors();
-    var {
-      kDispatches: kDispatches2,
-      kMockAgent,
-      kOriginalDispatch,
-      kOrigin,
-      kGetNetConnect
-    } = require_mock_symbols();
-    var { serializePathWithQuery } = require_util();
-    var { STATUS_CODES } = require("node:http");
-    var {
-      types: {
-        isPromise
-      }
-    } = require("node:util");
-    var { InvalidArgumentError } = require_errors();
-    function matchValue(match, value) {
-      if (typeof match === "string") {
-        return match === value;
-      }
-      if (match instanceof RegExp) {
-        return match.test(value);
-      }
-      if (typeof match === "function") {
-        return match(value) === true;
-      }
-      return false;
-    }
-    function lowerCaseEntries(headers) {
-      return Object.fromEntries(
-        Object.entries(headers).map(([headerName, headerValue]) => {
-          return [headerName.toLocaleLowerCase(), headerValue];
-        })
-      );
-    }
-    function getHeaderByName(headers, key) {
-      if (Array.isArray(headers)) {
-        for (let i = 0; i < headers.length; i += 2) {
-          if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) {
-            return headers[i + 1];
-          }
-        }
-        return void 0;
-      } else if (typeof headers.get === "function") {
-        return headers.get(key);
-      } else {
-        return lowerCaseEntries(headers)[key.toLocaleLowerCase()];
-      }
-    }
-    function buildHeadersFromArray(headers) {
-      const clone = headers.slice();
-      const entries = [];
-      for (let index = 0; index < clone.length; index += 2) {
-        entries.push([clone[index], clone[index + 1]]);
-      }
-      return Object.fromEntries(entries);
-    }
-    function matchHeaders(mockDispatch2, headers) {
-      if (typeof mockDispatch2.headers === "function") {
-        if (Array.isArray(headers)) {
-          headers = buildHeadersFromArray(headers);
-        }
-        return mockDispatch2.headers(headers ? lowerCaseEntries(headers) : {});
-      }
-      if (typeof mockDispatch2.headers === "undefined") {
-        return true;
-      }
-      if (typeof headers !== "object" || typeof mockDispatch2.headers !== "object") {
-        return false;
-      }
-      for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch2.headers)) {
-        const headerValue = getHeaderByName(headers, matchHeaderName);
-        if (!matchValue(matchHeaderValue, headerValue)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    function normalizeSearchParams(query) {
-      if (typeof query !== "string") {
-        return query;
-      }
-      const originalQp = new URLSearchParams(query);
-      const normalizedQp = new URLSearchParams();
-      for (let [key, value] of originalQp.entries()) {
-        key = key.replace("[]", "");
-        const valueRepresentsString = /^(['"]).*\1$/.test(value);
-        if (valueRepresentsString) {
-          normalizedQp.append(key, value);
-          continue;
-        }
-        if (value.includes(",")) {
-          const values = value.split(",");
-          for (const v of values) {
-            normalizedQp.append(key, v);
-          }
-          continue;
-        }
-        normalizedQp.append(key, value);
-      }
-      return normalizedQp;
-    }
-    function safeUrl(path) {
-      if (typeof path !== "string") {
-        return path;
-      }
-      const pathSegments = path.split("?", 3);
-      if (pathSegments.length !== 2) {
-        return path;
-      }
-      const qp = new URLSearchParams(pathSegments.pop());
-      qp.sort();
-      return [...pathSegments, qp.toString()].join("?");
-    }
-    function matchKey(mockDispatch2, { path, method, body, headers }) {
-      const pathMatch = matchValue(mockDispatch2.path, path);
-      const methodMatch = matchValue(mockDispatch2.method, method);
-      const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
-      const headersMatch = matchHeaders(mockDispatch2, headers);
-      return pathMatch && methodMatch && bodyMatch && headersMatch;
-    }
-    function getResponseData(data) {
-      if (Buffer.isBuffer(data)) {
-        return data;
-      } else if (data instanceof Uint8Array) {
-        return data;
-      } else if (data instanceof ArrayBuffer) {
-        return data;
-      } else if (typeof data === "object") {
-        return JSON.stringify(data);
-      } else if (data) {
-        return data.toString();
-      } else {
-        return "";
-      }
-    }
-    function getMockDispatch(mockDispatches, key) {
-      const basePath = key.query ? serializePathWithQuery(key.path, key.query) : key.path;
-      const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
-      const resolvedPathWithoutTrailingSlash = removeTrailingSlash(resolvedPath);
-      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path, ignoreTrailingSlash }) => {
-        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path), resolvedPath);
-      });
-      if (matchedMockDispatches.length === 0) {
-        throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
-      }
-      matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method));
-      if (matchedMockDispatches.length === 0) {
-        throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}' on path '${resolvedPath}'`);
-      }
-      matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true);
-      if (matchedMockDispatches.length === 0) {
-        throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}' on path '${resolvedPath}'`);
-      }
-      matchedMockDispatches = matchedMockDispatches.filter((mockDispatch2) => matchHeaders(mockDispatch2, key.headers));
-      if (matchedMockDispatches.length === 0) {
-        const headers = typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers;
-        throw new MockNotMatchedError(`Mock dispatch not matched for headers '${headers}' on path '${resolvedPath}'`);
-      }
-      return matchedMockDispatches[0];
-    }
-    function addMockDispatch(mockDispatches, key, data, opts) {
-      const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false, ...opts };
-      const replyData = typeof data === "function" ? { callback: data } : { ...data };
-      const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } };
-      mockDispatches.push(newMockDispatch);
-      return newMockDispatch;
-    }
-    function deleteMockDispatch(mockDispatches, key) {
-      const index = mockDispatches.findIndex((dispatch) => {
-        if (!dispatch.consumed) {
-          return false;
-        }
-        return matchKey(dispatch, key);
-      });
-      if (index !== -1) {
-        mockDispatches.splice(index, 1);
-      }
-    }
-    function removeTrailingSlash(path) {
-      while (path.endsWith("/")) {
-        path = path.slice(0, -1);
-      }
-      if (path.length === 0) {
-        path = "/";
-      }
-      return path;
-    }
-    function buildKey(opts) {
-      const { path, method, body, headers, query } = opts;
-      return {
-        path,
-        method,
-        body,
-        headers,
-        query
-      };
-    }
-    function generateKeyValues(data) {
-      const keys = Object.keys(data);
-      const result = [];
-      for (let i = 0; i < keys.length; ++i) {
-        const key = keys[i];
-        const value = data[key];
-        const name = Buffer.from(`${key}`);
-        if (Array.isArray(value)) {
-          for (let j = 0; j < value.length; ++j) {
-            result.push(name, Buffer.from(`${value[j]}`));
-          }
-        } else {
-          result.push(name, Buffer.from(`${value}`));
-        }
-      }
-      return result;
-    }
-    function getStatusText(statusCode) {
-      return STATUS_CODES[statusCode] || "unknown";
-    }
-    async function getResponse(body) {
-      const buffers = [];
-      for await (const data of body) {
-        buffers.push(data);
-      }
-      return Buffer.concat(buffers).toString("utf8");
-    }
-    function mockDispatch(opts, handler) {
-      const key = buildKey(opts);
-      const mockDispatch2 = getMockDispatch(this[kDispatches2], key);
-      mockDispatch2.timesInvoked++;
-      if (mockDispatch2.data.callback) {
-        mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) };
-      }
-      const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch2;
-      const { timesInvoked, times } = mockDispatch2;
-      mockDispatch2.consumed = !persist && timesInvoked >= times;
-      mockDispatch2.pending = timesInvoked < times;
-      if (error !== null) {
-        deleteMockDispatch(this[kDispatches2], key);
-        handler.onError(error);
-        return true;
-      }
-      if (typeof delay === "number" && delay > 0) {
-        setTimeout(() => {
-          handleReply(this[kDispatches2]);
-        }, delay);
-      } else {
-        handleReply(this[kDispatches2]);
-      }
-      function handleReply(mockDispatches, _data = data) {
-        const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers;
-        const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data;
-        if (isPromise(body)) {
-          return body.then((newData) => handleReply(mockDispatches, newData));
-        }
-        const responseData = getResponseData(body);
-        const responseHeaders = generateKeyValues(headers);
-        const responseTrailers = generateKeyValues(trailers);
-        handler.onConnect?.((err) => handler.onError(err), null);
-        handler.onHeaders?.(statusCode, responseHeaders, resume, getStatusText(statusCode));
-        handler.onData?.(Buffer.from(responseData));
-        handler.onComplete?.(responseTrailers);
-        deleteMockDispatch(mockDispatches, key);
-      }
-      function resume() {
-      }
-      return true;
-    }
-    function buildMockDispatch() {
-      const agent = this[kMockAgent];
-      const origin = this[kOrigin];
-      const originalDispatch = this[kOriginalDispatch];
-      return function dispatch(opts, handler) {
-        if (agent.isMockActive) {
-          try {
-            mockDispatch.call(this, opts, handler);
-          } catch (error) {
-            if (error.code === "UND_MOCK_ERR_MOCK_NOT_MATCHED") {
-              const netConnect = agent[kGetNetConnect]();
-              if (netConnect === false) {
-                throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`);
-              }
-              if (checkNetConnect(netConnect, origin)) {
-                originalDispatch.call(this, opts, handler);
-              } else {
-                throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`);
-              }
-            } else {
-              throw error;
-            }
-          }
-        } else {
-          originalDispatch.call(this, opts, handler);
-        }
-      };
-    }
-    function checkNetConnect(netConnect, origin) {
-      const url = new URL(origin);
-      if (netConnect === true) {
-        return true;
-      } else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) {
-        return true;
-      }
-      return false;
-    }
-    function buildAndValidateMockOptions(opts) {
-      const { agent, ...mockOptions } = opts;
-      if ("enableCallHistory" in mockOptions && typeof mockOptions.enableCallHistory !== "boolean") {
-        throw new InvalidArgumentError("options.enableCallHistory must to be a boolean");
-      }
-      if ("acceptNonStandardSearchParameters" in mockOptions && typeof mockOptions.acceptNonStandardSearchParameters !== "boolean") {
-        throw new InvalidArgumentError("options.acceptNonStandardSearchParameters must to be a boolean");
-      }
-      if ("ignoreTrailingSlash" in mockOptions && typeof mockOptions.ignoreTrailingSlash !== "boolean") {
-        throw new InvalidArgumentError("options.ignoreTrailingSlash must to be a boolean");
-      }
-      return mockOptions;
-    }
-    module2.exports = {
-      getResponseData,
-      getMockDispatch,
-      addMockDispatch,
-      deleteMockDispatch,
-      buildKey,
-      generateKeyValues,
-      matchValue,
-      getResponse,
-      getStatusText,
-      mockDispatch,
-      buildMockDispatch,
-      checkNetConnect,
-      buildAndValidateMockOptions,
-      getHeaderByName,
-      buildHeadersFromArray,
-      normalizeSearchParams
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-interceptor.js
-var require_mock_interceptor = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-interceptor.js"(exports2, module2) {
-    "use strict";
-    var { getResponseData, buildKey, addMockDispatch } = require_mock_utils();
-    var {
-      kDispatches: kDispatches2,
-      kDispatchKey,
-      kDefaultHeaders,
-      kDefaultTrailers,
-      kContentLength,
-      kMockDispatch,
-      kIgnoreTrailingSlash
-    } = require_mock_symbols();
-    var { InvalidArgumentError } = require_errors();
-    var { serializePathWithQuery } = require_util();
-    var MockScope = class {
-      constructor(mockDispatch) {
-        this[kMockDispatch] = mockDispatch;
-      }
-      /**
-       * Delay a reply by a set amount in ms.
-       */
-      delay(waitInMs) {
-        if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) {
-          throw new InvalidArgumentError("waitInMs must be a valid integer > 0");
-        }
-        this[kMockDispatch].delay = waitInMs;
-        return this;
-      }
-      /**
-       * For a defined reply, never mark as consumed.
-       */
-      persist() {
-        this[kMockDispatch].persist = true;
-        return this;
-      }
-      /**
-       * Allow one to define a reply for a set amount of matching requests.
-       */
-      times(repeatTimes) {
-        if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) {
-          throw new InvalidArgumentError("repeatTimes must be a valid integer > 0");
-        }
-        this[kMockDispatch].times = repeatTimes;
-        return this;
-      }
-    };
-    var MockInterceptor = class {
-      constructor(opts, mockDispatches) {
-        if (typeof opts !== "object") {
-          throw new InvalidArgumentError("opts must be an object");
-        }
-        if (typeof opts.path === "undefined") {
-          throw new InvalidArgumentError("opts.path must be defined");
-        }
-        if (typeof opts.method === "undefined") {
-          opts.method = "GET";
-        }
-        if (typeof opts.path === "string") {
-          if (opts.query) {
-            opts.path = serializePathWithQuery(opts.path, opts.query);
-          } else {
-            const parsedURL = new URL(opts.path, "data://");
-            opts.path = parsedURL.pathname + parsedURL.search;
-          }
-        }
-        if (typeof opts.method === "string") {
-          opts.method = opts.method.toUpperCase();
-        }
-        this[kDispatchKey] = buildKey(opts);
-        this[kDispatches2] = mockDispatches;
-        this[kIgnoreTrailingSlash] = opts.ignoreTrailingSlash ?? false;
-        this[kDefaultHeaders] = {};
-        this[kDefaultTrailers] = {};
-        this[kContentLength] = false;
-      }
-      createMockScopeDispatchData({ statusCode, data, responseOptions }) {
-        const responseData = getResponseData(data);
-        const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {};
-        const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers };
-        const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers };
-        return { statusCode, data, headers, trailers };
-      }
-      validateReplyParameters(replyParameters) {
-        if (typeof replyParameters.statusCode === "undefined") {
-          throw new InvalidArgumentError("statusCode must be defined");
-        }
-        if (typeof replyParameters.responseOptions !== "object" || replyParameters.responseOptions === null) {
-          throw new InvalidArgumentError("responseOptions must be an object");
-        }
-      }
-      /**
-       * Mock an undici request with a defined reply.
-       */
-      reply(replyOptionsCallbackOrStatusCode) {
-        if (typeof replyOptionsCallbackOrStatusCode === "function") {
-          const wrappedDefaultsCallback = (opts) => {
-            const resolvedData = replyOptionsCallbackOrStatusCode(opts);
-            if (typeof resolvedData !== "object" || resolvedData === null) {
-              throw new InvalidArgumentError("reply options callback must return an object");
-            }
-            const replyParameters2 = { data: "", responseOptions: {}, ...resolvedData };
-            this.validateReplyParameters(replyParameters2);
-            return {
-              ...this.createMockScopeDispatchData(replyParameters2)
-            };
-          };
-          const newMockDispatch2 = addMockDispatch(this[kDispatches2], this[kDispatchKey], wrappedDefaultsCallback, { ignoreTrailingSlash: this[kIgnoreTrailingSlash] });
-          return new MockScope(newMockDispatch2);
-        }
-        const replyParameters = {
-          statusCode: replyOptionsCallbackOrStatusCode,
-          data: arguments[1] === void 0 ? "" : arguments[1],
-          responseOptions: arguments[2] === void 0 ? {} : arguments[2]
-        };
-        this.validateReplyParameters(replyParameters);
-        const dispatchData = this.createMockScopeDispatchData(replyParameters);
-        const newMockDispatch = addMockDispatch(this[kDispatches2], this[kDispatchKey], dispatchData, { ignoreTrailingSlash: this[kIgnoreTrailingSlash] });
-        return new MockScope(newMockDispatch);
-      }
-      /**
-       * Mock an undici request with a defined error.
-       */
-      replyWithError(error) {
-        if (typeof error === "undefined") {
-          throw new InvalidArgumentError("error must be defined");
-        }
-        const newMockDispatch = addMockDispatch(this[kDispatches2], this[kDispatchKey], { error }, { ignoreTrailingSlash: this[kIgnoreTrailingSlash] });
-        return new MockScope(newMockDispatch);
-      }
-      /**
-       * Set default reply headers on the interceptor for subsequent replies
-       */
-      defaultReplyHeaders(headers) {
-        if (typeof headers === "undefined") {
-          throw new InvalidArgumentError("headers must be defined");
-        }
-        this[kDefaultHeaders] = headers;
-        return this;
-      }
-      /**
-       * Set default reply trailers on the interceptor for subsequent replies
-       */
-      defaultReplyTrailers(trailers) {
-        if (typeof trailers === "undefined") {
-          throw new InvalidArgumentError("trailers must be defined");
-        }
-        this[kDefaultTrailers] = trailers;
-        return this;
-      }
-      /**
-       * Set reply content length header for replies on the interceptor
-       */
-      replyContentLength() {
-        this[kContentLength] = true;
-        return this;
-      }
-    };
-    module2.exports.MockInterceptor = MockInterceptor;
-    module2.exports.MockScope = MockScope;
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-client.js
-var require_mock_client = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-client.js"(exports2, module2) {
-    "use strict";
-    var { promisify } = require("node:util");
-    var Client = require_client();
-    var { buildMockDispatch } = require_mock_utils();
-    var {
-      kDispatches: kDispatches2,
-      kMockAgent,
-      kClose,
-      kOriginalClose,
-      kOrigin,
-      kOriginalDispatch,
-      kConnected,
-      kIgnoreTrailingSlash
-    } = require_mock_symbols();
-    var { MockInterceptor } = require_mock_interceptor();
-    var Symbols = require_symbols();
-    var { InvalidArgumentError } = require_errors();
-    var MockClient = class extends Client {
-      constructor(origin, opts) {
-        if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
-          throw new InvalidArgumentError("Argument opts.agent must implement Agent");
-        }
-        super(origin, opts);
-        this[kMockAgent] = opts.agent;
-        this[kOrigin] = origin;
-        this[kIgnoreTrailingSlash] = opts.ignoreTrailingSlash ?? false;
-        this[kDispatches2] = [];
-        this[kConnected] = 1;
-        this[kOriginalDispatch] = this.dispatch;
-        this[kOriginalClose] = this.close.bind(this);
-        this.dispatch = buildMockDispatch.call(this);
-        this.close = this[kClose];
-      }
-      get [Symbols.kConnected]() {
-        return this[kConnected];
-      }
-      /**
-       * Sets up the base interceptor for mocking replies from undici.
-       */
-      intercept(opts) {
-        return new MockInterceptor(
-          opts && { ignoreTrailingSlash: this[kIgnoreTrailingSlash], ...opts },
-          this[kDispatches2]
-        );
-      }
-      cleanMocks() {
-        this[kDispatches2] = [];
-      }
-      async [kClose]() {
-        await promisify(this[kOriginalClose])();
-        this[kConnected] = 0;
-        this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
-      }
-    };
-    module2.exports = MockClient;
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-pool.js
-var require_mock_pool = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-pool.js"(exports2, module2) {
-    "use strict";
-    var { promisify } = require("node:util");
-    var Pool = require_pool();
-    var { buildMockDispatch } = require_mock_utils();
-    var {
-      kDispatches: kDispatches2,
-      kMockAgent,
-      kClose,
-      kOriginalClose,
-      kOrigin,
-      kOriginalDispatch,
-      kConnected,
-      kIgnoreTrailingSlash
-    } = require_mock_symbols();
-    var { MockInterceptor } = require_mock_interceptor();
-    var Symbols = require_symbols();
-    var { InvalidArgumentError } = require_errors();
-    var MockPool = class extends Pool {
-      constructor(origin, opts) {
-        if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
-          throw new InvalidArgumentError("Argument opts.agent must implement Agent");
-        }
-        super(origin, opts);
-        this[kMockAgent] = opts.agent;
-        this[kOrigin] = origin;
-        this[kIgnoreTrailingSlash] = opts.ignoreTrailingSlash ?? false;
-        this[kDispatches2] = [];
-        this[kConnected] = 1;
-        this[kOriginalDispatch] = this.dispatch;
-        this[kOriginalClose] = this.close.bind(this);
-        this.dispatch = buildMockDispatch.call(this);
-        this.close = this[kClose];
-      }
-      get [Symbols.kConnected]() {
-        return this[kConnected];
-      }
-      /**
-       * Sets up the base interceptor for mocking replies from undici.
-       */
-      intercept(opts) {
-        return new MockInterceptor(
-          opts && { ignoreTrailingSlash: this[kIgnoreTrailingSlash], ...opts },
-          this[kDispatches2]
-        );
-      }
-      cleanMocks() {
-        this[kDispatches2] = [];
-      }
-      async [kClose]() {
-        await promisify(this[kOriginalClose])();
-        this[kConnected] = 0;
-        this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
-      }
-    };
-    module2.exports = MockPool;
-  }
-});
-
-// src/mock-agent/pending-interceptor-formatter.cjs
-var require_pending_interceptor_formatter = __commonJS({
-  "src/mock-agent/pending-interceptor-formatter.cjs"(exports2, module2) {
-    var util = require("node:util");
-    module2.exports = class PendingInterceptorsFormatter {
-      constructor({ disableColors } = {}) {
-        this.inspectOptions = {
-          breakLength: Infinity,
-          colors: !disableColors && !process.env.CI
-        };
-      }
-      format(pendingInterceptors) {
-        const formatted = pendingInterceptors.map(
-          ({
-            method,
-            path,
-            data: { statusCode },
-            persist,
-            times,
-            timesInvoked,
-            origin
-          }) => {
-            const meta = {
-              persist: Boolean(persist),
-              invoked: timesInvoked,
-              remaining: persist ? Infinity : times - timesInvoked
-            };
-            const inspectedMeta = util.inspect(meta, this.inspectOptions);
-            return `- ${method} ${origin}${path} ${statusCode} ${inspectedMeta}`;
-          }
-        );
-        return formatted.join("\n");
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-call-history.js
-var require_mock_call_history = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-call-history.js"(exports2, module2) {
-    "use strict";
-    var { kMockCallHistoryAddLog } = require_mock_symbols();
-    var { InvalidArgumentError } = require_errors();
-    function handleFilterCallsWithOptions(criteria, options, handler, store) {
-      switch (options.operator) {
-        case "OR":
-          store.push(...handler(criteria));
-          return store;
-        case "AND":
-          return handler.call({ logs: store }, criteria);
-        default:
-          throw new InvalidArgumentError("options.operator must to be a case insensitive string equal to 'OR' or 'AND'");
-      }
-    }
-    function buildAndValidateFilterCallsOptions(options = {}) {
-      const finalOptions = {};
-      if ("operator" in options) {
-        if (typeof options.operator !== "string" || options.operator.toUpperCase() !== "OR" && options.operator.toUpperCase() !== "AND") {
-          throw new InvalidArgumentError("options.operator must to be a case insensitive string equal to 'OR' or 'AND'");
-        }
-        return {
-          ...finalOptions,
-          operator: options.operator.toUpperCase()
-        };
-      }
-      return finalOptions;
-    }
-    function makeFilterCalls(parameterName) {
-      return (parameterValue) => {
-        if (typeof parameterValue === "string" || parameterValue == null) {
-          return this.logs.filter((log) => {
-            return log[parameterName] === parameterValue;
-          });
-        }
-        if (parameterValue instanceof RegExp) {
-          return this.logs.filter((log) => {
-            return parameterValue.test(log[parameterName]);
-          });
-        }
-        throw new InvalidArgumentError(`${parameterName} parameter should be one of string, regexp, undefined or null`);
-      };
-    }
-    function computeUrlWithMaybeSearchParameters(requestInit) {
-      try {
-        const url = new URL(requestInit.path, requestInit.origin);
-        if (url.search.length !== 0) {
-          return url;
-        }
-        url.search = new URLSearchParams(requestInit.query).toString();
-        return url;
-      } catch (error) {
-        throw new InvalidArgumentError("An error occurred when computing MockCallHistoryLog.url", { cause: error });
-      }
-    }
-    var MockCallHistoryLog = class {
-      constructor(requestInit = {}) {
-        this.body = requestInit.body;
-        this.headers = requestInit.headers;
-        this.method = requestInit.method;
-        const url = computeUrlWithMaybeSearchParameters(requestInit);
-        this.fullUrl = url.toString();
-        this.origin = url.origin;
-        this.path = url.pathname;
-        this.searchParams = Object.fromEntries(url.searchParams);
-        this.protocol = url.protocol;
-        this.host = url.host;
-        this.port = url.port;
-        this.hash = url.hash;
-      }
-      toMap() {
-        return /* @__PURE__ */ new Map(
-          [
-            ["protocol", this.protocol],
-            ["host", this.host],
-            ["port", this.port],
-            ["origin", this.origin],
-            ["path", this.path],
-            ["hash", this.hash],
-            ["searchParams", this.searchParams],
-            ["fullUrl", this.fullUrl],
-            ["method", this.method],
-            ["body", this.body],
-            ["headers", this.headers]
-          ]
-        );
-      }
-      toString() {
-        const options = { betweenKeyValueSeparator: "->", betweenPairSeparator: "|" };
-        let result = "";
-        this.toMap().forEach((value, key) => {
-          if (typeof value === "string" || value === void 0 || value === null) {
-            result = `${result}${key}${options.betweenKeyValueSeparator}${value}${options.betweenPairSeparator}`;
-          }
-          if (typeof value === "object" && value !== null || Array.isArray(value)) {
-            result = `${result}${key}${options.betweenKeyValueSeparator}${JSON.stringify(value)}${options.betweenPairSeparator}`;
-          }
-        });
-        return result.slice(0, -1);
-      }
-    };
-    var MockCallHistory = class {
-      logs = [];
-      calls() {
-        return this.logs;
-      }
-      firstCall() {
-        return this.logs.at(0);
-      }
-      lastCall() {
-        return this.logs.at(-1);
-      }
-      nthCall(number) {
-        if (typeof number !== "number") {
-          throw new InvalidArgumentError("nthCall must be called with a number");
-        }
-        if (!Number.isInteger(number)) {
-          throw new InvalidArgumentError("nthCall must be called with an integer");
-        }
-        if (Math.sign(number) !== 1) {
-          throw new InvalidArgumentError("nthCall must be called with a positive value. use firstCall or lastCall instead");
-        }
-        return this.logs.at(number - 1);
-      }
-      filterCalls(criteria, options) {
-        if (this.logs.length === 0) {
-          return this.logs;
-        }
-        if (typeof criteria === "function") {
-          return this.logs.filter(criteria);
-        }
-        if (criteria instanceof RegExp) {
-          return this.logs.filter((log) => {
-            return criteria.test(log.toString());
-          });
-        }
-        if (typeof criteria === "object" && criteria !== null) {
-          if (Object.keys(criteria).length === 0) {
-            return this.logs;
-          }
-          const finalOptions = { operator: "OR", ...buildAndValidateFilterCallsOptions(options) };
-          let maybeDuplicatedLogsFiltered = [];
-          if ("protocol" in criteria) {
-            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.protocol, finalOptions, this.filterCallsByProtocol, maybeDuplicatedLogsFiltered);
-          }
-          if ("host" in criteria) {
-            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.host, finalOptions, this.filterCallsByHost, maybeDuplicatedLogsFiltered);
-          }
-          if ("port" in criteria) {
-            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.port, finalOptions, this.filterCallsByPort, maybeDuplicatedLogsFiltered);
-          }
-          if ("origin" in criteria) {
-            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.origin, finalOptions, this.filterCallsByOrigin, maybeDuplicatedLogsFiltered);
-          }
-          if ("path" in criteria) {
-            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.path, finalOptions, this.filterCallsByPath, maybeDuplicatedLogsFiltered);
-          }
-          if ("hash" in criteria) {
-            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.hash, finalOptions, this.filterCallsByHash, maybeDuplicatedLogsFiltered);
-          }
-          if ("fullUrl" in criteria) {
-            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.fullUrl, finalOptions, this.filterCallsByFullUrl, maybeDuplicatedLogsFiltered);
-          }
-          if ("method" in criteria) {
-            maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.method, finalOptions, this.filterCallsByMethod, maybeDuplicatedLogsFiltered);
-          }
-          const uniqLogsFiltered = [...new Set(maybeDuplicatedLogsFiltered)];
-          return uniqLogsFiltered;
-        }
-        throw new InvalidArgumentError("criteria parameter should be one of function, regexp, or object");
-      }
-      filterCallsByProtocol = makeFilterCalls.call(this, "protocol");
-      filterCallsByHost = makeFilterCalls.call(this, "host");
-      filterCallsByPort = makeFilterCalls.call(this, "port");
-      filterCallsByOrigin = makeFilterCalls.call(this, "origin");
-      filterCallsByPath = makeFilterCalls.call(this, "path");
-      filterCallsByHash = makeFilterCalls.call(this, "hash");
-      filterCallsByFullUrl = makeFilterCalls.call(this, "fullUrl");
-      filterCallsByMethod = makeFilterCalls.call(this, "method");
-      clear() {
-        this.logs = [];
-      }
-      [kMockCallHistoryAddLog](requestInit) {
-        const log = new MockCallHistoryLog(requestInit);
-        this.logs.push(log);
-        return log;
-      }
-      *[Symbol.iterator]() {
-        for (const log of this.calls()) {
-          yield log;
-        }
-      }
-    };
-    module2.exports.MockCallHistory = MockCallHistory;
-    module2.exports.MockCallHistoryLog = MockCallHistoryLog;
-  }
-});
-
-// ../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-agent.js
-var require_mock_agent = __commonJS({
-  "../../node_modules/.pnpm/undici@7.18.2/node_modules/undici/lib/mock/mock-agent.js"(exports2, module2) {
-    "use strict";
-    var { kClients: kClients2 } = require_symbols();
-    var Agent = require_agent();
-    var {
-      kAgent,
-      kMockAgentSet,
-      kMockAgentGet,
-      kDispatches: kDispatches2,
-      kIsMockActive: kIsMockActive2,
-      kNetConnect,
-      kGetNetConnect,
-      kOptions,
-      kFactory,
-      kMockAgentRegisterCallHistory,
-      kMockAgentIsCallHistoryEnabled,
-      kMockAgentAddCallHistoryLog,
-      kMockAgentMockCallHistoryInstance,
-      kMockAgentAcceptsNonStandardSearchParameters,
-      kMockCallHistoryAddLog,
-      kIgnoreTrailingSlash
-    } = require_mock_symbols();
-    var MockClient = require_mock_client();
-    var MockPool = require_mock_pool();
-    var { matchValue, normalizeSearchParams, buildAndValidateMockOptions } = require_mock_utils();
-    var { InvalidArgumentError, UndiciError } = require_errors();
-    var Dispatcher = require_dispatcher();
-    var PendingInterceptorsFormatter = require_pending_interceptor_formatter();
-    var { MockCallHistory } = require_mock_call_history();
-    var MockAgent2 = class extends Dispatcher {
-      constructor(opts = {}) {
-        super(opts);
-        const mockOptions = buildAndValidateMockOptions(opts);
-        this[kNetConnect] = true;
-        this[kIsMockActive2] = true;
-        this[kMockAgentIsCallHistoryEnabled] = mockOptions.enableCallHistory ?? false;
-        this[kMockAgentAcceptsNonStandardSearchParameters] = mockOptions.acceptNonStandardSearchParameters ?? false;
-        this[kIgnoreTrailingSlash] = mockOptions.ignoreTrailingSlash ?? false;
-        if (opts?.agent && typeof opts.agent.dispatch !== "function") {
-          throw new InvalidArgumentError("Argument opts.agent must implement Agent");
-        }
-        const agent = opts?.agent ? opts.agent : new Agent(opts);
-        this[kAgent] = agent;
-        this[kClients2] = agent[kClients2];
-        this[kOptions] = mockOptions;
-        if (this[kMockAgentIsCallHistoryEnabled]) {
-          this[kMockAgentRegisterCallHistory]();
-        }
-      }
-      get(origin) {
-        const originKey = this[kIgnoreTrailingSlash] ? origin.replace(/\/$/, "") : origin;
-        let dispatcher = this[kMockAgentGet](originKey);
-        if (!dispatcher) {
-          dispatcher = this[kFactory](originKey);
-          this[kMockAgentSet](originKey, dispatcher);
-        }
-        return dispatcher;
-      }
-      dispatch(opts, handler) {
-        this.get(opts.origin);
-        this[kMockAgentAddCallHistoryLog](opts);
-        const acceptNonStandardSearchParameters = this[kMockAgentAcceptsNonStandardSearchParameters];
-        const dispatchOpts = { ...opts };
-        if (acceptNonStandardSearchParameters && dispatchOpts.path) {
-          const [path, searchParams] = dispatchOpts.path.split("?");
-          const normalizedSearchParams = normalizeSearchParams(searchParams, acceptNonStandardSearchParameters);
-          dispatchOpts.path = `${path}?${normalizedSearchParams}`;
-        }
-        return this[kAgent].dispatch(dispatchOpts, handler);
-      }
-      async close() {
-        this.clearCallHistory();
-        await this[kAgent].close();
-        this[kClients2].clear();
-      }
-      deactivate() {
-        this[kIsMockActive2] = false;
-      }
-      activate() {
-        this[kIsMockActive2] = true;
-      }
-      enableNetConnect(matcher) {
-        if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) {
-          if (Array.isArray(this[kNetConnect])) {
-            this[kNetConnect].push(matcher);
-          } else {
-            this[kNetConnect] = [matcher];
-          }
-        } else if (typeof matcher === "undefined") {
-          this[kNetConnect] = true;
-        } else {
-          throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp.");
-        }
-      }
-      disableNetConnect() {
-        this[kNetConnect] = false;
-      }
-      enableCallHistory() {
-        this[kMockAgentIsCallHistoryEnabled] = true;
-        return this;
-      }
-      disableCallHistory() {
-        this[kMockAgentIsCallHistoryEnabled] = false;
-        return this;
-      }
-      getCallHistory() {
-        return this[kMockAgentMockCallHistoryInstance];
-      }
-      clearCallHistory() {
-        if (this[kMockAgentMockCallHistoryInstance] !== void 0) {
-          this[kMockAgentMockCallHistoryInstance].clear();
-        }
-      }
-      // This is required to bypass issues caused by using global symbols - see:
-      // https://github.com/nodejs/undici/issues/1447
-      get isMockActive() {
-        return this[kIsMockActive2];
-      }
-      [kMockAgentRegisterCallHistory]() {
-        if (this[kMockAgentMockCallHistoryInstance] === void 0) {
-          this[kMockAgentMockCallHistoryInstance] = new MockCallHistory();
-        }
-      }
-      [kMockAgentAddCallHistoryLog](opts) {
-        if (this[kMockAgentIsCallHistoryEnabled]) {
-          this[kMockAgentRegisterCallHistory]();
-          this[kMockAgentMockCallHistoryInstance][kMockCallHistoryAddLog](opts);
-        }
-      }
-      [kMockAgentSet](origin, dispatcher) {
-        this[kClients2].set(origin, { count: 0, dispatcher });
-      }
-      [kFactory](origin) {
-        const mockOptions = Object.assign({ agent: this }, this[kOptions]);
-        return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions);
-      }
-      [kMockAgentGet](origin) {
-        const result = this[kClients2].get(origin);
-        if (result?.dispatcher) {
-          return result.dispatcher;
-        }
-        if (typeof origin !== "string") {
-          const dispatcher = this[kFactory]("http://localhost:9999");
-          this[kMockAgentSet](origin, dispatcher);
-          return dispatcher;
-        }
-        for (const [keyMatcher, result2] of Array.from(this[kClients2])) {
-          if (result2 && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) {
-            const dispatcher = this[kFactory](origin);
-            this[kMockAgentSet](origin, dispatcher);
-            dispatcher[kDispatches2] = result2.dispatcher[kDispatches2];
-            return dispatcher;
-          }
-        }
-      }
-      [kGetNetConnect]() {
-        return this[kNetConnect];
-      }
-      pendingInterceptors() {
-        const mockAgentClients = this[kClients2];
-        return Array.from(mockAgentClients.entries()).flatMap(([origin, result]) => result.dispatcher[kDispatches2].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending);
-      }
-      assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) {
-        const pending = this.pendingInterceptors();
-        if (pending.length === 0) {
-          return;
-        }
-        throw new UndiciError(
-          pending.length === 1 ? `1 interceptor is pending:
-
-${pendingInterceptorsFormatter.format(pending)}`.trim() : `${pending.length} interceptors are pending:
-
-${pendingInterceptorsFormatter.format(pending)}`.trim()
-        );
-      }
-    };
-    module2.exports = MockAgent2;
-  }
-});
-
-// src/mock-agent/index.cjs
-globalThis.global = globalThis;
-process.versions = { node: "18.0.0" };
-var MockAgent = require_mock_agent();
-var { kClients } = require_symbols();
-var { kIsMockActive, kDispatches } = require_mock_symbols();
-var { setDispatcher } = require_dispatcher2();
-function isMockActive(agent) {
-  return agent[kIsMockActive];
-}
-function resetMockAgent(agent) {
-  agent.deactivate();
-  agent.enableNetConnect();
-  for (const mockClient of agent[kClients].values()) {
-    mockClient.dispatcher?.[kDispatches].splice(0);
-  }
-  agent.assertNoPendingInterceptors();
-}
-module.exports = {
-  MockAgent,
-  setDispatcher,
-  isMockActive,
-  resetMockAgent
-};
-//# sourceMappingURL=mock-agent.cjs.map