Function writeH2

deps/undici/undici.js:8919–9112

(client, request)

    }
    __name(setupUpgradeStream, "setupUpgradeStream");
    function writeH2(client, request) {
      const headersTimeout = request.headersTimeout ?? client[kHeadersTimeout];
      const bodyTimeout = request.bodyTimeout ?? client[kBodyTimeout];
      const session = client[kHTTP2Session];
      const { method, path, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request;
      let { body } = request;
      if (upgrade != null && upgrade !== "websocket") {
        util.errorRequest(client, request, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
        return false;
      }
      const headers = buildRequestHeaders(reqHeaders);
      let stream = null;
      headers[HTTP2_HEADER_AUTHORITY] = host || client[kHostAuthority];
      headers[HTTP2_HEADER_METHOD] = method;
      let requestFinalized = false;
      const finalizeRequest = /* @__PURE__ */ __name((resetPendingIdx = false) => {
        if (requestFinalized) {
          return;
        }
        requestFinalized = true;
        completeRequest(client, request, resetPendingIdx);
        client[kResume]();
      }, "finalizeRequest");
      const abort = /* @__PURE__ */ __name((err, resetPendingIdx = false) => {
        if (request.aborted || request.completed) {
          return;
        }
        err = err || new RequestAbortedError();
        util.errorRequest(client, request, err);
        if (stream != null) {
          clearRequestStream(request);
          stream.close();
          client[kOnError](err);
          finalizeRequest(resetPendingIdx);
        }
        util.destroy(body, err);
      }, "abort");
      const requestStream = /* @__PURE__ */ __name((headers2, options) => {
        try {
          return session.request(headers2, options);
        } catch (err) {
          if (err?.code === "ERR_HTTP2_INVALID_SESSION") {
            const wrappedErr2 = new SocketError(err.message, util.getSocketInfo(session[kSocket]));
            wrappedErr2.cause = err;
            session[kError] = wrappedErr2;
            resetHttp2Session(session, wrappedErr2);
            requeueUnsentRequest(client, request);
            return null;
          }
          const wrappedErr = new InformationalError(err.message, { cause: err });
          session[kError] = wrappedErr;
          session[kSocket][kError] = wrappedErr;
          session.destroy(wrappedErr);
          util.destroy(session[kSocket], wrappedErr);
          abort(wrappedErr);
          return null;
        }
      }, "requestStream");