Function dispatch

deps/undici/undici.js:14350–14499

({ body })

      __name(onAborted, "onAborted");
      return response;
      function dispatch({ body }) {
        const url = requestCurrentURL(request);
        const agent = fetchParams.controller.dispatcher;
        const path = url.pathname + url.search;
        const hasTrailingQuestionMark = url.search.length === 0 && url.href[url.href.length - url.hash.length - 1] === "?";
        return dispatchWithProtocolPreference(body);
        function dispatchWithProtocolPreference(body2, allowH2) {
          return new Promise((resolve, reject) => agent.dispatch(
            {
              path: hasTrailingQuestionMark ? `${path}?` : path,
              origin: url.origin,
              method: request.method,
              body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body2,
              // Preserve the serialized fetch body for MockAgent net-connect fallthroughs.
              __mockAgentBodyForDispatch: body2,
              headers: request.headersList.entries,
              maxRedirections: 0,
              upgrade: request.mode === "websocket" ? "websocket" : void 0,
              ...allowH2 === false ? { allowH2 } : null
            },
            {
              body: null,
              abort: null,
              onRequestStart(controller) {
                const { connection } = fetchParams.controller;
                timingInfo.finalConnectionTimingInfo = clampAndCoarsenConnectionTimingInfo(void 0, timingInfo.postRedirectStartTime, fetchParams.crossOriginIsolatedCapability);
                const abort = /* @__PURE__ */ __name((reason) => controller.abort(reason), "abort");
                if (connection.destroyed) {
                  abort(new DOMException("The operation was aborted.", "AbortError"));
                } else {
                  fetchParams.controller.on("terminated", abort);
                  this.abort = connection.abort = abort;
                }
                timingInfo.finalNetworkRequestStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
              },
              onResponseStarted() {
                timingInfo.finalNetworkResponseStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
              },
              onResponseStart(controller, status, headers, statusText) {
                if (status < 200) {
                  return;
                }
                const rawHeaders = controller?.rawHeaders ?? [];
                const headersList = new HeadersList();
                appendHeadersListFromResponseHeaders(headersList, headers, rawHeaders);
                const location = headersList.get("location", true);
                this.body = new Readable({ read: /* @__PURE__ */ __name(() => controller.resume(), "read") });
                const willFollow = location && request.redirect === "follow" && redirectStatusSet.has(status);
                const decoders = [];
                if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) {
                  const contentEncoding = headersList.get("content-encoding", true);
                  const codings = contentEncoding ? contentEncoding.toLowerCase().split(",") : [];
                  const maxContentEncodings = 5;
                  if (codings.length > maxContentEncodings) {
                    reject(new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`));
                    return;
                  }
                  for (let i = codings.length - 1; i >= 0; --i) {