• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1"use strict";
2var __defProp = Object.defineProperty;
3var __getOwnPropNames = Object.getOwnPropertyNames;
4var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
5var __commonJS = (cb, mod) => function __require() {
6  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
7};
8
9// lib/core/symbols.js
10var require_symbols = __commonJS({
11  "lib/core/symbols.js"(exports2, module2) {
12    module2.exports = {
13      kClose: Symbol("close"),
14      kDestroy: Symbol("destroy"),
15      kDispatch: Symbol("dispatch"),
16      kUrl: Symbol("url"),
17      kWriting: Symbol("writing"),
18      kResuming: Symbol("resuming"),
19      kQueue: Symbol("queue"),
20      kConnect: Symbol("connect"),
21      kConnecting: Symbol("connecting"),
22      kHeadersList: Symbol("headers list"),
23      kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"),
24      kKeepAliveMaxTimeout: Symbol("max keep alive timeout"),
25      kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"),
26      kKeepAliveTimeoutValue: Symbol("keep alive timeout"),
27      kKeepAlive: Symbol("keep alive"),
28      kHeadersTimeout: Symbol("headers timeout"),
29      kBodyTimeout: Symbol("body timeout"),
30      kServerName: Symbol("server name"),
31      kLocalAddress: Symbol("local address"),
32      kHost: Symbol("host"),
33      kNoRef: Symbol("no ref"),
34      kBodyUsed: Symbol("used"),
35      kRunning: Symbol("running"),
36      kBlocking: Symbol("blocking"),
37      kPending: Symbol("pending"),
38      kSize: Symbol("size"),
39      kBusy: Symbol("busy"),
40      kQueued: Symbol("queued"),
41      kFree: Symbol("free"),
42      kConnected: Symbol("connected"),
43      kClosed: Symbol("closed"),
44      kNeedDrain: Symbol("need drain"),
45      kReset: Symbol("reset"),
46      kDestroyed: Symbol.for("nodejs.stream.destroyed"),
47      kMaxHeadersSize: Symbol("max headers size"),
48      kRunningIdx: Symbol("running index"),
49      kPendingIdx: Symbol("pending index"),
50      kError: Symbol("error"),
51      kClients: Symbol("clients"),
52      kClient: Symbol("client"),
53      kParser: Symbol("parser"),
54      kOnDestroyed: Symbol("destroy callbacks"),
55      kPipelining: Symbol("pipelining"),
56      kSocket: Symbol("socket"),
57      kHostHeader: Symbol("host header"),
58      kConnector: Symbol("connector"),
59      kStrictContentLength: Symbol("strict content length"),
60      kMaxRedirections: Symbol("maxRedirections"),
61      kMaxRequests: Symbol("maxRequestsPerClient"),
62      kProxy: Symbol("proxy agent options"),
63      kCounter: Symbol("socket request counter"),
64      kInterceptors: Symbol("dispatch interceptors"),
65      kMaxResponseSize: Symbol("max response size"),
66      kHTTP2Session: Symbol("http2Session"),
67      kHTTP2SessionState: Symbol("http2Session state"),
68      kHTTP2BuildRequest: Symbol("http2 build request"),
69      kHTTP1BuildRequest: Symbol("http1 build request"),
70      kHTTP2CopyHeaders: Symbol("http2 copy headers"),
71      kHTTPConnVersion: Symbol("http connection version"),
72      kRetryHandlerDefaultRetry: Symbol("retry agent default retry"),
73      kConstruct: Symbol("constructable")
74    };
75  }
76});
77
78// lib/fetch/symbols.js
79var require_symbols2 = __commonJS({
80  "lib/fetch/symbols.js"(exports2, module2) {
81    "use strict";
82    module2.exports = {
83      kUrl: Symbol("url"),
84      kHeaders: Symbol("headers"),
85      kSignal: Symbol("signal"),
86      kState: Symbol("state"),
87      kGuard: Symbol("guard"),
88      kRealm: Symbol("realm")
89    };
90  }
91});
92
93// lib/core/errors.js
94var require_errors = __commonJS({
95  "lib/core/errors.js"(exports2, module2) {
96    "use strict";
97    var UndiciError = class extends Error {
98      static {
99        __name(this, "UndiciError");
100      }
101      constructor(message) {
102        super(message);
103        this.name = "UndiciError";
104        this.code = "UND_ERR";
105      }
106    };
107    var ConnectTimeoutError = class _ConnectTimeoutError extends UndiciError {
108      static {
109        __name(this, "ConnectTimeoutError");
110      }
111      constructor(message) {
112        super(message);
113        Error.captureStackTrace(this, _ConnectTimeoutError);
114        this.name = "ConnectTimeoutError";
115        this.message = message || "Connect Timeout Error";
116        this.code = "UND_ERR_CONNECT_TIMEOUT";
117      }
118    };
119    var HeadersTimeoutError = class _HeadersTimeoutError extends UndiciError {
120      static {
121        __name(this, "HeadersTimeoutError");
122      }
123      constructor(message) {
124        super(message);
125        Error.captureStackTrace(this, _HeadersTimeoutError);
126        this.name = "HeadersTimeoutError";
127        this.message = message || "Headers Timeout Error";
128        this.code = "UND_ERR_HEADERS_TIMEOUT";
129      }
130    };
131    var HeadersOverflowError = class _HeadersOverflowError extends UndiciError {
132      static {
133        __name(this, "HeadersOverflowError");
134      }
135      constructor(message) {
136        super(message);
137        Error.captureStackTrace(this, _HeadersOverflowError);
138        this.name = "HeadersOverflowError";
139        this.message = message || "Headers Overflow Error";
140        this.code = "UND_ERR_HEADERS_OVERFLOW";
141      }
142    };
143    var BodyTimeoutError = class _BodyTimeoutError extends UndiciError {
144      static {
145        __name(this, "BodyTimeoutError");
146      }
147      constructor(message) {
148        super(message);
149        Error.captureStackTrace(this, _BodyTimeoutError);
150        this.name = "BodyTimeoutError";
151        this.message = message || "Body Timeout Error";
152        this.code = "UND_ERR_BODY_TIMEOUT";
153      }
154    };
155    var ResponseStatusCodeError = class _ResponseStatusCodeError extends UndiciError {
156      static {
157        __name(this, "ResponseStatusCodeError");
158      }
159      constructor(message, statusCode, headers, body) {
160        super(message);
161        Error.captureStackTrace(this, _ResponseStatusCodeError);
162        this.name = "ResponseStatusCodeError";
163        this.message = message || "Response Status Code Error";
164        this.code = "UND_ERR_RESPONSE_STATUS_CODE";
165        this.body = body;
166        this.status = statusCode;
167        this.statusCode = statusCode;
168        this.headers = headers;
169      }
170    };
171    var InvalidArgumentError = class _InvalidArgumentError extends UndiciError {
172      static {
173        __name(this, "InvalidArgumentError");
174      }
175      constructor(message) {
176        super(message);
177        Error.captureStackTrace(this, _InvalidArgumentError);
178        this.name = "InvalidArgumentError";
179        this.message = message || "Invalid Argument Error";
180        this.code = "UND_ERR_INVALID_ARG";
181      }
182    };
183    var InvalidReturnValueError = class _InvalidReturnValueError extends UndiciError {
184      static {
185        __name(this, "InvalidReturnValueError");
186      }
187      constructor(message) {
188        super(message);
189        Error.captureStackTrace(this, _InvalidReturnValueError);
190        this.name = "InvalidReturnValueError";
191        this.message = message || "Invalid Return Value Error";
192        this.code = "UND_ERR_INVALID_RETURN_VALUE";
193      }
194    };
195    var RequestAbortedError = class _RequestAbortedError extends UndiciError {
196      static {
197        __name(this, "RequestAbortedError");
198      }
199      constructor(message) {
200        super(message);
201        Error.captureStackTrace(this, _RequestAbortedError);
202        this.name = "AbortError";
203        this.message = message || "Request aborted";
204        this.code = "UND_ERR_ABORTED";
205      }
206    };
207    var InformationalError = class _InformationalError extends UndiciError {
208      static {
209        __name(this, "InformationalError");
210      }
211      constructor(message) {
212        super(message);
213        Error.captureStackTrace(this, _InformationalError);
214        this.name = "InformationalError";
215        this.message = message || "Request information";
216        this.code = "UND_ERR_INFO";
217      }
218    };
219    var RequestContentLengthMismatchError = class _RequestContentLengthMismatchError extends UndiciError {
220      static {
221        __name(this, "RequestContentLengthMismatchError");
222      }
223      constructor(message) {
224        super(message);
225        Error.captureStackTrace(this, _RequestContentLengthMismatchError);
226        this.name = "RequestContentLengthMismatchError";
227        this.message = message || "Request body length does not match content-length header";
228        this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH";
229      }
230    };
231    var ResponseContentLengthMismatchError = class _ResponseContentLengthMismatchError extends UndiciError {
232      static {
233        __name(this, "ResponseContentLengthMismatchError");
234      }
235      constructor(message) {
236        super(message);
237        Error.captureStackTrace(this, _ResponseContentLengthMismatchError);
238        this.name = "ResponseContentLengthMismatchError";
239        this.message = message || "Response body length does not match content-length header";
240        this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH";
241      }
242    };
243    var ClientDestroyedError = class _ClientDestroyedError extends UndiciError {
244      static {
245        __name(this, "ClientDestroyedError");
246      }
247      constructor(message) {
248        super(message);
249        Error.captureStackTrace(this, _ClientDestroyedError);
250        this.name = "ClientDestroyedError";
251        this.message = message || "The client is destroyed";
252        this.code = "UND_ERR_DESTROYED";
253      }
254    };
255    var ClientClosedError = class _ClientClosedError extends UndiciError {
256      static {
257        __name(this, "ClientClosedError");
258      }
259      constructor(message) {
260        super(message);
261        Error.captureStackTrace(this, _ClientClosedError);
262        this.name = "ClientClosedError";
263        this.message = message || "The client is closed";
264        this.code = "UND_ERR_CLOSED";
265      }
266    };
267    var SocketError = class _SocketError extends UndiciError {
268      static {
269        __name(this, "SocketError");
270      }
271      constructor(message, socket) {
272        super(message);
273        Error.captureStackTrace(this, _SocketError);
274        this.name = "SocketError";
275        this.message = message || "Socket error";
276        this.code = "UND_ERR_SOCKET";
277        this.socket = socket;
278      }
279    };
280    var NotSupportedError = class _NotSupportedError extends UndiciError {
281      static {
282        __name(this, "NotSupportedError");
283      }
284      constructor(message) {
285        super(message);
286        Error.captureStackTrace(this, _NotSupportedError);
287        this.name = "NotSupportedError";
288        this.message = message || "Not supported error";
289        this.code = "UND_ERR_NOT_SUPPORTED";
290      }
291    };
292    var BalancedPoolMissingUpstreamError = class extends UndiciError {
293      static {
294        __name(this, "BalancedPoolMissingUpstreamError");
295      }
296      constructor(message) {
297        super(message);
298        Error.captureStackTrace(this, NotSupportedError);
299        this.name = "MissingUpstreamError";
300        this.message = message || "No upstream has been added to the BalancedPool";
301        this.code = "UND_ERR_BPL_MISSING_UPSTREAM";
302      }
303    };
304    var HTTPParserError = class _HTTPParserError extends Error {
305      static {
306        __name(this, "HTTPParserError");
307      }
308      constructor(message, code, data) {
309        super(message);
310        Error.captureStackTrace(this, _HTTPParserError);
311        this.name = "HTTPParserError";
312        this.code = code ? `HPE_${code}` : void 0;
313        this.data = data ? data.toString() : void 0;
314      }
315    };
316    var ResponseExceededMaxSizeError = class _ResponseExceededMaxSizeError extends UndiciError {
317      static {
318        __name(this, "ResponseExceededMaxSizeError");
319      }
320      constructor(message) {
321        super(message);
322        Error.captureStackTrace(this, _ResponseExceededMaxSizeError);
323        this.name = "ResponseExceededMaxSizeError";
324        this.message = message || "Response content exceeded max size";
325        this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE";
326      }
327    };
328    var RequestRetryError = class _RequestRetryError extends UndiciError {
329      static {
330        __name(this, "RequestRetryError");
331      }
332      constructor(message, code, { headers, data }) {
333        super(message);
334        Error.captureStackTrace(this, _RequestRetryError);
335        this.name = "RequestRetryError";
336        this.message = message || "Request retry error";
337        this.code = "UND_ERR_REQ_RETRY";
338        this.statusCode = code;
339        this.data = data;
340        this.headers = headers;
341      }
342    };
343    module2.exports = {
344      HTTPParserError,
345      UndiciError,
346      HeadersTimeoutError,
347      HeadersOverflowError,
348      BodyTimeoutError,
349      RequestContentLengthMismatchError,
350      ConnectTimeoutError,
351      ResponseStatusCodeError,
352      InvalidArgumentError,
353      InvalidReturnValueError,
354      RequestAbortedError,
355      ClientDestroyedError,
356      ClientClosedError,
357      InformationalError,
358      SocketError,
359      NotSupportedError,
360      ResponseContentLengthMismatchError,
361      BalancedPoolMissingUpstreamError,
362      ResponseExceededMaxSizeError,
363      RequestRetryError
364    };
365  }
366});
367
368// lib/core/constants.js
369var require_constants = __commonJS({
370  "lib/core/constants.js"(exports2, module2) {
371    "use strict";
372    var headerNameLowerCasedRecord = {};
373    var wellknownHeaderNames = [
374      "Accept",
375      "Accept-Encoding",
376      "Accept-Language",
377      "Accept-Ranges",
378      "Access-Control-Allow-Credentials",
379      "Access-Control-Allow-Headers",
380      "Access-Control-Allow-Methods",
381      "Access-Control-Allow-Origin",
382      "Access-Control-Expose-Headers",
383      "Access-Control-Max-Age",
384      "Access-Control-Request-Headers",
385      "Access-Control-Request-Method",
386      "Age",
387      "Allow",
388      "Alt-Svc",
389      "Alt-Used",
390      "Authorization",
391      "Cache-Control",
392      "Clear-Site-Data",
393      "Connection",
394      "Content-Disposition",
395      "Content-Encoding",
396      "Content-Language",
397      "Content-Length",
398      "Content-Location",
399      "Content-Range",
400      "Content-Security-Policy",
401      "Content-Security-Policy-Report-Only",
402      "Content-Type",
403      "Cookie",
404      "Cross-Origin-Embedder-Policy",
405      "Cross-Origin-Opener-Policy",
406      "Cross-Origin-Resource-Policy",
407      "Date",
408      "Device-Memory",
409      "Downlink",
410      "ECT",
411      "ETag",
412      "Expect",
413      "Expect-CT",
414      "Expires",
415      "Forwarded",
416      "From",
417      "Host",
418      "If-Match",
419      "If-Modified-Since",
420      "If-None-Match",
421      "If-Range",
422      "If-Unmodified-Since",
423      "Keep-Alive",
424      "Last-Modified",
425      "Link",
426      "Location",
427      "Max-Forwards",
428      "Origin",
429      "Permissions-Policy",
430      "Pragma",
431      "Proxy-Authenticate",
432      "Proxy-Authorization",
433      "RTT",
434      "Range",
435      "Referer",
436      "Referrer-Policy",
437      "Refresh",
438      "Retry-After",
439      "Sec-WebSocket-Accept",
440      "Sec-WebSocket-Extensions",
441      "Sec-WebSocket-Key",
442      "Sec-WebSocket-Protocol",
443      "Sec-WebSocket-Version",
444      "Server",
445      "Server-Timing",
446      "Service-Worker-Allowed",
447      "Service-Worker-Navigation-Preload",
448      "Set-Cookie",
449      "SourceMap",
450      "Strict-Transport-Security",
451      "Supports-Loading-Mode",
452      "TE",
453      "Timing-Allow-Origin",
454      "Trailer",
455      "Transfer-Encoding",
456      "Upgrade",
457      "Upgrade-Insecure-Requests",
458      "User-Agent",
459      "Vary",
460      "Via",
461      "WWW-Authenticate",
462      "X-Content-Type-Options",
463      "X-DNS-Prefetch-Control",
464      "X-Frame-Options",
465      "X-Permitted-Cross-Domain-Policies",
466      "X-Powered-By",
467      "X-Requested-With",
468      "X-XSS-Protection"
469    ];
470    for (let i = 0; i < wellknownHeaderNames.length; ++i) {
471      const key = wellknownHeaderNames[i];
472      const lowerCasedKey = key.toLowerCase();
473      headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey;
474    }
475    Object.setPrototypeOf(headerNameLowerCasedRecord, null);
476    module2.exports = {
477      wellknownHeaderNames,
478      headerNameLowerCasedRecord
479    };
480  }
481});
482
483// lib/core/util.js
484var require_util = __commonJS({
485  "lib/core/util.js"(exports2, module2) {
486    "use strict";
487    var assert = require("assert");
488    var { kDestroyed, kBodyUsed } = require_symbols();
489    var { IncomingMessage } = require("http");
490    var stream = require("stream");
491    var net = require("net");
492    var { InvalidArgumentError } = require_errors();
493    var { Blob: Blob2 } = require("buffer");
494    var nodeUtil = require("util");
495    var { stringify } = require("querystring");
496    var { headerNameLowerCasedRecord } = require_constants();
497    var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v));
498    function nop() {
499    }
500    __name(nop, "nop");
501    function isStream(obj) {
502      return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function";
503    }
504    __name(isStream, "isStream");
505    function isBlobLike(object) {
506      return Blob2 && object instanceof Blob2 || object && typeof object === "object" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]);
507    }
508    __name(isBlobLike, "isBlobLike");
509    function buildURL(url, queryParams) {
510      if (url.includes("?") || url.includes("#")) {
511        throw new Error('Query params cannot be passed when url already contains "?" or "#".');
512      }
513      const stringified = stringify(queryParams);
514      if (stringified) {
515        url += "?" + stringified;
516      }
517      return url;
518    }
519    __name(buildURL, "buildURL");
520    function parseURL(url) {
521      if (typeof url === "string") {
522        url = new URL(url);
523        if (!/^https?:/.test(url.origin || url.protocol)) {
524          throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
525        }
526        return url;
527      }
528      if (!url || typeof url !== "object") {
529        throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object.");
530      }
531      if (!/^https?:/.test(url.origin || url.protocol)) {
532        throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
533      }
534      if (!(url instanceof URL)) {
535        if (url.port != null && url.port !== "" && !Number.isFinite(parseInt(url.port))) {
536          throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer.");
537        }
538        if (url.path != null && typeof url.path !== "string") {
539          throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined.");
540        }
541        if (url.pathname != null && typeof url.pathname !== "string") {
542          throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined.");
543        }
544        if (url.hostname != null && typeof url.hostname !== "string") {
545          throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined.");
546        }
547        if (url.origin != null && typeof url.origin !== "string") {
548          throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined.");
549        }
550        const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
551        let origin = url.origin != null ? url.origin : `${url.protocol}//${url.hostname}:${port}`;
552        let path = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
553        if (origin.endsWith("/")) {
554          origin = origin.substring(0, origin.length - 1);
555        }
556        if (path && !path.startsWith("/")) {
557          path = `/${path}`;
558        }
559        url = new URL(origin + path);
560      }
561      return url;
562    }
563    __name(parseURL, "parseURL");
564    function parseOrigin(url) {
565      url = parseURL(url);
566      if (url.pathname !== "/" || url.search || url.hash) {
567        throw new InvalidArgumentError("invalid url");
568      }
569      return url;
570    }
571    __name(parseOrigin, "parseOrigin");
572    function getHostname(host) {
573      if (host[0] === "[") {
574        const idx2 = host.indexOf("]");
575        assert(idx2 !== -1);
576        return host.substring(1, idx2);
577      }
578      const idx = host.indexOf(":");
579      if (idx === -1)
580        return host;
581      return host.substring(0, idx);
582    }
583    __name(getHostname, "getHostname");
584    function getServerName(host) {
585      if (!host) {
586        return null;
587      }
588      assert.strictEqual(typeof host, "string");
589      const servername = getHostname(host);
590      if (net.isIP(servername)) {
591        return "";
592      }
593      return servername;
594    }
595    __name(getServerName, "getServerName");
596    function deepClone(obj) {
597      return JSON.parse(JSON.stringify(obj));
598    }
599    __name(deepClone, "deepClone");
600    function isAsyncIterable(obj) {
601      return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function");
602    }
603    __name(isAsyncIterable, "isAsyncIterable");
604    function isIterable(obj) {
605      return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function"));
606    }
607    __name(isIterable, "isIterable");
608    function bodyLength(body) {
609      if (body == null) {
610        return 0;
611      } else if (isStream(body)) {
612        const state = body._readableState;
613        return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null;
614      } else if (isBlobLike(body)) {
615        return body.size != null ? body.size : null;
616      } else if (isBuffer(body)) {
617        return body.byteLength;
618      }
619      return null;
620    }
621    __name(bodyLength, "bodyLength");
622    function isDestroyed(stream2) {
623      return !stream2 || !!(stream2.destroyed || stream2[kDestroyed]);
624    }
625    __name(isDestroyed, "isDestroyed");
626    function isReadableAborted(stream2) {
627      const state = stream2 && stream2._readableState;
628      return isDestroyed(stream2) && state && !state.endEmitted;
629    }
630    __name(isReadableAborted, "isReadableAborted");
631    function destroy(stream2, err) {
632      if (stream2 == null || !isStream(stream2) || isDestroyed(stream2)) {
633        return;
634      }
635      if (typeof stream2.destroy === "function") {
636        if (Object.getPrototypeOf(stream2).constructor === IncomingMessage) {
637          stream2.socket = null;
638        }
639        stream2.destroy(err);
640      } else if (err) {
641        process.nextTick((stream3, err2) => {
642          stream3.emit("error", err2);
643        }, stream2, err);
644      }
645      if (stream2.destroyed !== true) {
646        stream2[kDestroyed] = true;
647      }
648    }
649    __name(destroy, "destroy");
650    var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/;
651    function parseKeepAliveTimeout(val) {
652      const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR);
653      return m ? parseInt(m[1], 10) * 1e3 : null;
654    }
655    __name(parseKeepAliveTimeout, "parseKeepAliveTimeout");
656    function headerNameToString(value) {
657      return headerNameLowerCasedRecord[value] || value.toLowerCase();
658    }
659    __name(headerNameToString, "headerNameToString");
660    function parseHeaders(headers, obj = {}) {
661      if (!Array.isArray(headers))
662        return headers;
663      for (let i = 0; i < headers.length; i += 2) {
664        const key = headers[i].toString().toLowerCase();
665        let val = obj[key];
666        if (!val) {
667          if (Array.isArray(headers[i + 1])) {
668            obj[key] = headers[i + 1].map((x) => x.toString("utf8"));
669          } else {
670            obj[key] = headers[i + 1].toString("utf8");
671          }
672        } else {
673          if (!Array.isArray(val)) {
674            val = [val];
675            obj[key] = val;
676          }
677          val.push(headers[i + 1].toString("utf8"));
678        }
679      }
680      if ("content-length" in obj && "content-disposition" in obj) {
681        obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1");
682      }
683      return obj;
684    }
685    __name(parseHeaders, "parseHeaders");
686    function parseRawHeaders(headers) {
687      const ret = [];
688      let hasContentLength = false;
689      let contentDispositionIdx = -1;
690      for (let n = 0; n < headers.length; n += 2) {
691        const key = headers[n + 0].toString();
692        const val = headers[n + 1].toString("utf8");
693        if (key.length === 14 && (key === "content-length" || key.toLowerCase() === "content-length")) {
694          ret.push(key, val);
695          hasContentLength = true;
696        } else if (key.length === 19 && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) {
697          contentDispositionIdx = ret.push(key, val) - 1;
698        } else {
699          ret.push(key, val);
700        }
701      }
702      if (hasContentLength && contentDispositionIdx !== -1) {
703        ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1");
704      }
705      return ret;
706    }
707    __name(parseRawHeaders, "parseRawHeaders");
708    function isBuffer(buffer) {
709      return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
710    }
711    __name(isBuffer, "isBuffer");
712    function validateHandler(handler, method, upgrade) {
713      if (!handler || typeof handler !== "object") {
714        throw new InvalidArgumentError("handler must be an object");
715      }
716      if (typeof handler.onConnect !== "function") {
717        throw new InvalidArgumentError("invalid onConnect method");
718      }
719      if (typeof handler.onError !== "function") {
720        throw new InvalidArgumentError("invalid onError method");
721      }
722      if (typeof handler.onBodySent !== "function" && handler.onBodySent !== void 0) {
723        throw new InvalidArgumentError("invalid onBodySent method");
724      }
725      if (upgrade || method === "CONNECT") {
726        if (typeof handler.onUpgrade !== "function") {
727          throw new InvalidArgumentError("invalid onUpgrade method");
728        }
729      } else {
730        if (typeof handler.onHeaders !== "function") {
731          throw new InvalidArgumentError("invalid onHeaders method");
732        }
733        if (typeof handler.onData !== "function") {
734          throw new InvalidArgumentError("invalid onData method");
735        }
736        if (typeof handler.onComplete !== "function") {
737          throw new InvalidArgumentError("invalid onComplete method");
738        }
739      }
740    }
741    __name(validateHandler, "validateHandler");
742    function isDisturbed(body) {
743      return !!(body && (stream.isDisturbed ? stream.isDisturbed(body) || body[kBodyUsed] : body[kBodyUsed] || body.readableDidRead || body._readableState && body._readableState.dataEmitted || isReadableAborted(body)));
744    }
745    __name(isDisturbed, "isDisturbed");
746    function isErrored(body) {
747      return !!(body && (stream.isErrored ? stream.isErrored(body) : /state: 'errored'/.test(
748        nodeUtil.inspect(body)
749      )));
750    }
751    __name(isErrored, "isErrored");
752    function isReadable(body) {
753      return !!(body && (stream.isReadable ? stream.isReadable(body) : /state: 'readable'/.test(
754        nodeUtil.inspect(body)
755      )));
756    }
757    __name(isReadable, "isReadable");
758    function getSocketInfo(socket) {
759      return {
760        localAddress: socket.localAddress,
761        localPort: socket.localPort,
762        remoteAddress: socket.remoteAddress,
763        remotePort: socket.remotePort,
764        remoteFamily: socket.remoteFamily,
765        timeout: socket.timeout,
766        bytesWritten: socket.bytesWritten,
767        bytesRead: socket.bytesRead
768      };
769    }
770    __name(getSocketInfo, "getSocketInfo");
771    async function* convertIterableToBuffer(iterable) {
772      for await (const chunk of iterable) {
773        yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
774      }
775    }
776    __name(convertIterableToBuffer, "convertIterableToBuffer");
777    var ReadableStream;
778    function ReadableStreamFrom(iterable) {
779      if (!ReadableStream) {
780        ReadableStream = require("stream/web").ReadableStream;
781      }
782      if (ReadableStream.from) {
783        return ReadableStream.from(convertIterableToBuffer(iterable));
784      }
785      let iterator;
786      return new ReadableStream(
787        {
788          async start() {
789            iterator = iterable[Symbol.asyncIterator]();
790          },
791          async pull(controller) {
792            const { done, value } = await iterator.next();
793            if (done) {
794              queueMicrotask(() => {
795                controller.close();
796              });
797            } else {
798              const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
799              controller.enqueue(new Uint8Array(buf));
800            }
801            return controller.desiredSize > 0;
802          },
803          async cancel(reason) {
804            await iterator.return();
805          }
806        },
807        0
808      );
809    }
810    __name(ReadableStreamFrom, "ReadableStreamFrom");
811    function isFormDataLike(object) {
812      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";
813    }
814    __name(isFormDataLike, "isFormDataLike");
815    function throwIfAborted(signal) {
816      if (!signal) {
817        return;
818      }
819      if (typeof signal.throwIfAborted === "function") {
820        signal.throwIfAborted();
821      } else {
822        if (signal.aborted) {
823          const err = new Error("The operation was aborted");
824          err.name = "AbortError";
825          throw err;
826        }
827      }
828    }
829    __name(throwIfAborted, "throwIfAborted");
830    function addAbortListener(signal, listener) {
831      if ("addEventListener" in signal) {
832        signal.addEventListener("abort", listener, { once: true });
833        return () => signal.removeEventListener("abort", listener);
834      }
835      signal.addListener("abort", listener);
836      return () => signal.removeListener("abort", listener);
837    }
838    __name(addAbortListener, "addAbortListener");
839    var hasToWellFormed = !!String.prototype.toWellFormed;
840    function toUSVString(val) {
841      if (hasToWellFormed) {
842        return `${val}`.toWellFormed();
843      } else if (nodeUtil.toUSVString) {
844        return nodeUtil.toUSVString(val);
845      }
846      return `${val}`;
847    }
848    __name(toUSVString, "toUSVString");
849    function parseRangeHeader(range) {
850      if (range == null || range === "")
851        return { start: 0, end: null, size: null };
852      const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null;
853      return m ? {
854        start: parseInt(m[1]),
855        end: m[2] ? parseInt(m[2]) : null,
856        size: m[3] ? parseInt(m[3]) : null
857      } : null;
858    }
859    __name(parseRangeHeader, "parseRangeHeader");
860    var kEnumerableProperty = /* @__PURE__ */ Object.create(null);
861    kEnumerableProperty.enumerable = true;
862    module2.exports = {
863      kEnumerableProperty,
864      nop,
865      isDisturbed,
866      isErrored,
867      isReadable,
868      toUSVString,
869      isReadableAborted,
870      isBlobLike,
871      parseOrigin,
872      parseURL,
873      getServerName,
874      isStream,
875      isIterable,
876      isAsyncIterable,
877      isDestroyed,
878      headerNameToString,
879      parseRawHeaders,
880      parseHeaders,
881      parseKeepAliveTimeout,
882      destroy,
883      bodyLength,
884      deepClone,
885      ReadableStreamFrom,
886      isBuffer,
887      validateHandler,
888      getSocketInfo,
889      isFormDataLike,
890      buildURL,
891      throwIfAborted,
892      addAbortListener,
893      parseRangeHeader,
894      nodeMajor,
895      nodeMinor,
896      nodeHasAutoSelectFamily: nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 13,
897      safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"]
898    };
899  }
900});
901
902// lib/fetch/constants.js
903var require_constants2 = __commonJS({
904  "lib/fetch/constants.js"(exports2, module2) {
905    "use strict";
906    var { MessageChannel, receiveMessageOnPort } = require("worker_threads");
907    var corsSafeListedMethods = ["GET", "HEAD", "POST"];
908    var corsSafeListedMethodsSet = new Set(corsSafeListedMethods);
909    var nullBodyStatus = [101, 204, 205, 304];
910    var redirectStatus = [301, 302, 303, 307, 308];
911    var redirectStatusSet = new Set(redirectStatus);
912    var badPorts = [
913      "1",
914      "7",
915      "9",
916      "11",
917      "13",
918      "15",
919      "17",
920      "19",
921      "20",
922      "21",
923      "22",
924      "23",
925      "25",
926      "37",
927      "42",
928      "43",
929      "53",
930      "69",
931      "77",
932      "79",
933      "87",
934      "95",
935      "101",
936      "102",
937      "103",
938      "104",
939      "109",
940      "110",
941      "111",
942      "113",
943      "115",
944      "117",
945      "119",
946      "123",
947      "135",
948      "137",
949      "139",
950      "143",
951      "161",
952      "179",
953      "389",
954      "427",
955      "465",
956      "512",
957      "513",
958      "514",
959      "515",
960      "526",
961      "530",
962      "531",
963      "532",
964      "540",
965      "548",
966      "554",
967      "556",
968      "563",
969      "587",
970      "601",
971      "636",
972      "989",
973      "990",
974      "993",
975      "995",
976      "1719",
977      "1720",
978      "1723",
979      "2049",
980      "3659",
981      "4045",
982      "5060",
983      "5061",
984      "6000",
985      "6566",
986      "6665",
987      "6666",
988      "6667",
989      "6668",
990      "6669",
991      "6697",
992      "10080"
993    ];
994    var badPortsSet = new Set(badPorts);
995    var referrerPolicy = [
996      "",
997      "no-referrer",
998      "no-referrer-when-downgrade",
999      "same-origin",
1000      "origin",
1001      "strict-origin",
1002      "origin-when-cross-origin",
1003      "strict-origin-when-cross-origin",
1004      "unsafe-url"
1005    ];
1006    var referrerPolicySet = new Set(referrerPolicy);
1007    var requestRedirect = ["follow", "manual", "error"];
1008    var safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"];
1009    var safeMethodsSet = new Set(safeMethods);
1010    var requestMode = ["navigate", "same-origin", "no-cors", "cors"];
1011    var requestCredentials = ["omit", "same-origin", "include"];
1012    var requestCache = [
1013      "default",
1014      "no-store",
1015      "reload",
1016      "no-cache",
1017      "force-cache",
1018      "only-if-cached"
1019    ];
1020    var requestBodyHeader = [
1021      "content-encoding",
1022      "content-language",
1023      "content-location",
1024      "content-type",
1025      // See https://github.com/nodejs/undici/issues/2021
1026      // 'Content-Length' is a forbidden header name, which is typically
1027      // removed in the Headers implementation. However, undici doesn't
1028      // filter out headers, so we add it here.
1029      "content-length"
1030    ];
1031    var requestDuplex = [
1032      "half"
1033    ];
1034    var forbiddenMethods = ["CONNECT", "TRACE", "TRACK"];
1035    var forbiddenMethodsSet = new Set(forbiddenMethods);
1036    var subresource = [
1037      "audio",
1038      "audioworklet",
1039      "font",
1040      "image",
1041      "manifest",
1042      "paintworklet",
1043      "script",
1044      "style",
1045      "track",
1046      "video",
1047      "xslt",
1048      ""
1049    ];
1050    var subresourceSet = new Set(subresource);
1051    var DOMException = globalThis.DOMException ?? (() => {
1052      try {
1053        atob("~");
1054      } catch (err) {
1055        return Object.getPrototypeOf(err).constructor;
1056      }
1057    })();
1058    var channel;
1059    var structuredClone = globalThis.structuredClone ?? // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js
1060    // structuredClone was added in v17.0.0, but fetch supports v16.8
1061    /* @__PURE__ */ __name(function structuredClone2(value, options = void 0) {
1062      if (arguments.length === 0) {
1063        throw new TypeError("missing argument");
1064      }
1065      if (!channel) {
1066        channel = new MessageChannel();
1067      }
1068      channel.port1.unref();
1069      channel.port2.unref();
1070      channel.port1.postMessage(value, options?.transfer);
1071      return receiveMessageOnPort(channel.port2).message;
1072    }, "structuredClone");
1073    module2.exports = {
1074      DOMException,
1075      structuredClone,
1076      subresource,
1077      forbiddenMethods,
1078      requestBodyHeader,
1079      referrerPolicy,
1080      requestRedirect,
1081      requestMode,
1082      requestCredentials,
1083      requestCache,
1084      redirectStatus,
1085      corsSafeListedMethods,
1086      nullBodyStatus,
1087      safeMethods,
1088      badPorts,
1089      requestDuplex,
1090      subresourceSet,
1091      badPortsSet,
1092      redirectStatusSet,
1093      corsSafeListedMethodsSet,
1094      safeMethodsSet,
1095      forbiddenMethodsSet,
1096      referrerPolicySet
1097    };
1098  }
1099});
1100
1101// lib/fetch/global.js
1102var require_global = __commonJS({
1103  "lib/fetch/global.js"(exports2, module2) {
1104    "use strict";
1105    var globalOrigin = Symbol.for("undici.globalOrigin.1");
1106    function getGlobalOrigin() {
1107      return globalThis[globalOrigin];
1108    }
1109    __name(getGlobalOrigin, "getGlobalOrigin");
1110    function setGlobalOrigin(newOrigin) {
1111      if (newOrigin === void 0) {
1112        Object.defineProperty(globalThis, globalOrigin, {
1113          value: void 0,
1114          writable: true,
1115          enumerable: false,
1116          configurable: false
1117        });
1118        return;
1119      }
1120      const parsedURL = new URL(newOrigin);
1121      if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") {
1122        throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`);
1123      }
1124      Object.defineProperty(globalThis, globalOrigin, {
1125        value: parsedURL,
1126        writable: true,
1127        enumerable: false,
1128        configurable: false
1129      });
1130    }
1131    __name(setGlobalOrigin, "setGlobalOrigin");
1132    module2.exports = {
1133      getGlobalOrigin,
1134      setGlobalOrigin
1135    };
1136  }
1137});
1138
1139// lib/fetch/util.js
1140var require_util2 = __commonJS({
1141  "lib/fetch/util.js"(exports2, module2) {
1142    "use strict";
1143    var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants2();
1144    var { getGlobalOrigin } = require_global();
1145    var { performance: performance2 } = require("perf_hooks");
1146    var { isBlobLike, toUSVString, ReadableStreamFrom } = require_util();
1147    var assert = require("assert");
1148    var { isUint8Array } = require("util/types");
1149    var supportedHashes = [];
1150    var crypto;
1151    try {
1152      crypto = require("crypto");
1153      const possibleRelevantHashes = ["sha256", "sha384", "sha512"];
1154      supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
1155    } catch {
1156    }
1157    function responseURL(response) {
1158      const urlList = response.urlList;
1159      const length = urlList.length;
1160      return length === 0 ? null : urlList[length - 1].toString();
1161    }
1162    __name(responseURL, "responseURL");
1163    function responseLocationURL(response, requestFragment) {
1164      if (!redirectStatusSet.has(response.status)) {
1165        return null;
1166      }
1167      let location = response.headersList.get("location");
1168      if (location !== null && isValidHeaderValue(location)) {
1169        location = new URL(location, responseURL(response));
1170      }
1171      if (location && !location.hash) {
1172        location.hash = requestFragment;
1173      }
1174      return location;
1175    }
1176    __name(responseLocationURL, "responseLocationURL");
1177    function requestCurrentURL(request) {
1178      return request.urlList[request.urlList.length - 1];
1179    }
1180    __name(requestCurrentURL, "requestCurrentURL");
1181    function requestBadPort(request) {
1182      const url = requestCurrentURL(request);
1183      if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) {
1184        return "blocked";
1185      }
1186      return "allowed";
1187    }
1188    __name(requestBadPort, "requestBadPort");
1189    function isErrorLike(object) {
1190      return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException");
1191    }
1192    __name(isErrorLike, "isErrorLike");
1193    function isValidReasonPhrase(statusText) {
1194      for (let i = 0; i < statusText.length; ++i) {
1195        const c = statusText.charCodeAt(i);
1196        if (!(c === 9 || // HTAB
1197        c >= 32 && c <= 126 || // SP / VCHAR
1198        c >= 128 && c <= 255)) {
1199          return false;
1200        }
1201      }
1202      return true;
1203    }
1204    __name(isValidReasonPhrase, "isValidReasonPhrase");
1205    function isTokenCharCode(c) {
1206      switch (c) {
1207        case 34:
1208        case 40:
1209        case 41:
1210        case 44:
1211        case 47:
1212        case 58:
1213        case 59:
1214        case 60:
1215        case 61:
1216        case 62:
1217        case 63:
1218        case 64:
1219        case 91:
1220        case 92:
1221        case 93:
1222        case 123:
1223        case 125:
1224          return false;
1225        default:
1226          return c >= 33 && c <= 126;
1227      }
1228    }
1229    __name(isTokenCharCode, "isTokenCharCode");
1230    function isValidHTTPToken(characters) {
1231      if (characters.length === 0) {
1232        return false;
1233      }
1234      for (let i = 0; i < characters.length; ++i) {
1235        if (!isTokenCharCode(characters.charCodeAt(i))) {
1236          return false;
1237        }
1238      }
1239      return true;
1240    }
1241    __name(isValidHTTPToken, "isValidHTTPToken");
1242    function isValidHeaderName(potentialValue) {
1243      return isValidHTTPToken(potentialValue);
1244    }
1245    __name(isValidHeaderName, "isValidHeaderName");
1246    function isValidHeaderValue(potentialValue) {
1247      if (potentialValue.startsWith("	") || potentialValue.startsWith(" ") || potentialValue.endsWith("	") || potentialValue.endsWith(" ")) {
1248        return false;
1249      }
1250      if (potentialValue.includes("\0") || potentialValue.includes("\r") || potentialValue.includes("\n")) {
1251        return false;
1252      }
1253      return true;
1254    }
1255    __name(isValidHeaderValue, "isValidHeaderValue");
1256    function setRequestReferrerPolicyOnRedirect(request, actualResponse) {
1257      const { headersList } = actualResponse;
1258      const policyHeader = (headersList.get("referrer-policy") ?? "").split(",");
1259      let policy = "";
1260      if (policyHeader.length > 0) {
1261        for (let i = policyHeader.length; i !== 0; i--) {
1262          const token = policyHeader[i - 1].trim();
1263          if (referrerPolicyTokens.has(token)) {
1264            policy = token;
1265            break;
1266          }
1267        }
1268      }
1269      if (policy !== "") {
1270        request.referrerPolicy = policy;
1271      }
1272    }
1273    __name(setRequestReferrerPolicyOnRedirect, "setRequestReferrerPolicyOnRedirect");
1274    function crossOriginResourcePolicyCheck() {
1275      return "allowed";
1276    }
1277    __name(crossOriginResourcePolicyCheck, "crossOriginResourcePolicyCheck");
1278    function corsCheck() {
1279      return "success";
1280    }
1281    __name(corsCheck, "corsCheck");
1282    function TAOCheck() {
1283      return "success";
1284    }
1285    __name(TAOCheck, "TAOCheck");
1286    function appendFetchMetadata(httpRequest) {
1287      let header = null;
1288      header = httpRequest.mode;
1289      httpRequest.headersList.set("sec-fetch-mode", header);
1290    }
1291    __name(appendFetchMetadata, "appendFetchMetadata");
1292    function appendRequestOriginHeader(request) {
1293      let serializedOrigin = request.origin;
1294      if (request.responseTainting === "cors" || request.mode === "websocket") {
1295        if (serializedOrigin) {
1296          request.headersList.append("origin", serializedOrigin);
1297        }
1298      } else if (request.method !== "GET" && request.method !== "HEAD") {
1299        switch (request.referrerPolicy) {
1300          case "no-referrer":
1301            serializedOrigin = null;
1302            break;
1303          case "no-referrer-when-downgrade":
1304          case "strict-origin":
1305          case "strict-origin-when-cross-origin":
1306            if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) {
1307              serializedOrigin = null;
1308            }
1309            break;
1310          case "same-origin":
1311            if (!sameOrigin(request, requestCurrentURL(request))) {
1312              serializedOrigin = null;
1313            }
1314            break;
1315          default:
1316        }
1317        if (serializedOrigin) {
1318          request.headersList.append("origin", serializedOrigin);
1319        }
1320      }
1321    }
1322    __name(appendRequestOriginHeader, "appendRequestOriginHeader");
1323    function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
1324      return performance2.now();
1325    }
1326    __name(coarsenedSharedCurrentTime, "coarsenedSharedCurrentTime");
1327    function createOpaqueTimingInfo(timingInfo) {
1328      return {
1329        startTime: timingInfo.startTime ?? 0,
1330        redirectStartTime: 0,
1331        redirectEndTime: 0,
1332        postRedirectStartTime: timingInfo.startTime ?? 0,
1333        finalServiceWorkerStartTime: 0,
1334        finalNetworkResponseStartTime: 0,
1335        finalNetworkRequestStartTime: 0,
1336        endTime: 0,
1337        encodedBodySize: 0,
1338        decodedBodySize: 0,
1339        finalConnectionTimingInfo: null
1340      };
1341    }
1342    __name(createOpaqueTimingInfo, "createOpaqueTimingInfo");
1343    function makePolicyContainer() {
1344      return {
1345        referrerPolicy: "strict-origin-when-cross-origin"
1346      };
1347    }
1348    __name(makePolicyContainer, "makePolicyContainer");
1349    function clonePolicyContainer(policyContainer) {
1350      return {
1351        referrerPolicy: policyContainer.referrerPolicy
1352      };
1353    }
1354    __name(clonePolicyContainer, "clonePolicyContainer");
1355    function determineRequestsReferrer(request) {
1356      const policy = request.referrerPolicy;
1357      assert(policy);
1358      let referrerSource = null;
1359      if (request.referrer === "client") {
1360        const globalOrigin = getGlobalOrigin();
1361        if (!globalOrigin || globalOrigin.origin === "null") {
1362          return "no-referrer";
1363        }
1364        referrerSource = new URL(globalOrigin);
1365      } else if (request.referrer instanceof URL) {
1366        referrerSource = request.referrer;
1367      }
1368      let referrerURL = stripURLForReferrer(referrerSource);
1369      const referrerOrigin = stripURLForReferrer(referrerSource, true);
1370      if (referrerURL.toString().length > 4096) {
1371        referrerURL = referrerOrigin;
1372      }
1373      const areSameOrigin = sameOrigin(request, referrerURL);
1374      const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request.url);
1375      switch (policy) {
1376        case "origin":
1377          return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true);
1378        case "unsafe-url":
1379          return referrerURL;
1380        case "same-origin":
1381          return areSameOrigin ? referrerOrigin : "no-referrer";
1382        case "origin-when-cross-origin":
1383          return areSameOrigin ? referrerURL : referrerOrigin;
1384        case "strict-origin-when-cross-origin": {
1385          const currentURL = requestCurrentURL(request);
1386          if (sameOrigin(referrerURL, currentURL)) {
1387            return referrerURL;
1388          }
1389          if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
1390            return "no-referrer";
1391          }
1392          return referrerOrigin;
1393        }
1394        case "strict-origin":
1395        case "no-referrer-when-downgrade":
1396        default:
1397          return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin;
1398      }
1399    }
1400    __name(determineRequestsReferrer, "determineRequestsReferrer");
1401    function stripURLForReferrer(url, originOnly) {
1402      assert(url instanceof URL);
1403      if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") {
1404        return "no-referrer";
1405      }
1406      url.username = "";
1407      url.password = "";
1408      url.hash = "";
1409      if (originOnly) {
1410        url.pathname = "";
1411        url.search = "";
1412      }
1413      return url;
1414    }
1415    __name(stripURLForReferrer, "stripURLForReferrer");
1416    function isURLPotentiallyTrustworthy(url) {
1417      if (!(url instanceof URL)) {
1418        return false;
1419      }
1420      if (url.href === "about:blank" || url.href === "about:srcdoc") {
1421        return true;
1422      }
1423      if (url.protocol === "data:")
1424        return true;
1425      if (url.protocol === "file:")
1426        return true;
1427      return isOriginPotentiallyTrustworthy(url.origin);
1428      function isOriginPotentiallyTrustworthy(origin) {
1429        if (origin == null || origin === "null")
1430          return false;
1431        const originAsURL = new URL(origin);
1432        if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") {
1433          return true;
1434        }
1435        if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) {
1436          return true;
1437        }
1438        return false;
1439      }
1440      __name(isOriginPotentiallyTrustworthy, "isOriginPotentiallyTrustworthy");
1441    }
1442    __name(isURLPotentiallyTrustworthy, "isURLPotentiallyTrustworthy");
1443    function bytesMatch(bytes, metadataList) {
1444      if (crypto === void 0) {
1445        return true;
1446      }
1447      const parsedMetadata = parseMetadata(metadataList);
1448      if (parsedMetadata === "no metadata") {
1449        return true;
1450      }
1451      if (parsedMetadata.length === 0) {
1452        return true;
1453      }
1454      const strongest = getStrongestMetadata(parsedMetadata);
1455      const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest);
1456      for (const item of metadata) {
1457        const algorithm = item.algo;
1458        const expectedValue = item.hash;
1459        let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64");
1460        if (actualValue[actualValue.length - 1] === "=") {
1461          if (actualValue[actualValue.length - 2] === "=") {
1462            actualValue = actualValue.slice(0, -2);
1463          } else {
1464            actualValue = actualValue.slice(0, -1);
1465          }
1466        }
1467        if (compareBase64Mixed(actualValue, expectedValue)) {
1468          return true;
1469        }
1470      }
1471      return false;
1472    }
1473    __name(bytesMatch, "bytesMatch");
1474    var parseHashWithOptions = /(?<algo>sha256|sha384|sha512)-((?<hash>[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i;
1475    function parseMetadata(metadata) {
1476      const result = [];
1477      let empty = true;
1478      for (const token of metadata.split(" ")) {
1479        empty = false;
1480        const parsedToken = parseHashWithOptions.exec(token);
1481        if (parsedToken === null || parsedToken.groups === void 0 || parsedToken.groups.algo === void 0) {
1482          continue;
1483        }
1484        const algorithm = parsedToken.groups.algo.toLowerCase();
1485        if (supportedHashes.includes(algorithm)) {
1486          result.push(parsedToken.groups);
1487        }
1488      }
1489      if (empty === true) {
1490        return "no metadata";
1491      }
1492      return result;
1493    }
1494    __name(parseMetadata, "parseMetadata");
1495    function getStrongestMetadata(metadataList) {
1496      let algorithm = metadataList[0].algo;
1497      if (algorithm[3] === "5") {
1498        return algorithm;
1499      }
1500      for (let i = 1; i < metadataList.length; ++i) {
1501        const metadata = metadataList[i];
1502        if (metadata.algo[3] === "5") {
1503          algorithm = "sha512";
1504          break;
1505        } else if (algorithm[3] === "3") {
1506          continue;
1507        } else if (metadata.algo[3] === "3") {
1508          algorithm = "sha384";
1509        }
1510      }
1511      return algorithm;
1512    }
1513    __name(getStrongestMetadata, "getStrongestMetadata");
1514    function filterMetadataListByAlgorithm(metadataList, algorithm) {
1515      if (metadataList.length === 1) {
1516        return metadataList;
1517      }
1518      let pos = 0;
1519      for (let i = 0; i < metadataList.length; ++i) {
1520        if (metadataList[i].algo === algorithm) {
1521          metadataList[pos++] = metadataList[i];
1522        }
1523      }
1524      metadataList.length = pos;
1525      return metadataList;
1526    }
1527    __name(filterMetadataListByAlgorithm, "filterMetadataListByAlgorithm");
1528    function compareBase64Mixed(actualValue, expectedValue) {
1529      if (actualValue.length !== expectedValue.length) {
1530        return false;
1531      }
1532      for (let i = 0; i < actualValue.length; ++i) {
1533        if (actualValue[i] !== expectedValue[i]) {
1534          if (actualValue[i] === "+" && expectedValue[i] === "-" || actualValue[i] === "/" && expectedValue[i] === "_") {
1535            continue;
1536          }
1537          return false;
1538        }
1539      }
1540      return true;
1541    }
1542    __name(compareBase64Mixed, "compareBase64Mixed");
1543    function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) {
1544    }
1545    __name(tryUpgradeRequestToAPotentiallyTrustworthyURL, "tryUpgradeRequestToAPotentiallyTrustworthyURL");
1546    function sameOrigin(A, B) {
1547      if (A.origin === B.origin && A.origin === "null") {
1548        return true;
1549      }
1550      if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) {
1551        return true;
1552      }
1553      return false;
1554    }
1555    __name(sameOrigin, "sameOrigin");
1556    function createDeferredPromise() {
1557      let res;
1558      let rej;
1559      const promise = new Promise((resolve, reject) => {
1560        res = resolve;
1561        rej = reject;
1562      });
1563      return { promise, resolve: res, reject: rej };
1564    }
1565    __name(createDeferredPromise, "createDeferredPromise");
1566    function isAborted(fetchParams) {
1567      return fetchParams.controller.state === "aborted";
1568    }
1569    __name(isAborted, "isAborted");
1570    function isCancelled(fetchParams) {
1571      return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated";
1572    }
1573    __name(isCancelled, "isCancelled");
1574    var normalizeMethodRecord = {
1575      delete: "DELETE",
1576      DELETE: "DELETE",
1577      get: "GET",
1578      GET: "GET",
1579      head: "HEAD",
1580      HEAD: "HEAD",
1581      options: "OPTIONS",
1582      OPTIONS: "OPTIONS",
1583      post: "POST",
1584      POST: "POST",
1585      put: "PUT",
1586      PUT: "PUT"
1587    };
1588    Object.setPrototypeOf(normalizeMethodRecord, null);
1589    function normalizeMethod(method) {
1590      return normalizeMethodRecord[method.toLowerCase()] ?? method;
1591    }
1592    __name(normalizeMethod, "normalizeMethod");
1593    function serializeJavascriptValueToJSONString(value) {
1594      const result = JSON.stringify(value);
1595      if (result === void 0) {
1596        throw new TypeError("Value is not JSON serializable");
1597      }
1598      assert(typeof result === "string");
1599      return result;
1600    }
1601    __name(serializeJavascriptValueToJSONString, "serializeJavascriptValueToJSONString");
1602    var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
1603    function makeIterator(iterator, name, kind) {
1604      const object = {
1605        index: 0,
1606        kind,
1607        target: iterator
1608      };
1609      const i = {
1610        next() {
1611          if (Object.getPrototypeOf(this) !== i) {
1612            throw new TypeError(
1613              `'next' called on an object that does not implement interface ${name} Iterator.`
1614            );
1615          }
1616          const { index, kind: kind2, target } = object;
1617          const values = target();
1618          const len = values.length;
1619          if (index >= len) {
1620            return { value: void 0, done: true };
1621          }
1622          const pair = values[index];
1623          object.index = index + 1;
1624          return iteratorResult(pair, kind2);
1625        },
1626        // The class string of an iterator prototype object for a given interface is the
1627        // result of concatenating the identifier of the interface and the string " Iterator".
1628        [Symbol.toStringTag]: `${name} Iterator`
1629      };
1630      Object.setPrototypeOf(i, esIteratorPrototype);
1631      return Object.setPrototypeOf({}, i);
1632    }
1633    __name(makeIterator, "makeIterator");
1634    function iteratorResult(pair, kind) {
1635      let result;
1636      switch (kind) {
1637        case "key": {
1638          result = pair[0];
1639          break;
1640        }
1641        case "value": {
1642          result = pair[1];
1643          break;
1644        }
1645        case "key+value": {
1646          result = pair;
1647          break;
1648        }
1649      }
1650      return { value: result, done: false };
1651    }
1652    __name(iteratorResult, "iteratorResult");
1653    async function fullyReadBody(body, processBody, processBodyError) {
1654      const successSteps = processBody;
1655      const errorSteps = processBodyError;
1656      let reader;
1657      try {
1658        reader = body.stream.getReader();
1659      } catch (e) {
1660        errorSteps(e);
1661        return;
1662      }
1663      try {
1664        const result = await readAllBytes(reader);
1665        successSteps(result);
1666      } catch (e) {
1667        errorSteps(e);
1668      }
1669    }
1670    __name(fullyReadBody, "fullyReadBody");
1671    var ReadableStream = globalThis.ReadableStream;
1672    function isReadableStreamLike(stream) {
1673      if (!ReadableStream) {
1674        ReadableStream = require("stream/web").ReadableStream;
1675      }
1676      return stream instanceof ReadableStream || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function";
1677    }
1678    __name(isReadableStreamLike, "isReadableStreamLike");
1679    var MAXIMUM_ARGUMENT_LENGTH = 65535;
1680    function isomorphicDecode(input) {
1681      if (input.length < MAXIMUM_ARGUMENT_LENGTH) {
1682        return String.fromCharCode(...input);
1683      }
1684      return input.reduce((previous, current) => previous + String.fromCharCode(current), "");
1685    }
1686    __name(isomorphicDecode, "isomorphicDecode");
1687    function readableStreamClose(controller) {
1688      try {
1689        controller.close();
1690      } catch (err) {
1691        if (!err.message.includes("Controller is already closed")) {
1692          throw err;
1693        }
1694      }
1695    }
1696    __name(readableStreamClose, "readableStreamClose");
1697    function isomorphicEncode(input) {
1698      for (let i = 0; i < input.length; i++) {
1699        assert(input.charCodeAt(i) <= 255);
1700      }
1701      return input;
1702    }
1703    __name(isomorphicEncode, "isomorphicEncode");
1704    async function readAllBytes(reader) {
1705      const bytes = [];
1706      let byteLength = 0;
1707      while (true) {
1708        const { done, value: chunk } = await reader.read();
1709        if (done) {
1710          return Buffer.concat(bytes, byteLength);
1711        }
1712        if (!isUint8Array(chunk)) {
1713          throw new TypeError("Received non-Uint8Array chunk");
1714        }
1715        bytes.push(chunk);
1716        byteLength += chunk.length;
1717      }
1718    }
1719    __name(readAllBytes, "readAllBytes");
1720    function urlIsLocal(url) {
1721      assert("protocol" in url);
1722      const protocol = url.protocol;
1723      return protocol === "about:" || protocol === "blob:" || protocol === "data:";
1724    }
1725    __name(urlIsLocal, "urlIsLocal");
1726    function urlHasHttpsScheme(url) {
1727      if (typeof url === "string") {
1728        return url.startsWith("https:");
1729      }
1730      return url.protocol === "https:";
1731    }
1732    __name(urlHasHttpsScheme, "urlHasHttpsScheme");
1733    function urlIsHttpHttpsScheme(url) {
1734      assert("protocol" in url);
1735      const protocol = url.protocol;
1736      return protocol === "http:" || protocol === "https:";
1737    }
1738    __name(urlIsHttpHttpsScheme, "urlIsHttpHttpsScheme");
1739    var hasOwn = Object.hasOwn || ((dict, key) => Object.prototype.hasOwnProperty.call(dict, key));
1740    module2.exports = {
1741      isAborted,
1742      isCancelled,
1743      createDeferredPromise,
1744      ReadableStreamFrom,
1745      toUSVString,
1746      tryUpgradeRequestToAPotentiallyTrustworthyURL,
1747      coarsenedSharedCurrentTime,
1748      determineRequestsReferrer,
1749      makePolicyContainer,
1750      clonePolicyContainer,
1751      appendFetchMetadata,
1752      appendRequestOriginHeader,
1753      TAOCheck,
1754      corsCheck,
1755      crossOriginResourcePolicyCheck,
1756      createOpaqueTimingInfo,
1757      setRequestReferrerPolicyOnRedirect,
1758      isValidHTTPToken,
1759      requestBadPort,
1760      requestCurrentURL,
1761      responseURL,
1762      responseLocationURL,
1763      isBlobLike,
1764      isURLPotentiallyTrustworthy,
1765      isValidReasonPhrase,
1766      sameOrigin,
1767      normalizeMethod,
1768      serializeJavascriptValueToJSONString,
1769      makeIterator,
1770      isValidHeaderName,
1771      isValidHeaderValue,
1772      hasOwn,
1773      isErrorLike,
1774      fullyReadBody,
1775      bytesMatch,
1776      isReadableStreamLike,
1777      readableStreamClose,
1778      isomorphicEncode,
1779      isomorphicDecode,
1780      urlIsLocal,
1781      urlHasHttpsScheme,
1782      urlIsHttpHttpsScheme,
1783      readAllBytes,
1784      normalizeMethodRecord,
1785      parseMetadata
1786    };
1787  }
1788});
1789
1790// lib/fetch/webidl.js
1791var require_webidl = __commonJS({
1792  "lib/fetch/webidl.js"(exports2, module2) {
1793    "use strict";
1794    var { types } = require("util");
1795    var { hasOwn, toUSVString } = require_util2();
1796    var webidl = {};
1797    webidl.converters = {};
1798    webidl.util = {};
1799    webidl.errors = {};
1800    webidl.errors.exception = function(message) {
1801      return new TypeError(`${message.header}: ${message.message}`);
1802    };
1803    webidl.errors.conversionFailed = function(context) {
1804      const plural = context.types.length === 1 ? "" : " one of";
1805      const message = `${context.argument} could not be converted to${plural}: ${context.types.join(", ")}.`;
1806      return webidl.errors.exception({
1807        header: context.prefix,
1808        message
1809      });
1810    };
1811    webidl.errors.invalidArgument = function(context) {
1812      return webidl.errors.exception({
1813        header: context.prefix,
1814        message: `"${context.value}" is an invalid ${context.type}.`
1815      });
1816    };
1817    webidl.brandCheck = function(V, I, opts = void 0) {
1818      if (opts?.strict !== false && !(V instanceof I)) {
1819        throw new TypeError("Illegal invocation");
1820      } else {
1821        return V?.[Symbol.toStringTag] === I.prototype[Symbol.toStringTag];
1822      }
1823    };
1824    webidl.argumentLengthCheck = function({ length }, min, ctx) {
1825      if (length < min) {
1826        throw webidl.errors.exception({
1827          message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`,
1828          ...ctx
1829        });
1830      }
1831    };
1832    webidl.illegalConstructor = function() {
1833      throw webidl.errors.exception({
1834        header: "TypeError",
1835        message: "Illegal constructor"
1836      });
1837    };
1838    webidl.util.Type = function(V) {
1839      switch (typeof V) {
1840        case "undefined":
1841          return "Undefined";
1842        case "boolean":
1843          return "Boolean";
1844        case "string":
1845          return "String";
1846        case "symbol":
1847          return "Symbol";
1848        case "number":
1849          return "Number";
1850        case "bigint":
1851          return "BigInt";
1852        case "function":
1853        case "object": {
1854          if (V === null) {
1855            return "Null";
1856          }
1857          return "Object";
1858        }
1859      }
1860    };
1861    webidl.util.ConvertToInt = function(V, bitLength, signedness, opts = {}) {
1862      let upperBound;
1863      let lowerBound;
1864      if (bitLength === 64) {
1865        upperBound = Math.pow(2, 53) - 1;
1866        if (signedness === "unsigned") {
1867          lowerBound = 0;
1868        } else {
1869          lowerBound = Math.pow(-2, 53) + 1;
1870        }
1871      } else if (signedness === "unsigned") {
1872        lowerBound = 0;
1873        upperBound = Math.pow(2, bitLength) - 1;
1874      } else {
1875        lowerBound = Math.pow(-2, bitLength) - 1;
1876        upperBound = Math.pow(2, bitLength - 1) - 1;
1877      }
1878      let x = Number(V);
1879      if (x === 0) {
1880        x = 0;
1881      }
1882      if (opts.enforceRange === true) {
1883        if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) {
1884          throw webidl.errors.exception({
1885            header: "Integer conversion",
1886            message: `Could not convert ${V} to an integer.`
1887          });
1888        }
1889        x = webidl.util.IntegerPart(x);
1890        if (x < lowerBound || x > upperBound) {
1891          throw webidl.errors.exception({
1892            header: "Integer conversion",
1893            message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.`
1894          });
1895        }
1896        return x;
1897      }
1898      if (!Number.isNaN(x) && opts.clamp === true) {
1899        x = Math.min(Math.max(x, lowerBound), upperBound);
1900        if (Math.floor(x) % 2 === 0) {
1901          x = Math.floor(x);
1902        } else {
1903          x = Math.ceil(x);
1904        }
1905        return x;
1906      }
1907      if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) {
1908        return 0;
1909      }
1910      x = webidl.util.IntegerPart(x);
1911      x = x % Math.pow(2, bitLength);
1912      if (signedness === "signed" && x >= Math.pow(2, bitLength) - 1) {
1913        return x - Math.pow(2, bitLength);
1914      }
1915      return x;
1916    };
1917    webidl.util.IntegerPart = function(n) {
1918      const r = Math.floor(Math.abs(n));
1919      if (n < 0) {
1920        return -1 * r;
1921      }
1922      return r;
1923    };
1924    webidl.sequenceConverter = function(converter) {
1925      return (V) => {
1926        if (webidl.util.Type(V) !== "Object") {
1927          throw webidl.errors.exception({
1928            header: "Sequence",
1929            message: `Value of type ${webidl.util.Type(V)} is not an Object.`
1930          });
1931        }
1932        const method = V?.[Symbol.iterator]?.();
1933        const seq = [];
1934        if (method === void 0 || typeof method.next !== "function") {
1935          throw webidl.errors.exception({
1936            header: "Sequence",
1937            message: "Object is not an iterator."
1938          });
1939        }
1940        while (true) {
1941          const { done, value } = method.next();
1942          if (done) {
1943            break;
1944          }
1945          seq.push(converter(value));
1946        }
1947        return seq;
1948      };
1949    };
1950    webidl.recordConverter = function(keyConverter, valueConverter) {
1951      return (O) => {
1952        if (webidl.util.Type(O) !== "Object") {
1953          throw webidl.errors.exception({
1954            header: "Record",
1955            message: `Value of type ${webidl.util.Type(O)} is not an Object.`
1956          });
1957        }
1958        const result = {};
1959        if (!types.isProxy(O)) {
1960          const keys2 = Object.keys(O);
1961          for (const key of keys2) {
1962            const typedKey = keyConverter(key);
1963            const typedValue = valueConverter(O[key]);
1964            result[typedKey] = typedValue;
1965          }
1966          return result;
1967        }
1968        const keys = Reflect.ownKeys(O);
1969        for (const key of keys) {
1970          const desc = Reflect.getOwnPropertyDescriptor(O, key);
1971          if (desc?.enumerable) {
1972            const typedKey = keyConverter(key);
1973            const typedValue = valueConverter(O[key]);
1974            result[typedKey] = typedValue;
1975          }
1976        }
1977        return result;
1978      };
1979    };
1980    webidl.interfaceConverter = function(i) {
1981      return (V, opts = {}) => {
1982        if (opts.strict !== false && !(V instanceof i)) {
1983          throw webidl.errors.exception({
1984            header: i.name,
1985            message: `Expected ${V} to be an instance of ${i.name}.`
1986          });
1987        }
1988        return V;
1989      };
1990    };
1991    webidl.dictionaryConverter = function(converters) {
1992      return (dictionary) => {
1993        const type = webidl.util.Type(dictionary);
1994        const dict = {};
1995        if (type === "Null" || type === "Undefined") {
1996          return dict;
1997        } else if (type !== "Object") {
1998          throw webidl.errors.exception({
1999            header: "Dictionary",
2000            message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
2001          });
2002        }
2003        for (const options of converters) {
2004          const { key, defaultValue, required, converter } = options;
2005          if (required === true) {
2006            if (!hasOwn(dictionary, key)) {
2007              throw webidl.errors.exception({
2008                header: "Dictionary",
2009                message: `Missing required key "${key}".`
2010              });
2011            }
2012          }
2013          let value = dictionary[key];
2014          const hasDefault = hasOwn(options, "defaultValue");
2015          if (hasDefault && value !== null) {
2016            value = value ?? defaultValue;
2017          }
2018          if (required || hasDefault || value !== void 0) {
2019            value = converter(value);
2020            if (options.allowedValues && !options.allowedValues.includes(value)) {
2021              throw webidl.errors.exception({
2022                header: "Dictionary",
2023                message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.`
2024              });
2025            }
2026            dict[key] = value;
2027          }
2028        }
2029        return dict;
2030      };
2031    };
2032    webidl.nullableConverter = function(converter) {
2033      return (V) => {
2034        if (V === null) {
2035          return V;
2036        }
2037        return converter(V);
2038      };
2039    };
2040    webidl.converters.DOMString = function(V, opts = {}) {
2041      if (V === null && opts.legacyNullToEmptyString) {
2042        return "";
2043      }
2044      if (typeof V === "symbol") {
2045        throw new TypeError("Could not convert argument of type symbol to string.");
2046      }
2047      return String(V);
2048    };
2049    webidl.converters.ByteString = function(V) {
2050      const x = webidl.converters.DOMString(V);
2051      for (let index = 0; index < x.length; index++) {
2052        if (x.charCodeAt(index) > 255) {
2053          throw new TypeError(
2054            `Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.`
2055          );
2056        }
2057      }
2058      return x;
2059    };
2060    webidl.converters.USVString = toUSVString;
2061    webidl.converters.boolean = function(V) {
2062      const x = Boolean(V);
2063      return x;
2064    };
2065    webidl.converters.any = function(V) {
2066      return V;
2067    };
2068    webidl.converters["long long"] = function(V) {
2069      const x = webidl.util.ConvertToInt(V, 64, "signed");
2070      return x;
2071    };
2072    webidl.converters["unsigned long long"] = function(V) {
2073      const x = webidl.util.ConvertToInt(V, 64, "unsigned");
2074      return x;
2075    };
2076    webidl.converters["unsigned long"] = function(V) {
2077      const x = webidl.util.ConvertToInt(V, 32, "unsigned");
2078      return x;
2079    };
2080    webidl.converters["unsigned short"] = function(V, opts) {
2081      const x = webidl.util.ConvertToInt(V, 16, "unsigned", opts);
2082      return x;
2083    };
2084    webidl.converters.ArrayBuffer = function(V, opts = {}) {
2085      if (webidl.util.Type(V) !== "Object" || !types.isAnyArrayBuffer(V)) {
2086        throw webidl.errors.conversionFailed({
2087          prefix: `${V}`,
2088          argument: `${V}`,
2089          types: ["ArrayBuffer"]
2090        });
2091      }
2092      if (opts.allowShared === false && types.isSharedArrayBuffer(V)) {
2093        throw webidl.errors.exception({
2094          header: "ArrayBuffer",
2095          message: "SharedArrayBuffer is not allowed."
2096        });
2097      }
2098      return V;
2099    };
2100    webidl.converters.TypedArray = function(V, T, opts = {}) {
2101      if (webidl.util.Type(V) !== "Object" || !types.isTypedArray(V) || V.constructor.name !== T.name) {
2102        throw webidl.errors.conversionFailed({
2103          prefix: `${T.name}`,
2104          argument: `${V}`,
2105          types: [T.name]
2106        });
2107      }
2108      if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
2109        throw webidl.errors.exception({
2110          header: "ArrayBuffer",
2111          message: "SharedArrayBuffer is not allowed."
2112        });
2113      }
2114      return V;
2115    };
2116    webidl.converters.DataView = function(V, opts = {}) {
2117      if (webidl.util.Type(V) !== "Object" || !types.isDataView(V)) {
2118        throw webidl.errors.exception({
2119          header: "DataView",
2120          message: "Object is not a DataView."
2121        });
2122      }
2123      if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
2124        throw webidl.errors.exception({
2125          header: "ArrayBuffer",
2126          message: "SharedArrayBuffer is not allowed."
2127        });
2128      }
2129      return V;
2130    };
2131    webidl.converters.BufferSource = function(V, opts = {}) {
2132      if (types.isAnyArrayBuffer(V)) {
2133        return webidl.converters.ArrayBuffer(V, opts);
2134      }
2135      if (types.isTypedArray(V)) {
2136        return webidl.converters.TypedArray(V, V.constructor);
2137      }
2138      if (types.isDataView(V)) {
2139        return webidl.converters.DataView(V, opts);
2140      }
2141      throw new TypeError(`Could not convert ${V} to a BufferSource.`);
2142    };
2143    webidl.converters["sequence<ByteString>"] = webidl.sequenceConverter(
2144      webidl.converters.ByteString
2145    );
2146    webidl.converters["sequence<sequence<ByteString>>"] = webidl.sequenceConverter(
2147      webidl.converters["sequence<ByteString>"]
2148    );
2149    webidl.converters["record<ByteString, ByteString>"] = webidl.recordConverter(
2150      webidl.converters.ByteString,
2151      webidl.converters.ByteString
2152    );
2153    module2.exports = {
2154      webidl
2155    };
2156  }
2157});
2158
2159// lib/fetch/headers.js
2160var require_headers = __commonJS({
2161  "lib/fetch/headers.js"(exports2, module2) {
2162    "use strict";
2163    var { kHeadersList, kConstruct } = require_symbols();
2164    var { kGuard } = require_symbols2();
2165    var { kEnumerableProperty } = require_util();
2166    var {
2167      makeIterator,
2168      isValidHeaderName,
2169      isValidHeaderValue
2170    } = require_util2();
2171    var { webidl } = require_webidl();
2172    var assert = require("assert");
2173    var kHeadersMap = Symbol("headers map");
2174    var kHeadersSortedMap = Symbol("headers map sorted");
2175    function isHTTPWhiteSpaceCharCode(code) {
2176      return code === 10 || code === 13 || code === 9 || code === 32;
2177    }
2178    __name(isHTTPWhiteSpaceCharCode, "isHTTPWhiteSpaceCharCode");
2179    function headerValueNormalize(potentialValue) {
2180      let i = 0;
2181      let j = potentialValue.length;
2182      while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1)))
2183        --j;
2184      while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i)))
2185        ++i;
2186      return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j);
2187    }
2188    __name(headerValueNormalize, "headerValueNormalize");
2189    function fill(headers, object) {
2190      if (Array.isArray(object)) {
2191        for (let i = 0; i < object.length; ++i) {
2192          const header = object[i];
2193          if (header.length !== 2) {
2194            throw webidl.errors.exception({
2195              header: "Headers constructor",
2196              message: `expected name/value pair to be length 2, found ${header.length}.`
2197            });
2198          }
2199          appendHeader(headers, header[0], header[1]);
2200        }
2201      } else if (typeof object === "object" && object !== null) {
2202        const keys = Object.keys(object);
2203        for (let i = 0; i < keys.length; ++i) {
2204          appendHeader(headers, keys[i], object[keys[i]]);
2205        }
2206      } else {
2207        throw webidl.errors.conversionFailed({
2208          prefix: "Headers constructor",
2209          argument: "Argument 1",
2210          types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
2211        });
2212      }
2213    }
2214    __name(fill, "fill");
2215    function appendHeader(headers, name, value) {
2216      value = headerValueNormalize(value);
2217      if (!isValidHeaderName(name)) {
2218        throw webidl.errors.invalidArgument({
2219          prefix: "Headers.append",
2220          value: name,
2221          type: "header name"
2222        });
2223      } else if (!isValidHeaderValue(value)) {
2224        throw webidl.errors.invalidArgument({
2225          prefix: "Headers.append",
2226          value,
2227          type: "header value"
2228        });
2229      }
2230      if (headers[kGuard] === "immutable") {
2231        throw new TypeError("immutable");
2232      } else if (headers[kGuard] === "request-no-cors") {
2233      }
2234      return headers[kHeadersList].append(name, value);
2235    }
2236    __name(appendHeader, "appendHeader");
2237    var HeadersList = class _HeadersList {
2238      static {
2239        __name(this, "HeadersList");
2240      }
2241      /** @type {[string, string][]|null} */
2242      cookies = null;
2243      constructor(init) {
2244        if (init instanceof _HeadersList) {
2245          this[kHeadersMap] = new Map(init[kHeadersMap]);
2246          this[kHeadersSortedMap] = init[kHeadersSortedMap];
2247          this.cookies = init.cookies === null ? null : [...init.cookies];
2248        } else {
2249          this[kHeadersMap] = new Map(init);
2250          this[kHeadersSortedMap] = null;
2251        }
2252      }
2253      // https://fetch.spec.whatwg.org/#header-list-contains
2254      contains(name) {
2255        name = name.toLowerCase();
2256        return this[kHeadersMap].has(name);
2257      }
2258      clear() {
2259        this[kHeadersMap].clear();
2260        this[kHeadersSortedMap] = null;
2261        this.cookies = null;
2262      }
2263      // https://fetch.spec.whatwg.org/#concept-header-list-append
2264      append(name, value) {
2265        this[kHeadersSortedMap] = null;
2266        const lowercaseName = name.toLowerCase();
2267        const exists = this[kHeadersMap].get(lowercaseName);
2268        if (exists) {
2269          const delimiter = lowercaseName === "cookie" ? "; " : ", ";
2270          this[kHeadersMap].set(lowercaseName, {
2271            name: exists.name,
2272            value: `${exists.value}${delimiter}${value}`
2273          });
2274        } else {
2275          this[kHeadersMap].set(lowercaseName, { name, value });
2276        }
2277        if (lowercaseName === "set-cookie") {
2278          this.cookies ??= [];
2279          this.cookies.push(value);
2280        }
2281      }
2282      // https://fetch.spec.whatwg.org/#concept-header-list-set
2283      set(name, value) {
2284        this[kHeadersSortedMap] = null;
2285        const lowercaseName = name.toLowerCase();
2286        if (lowercaseName === "set-cookie") {
2287          this.cookies = [value];
2288        }
2289        this[kHeadersMap].set(lowercaseName, { name, value });
2290      }
2291      // https://fetch.spec.whatwg.org/#concept-header-list-delete
2292      delete(name) {
2293        this[kHeadersSortedMap] = null;
2294        name = name.toLowerCase();
2295        if (name === "set-cookie") {
2296          this.cookies = null;
2297        }
2298        this[kHeadersMap].delete(name);
2299      }
2300      // https://fetch.spec.whatwg.org/#concept-header-list-get
2301      get(name) {
2302        const value = this[kHeadersMap].get(name.toLowerCase());
2303        return value === void 0 ? null : value.value;
2304      }
2305      *[Symbol.iterator]() {
2306        for (const [name, { value }] of this[kHeadersMap]) {
2307          yield [name, value];
2308        }
2309      }
2310      get entries() {
2311        const headers = {};
2312        if (this[kHeadersMap].size) {
2313          for (const { name, value } of this[kHeadersMap].values()) {
2314            headers[name] = value;
2315          }
2316        }
2317        return headers;
2318      }
2319    };
2320    var Headers = class _Headers {
2321      static {
2322        __name(this, "Headers");
2323      }
2324      constructor(init = void 0) {
2325        if (init === kConstruct) {
2326          return;
2327        }
2328        this[kHeadersList] = new HeadersList();
2329        this[kGuard] = "none";
2330        if (init !== void 0) {
2331          init = webidl.converters.HeadersInit(init);
2332          fill(this, init);
2333        }
2334      }
2335      // https://fetch.spec.whatwg.org/#dom-headers-append
2336      append(name, value) {
2337        webidl.brandCheck(this, _Headers);
2338        webidl.argumentLengthCheck(arguments, 2, { header: "Headers.append" });
2339        name = webidl.converters.ByteString(name);
2340        value = webidl.converters.ByteString(value);
2341        return appendHeader(this, name, value);
2342      }
2343      // https://fetch.spec.whatwg.org/#dom-headers-delete
2344      delete(name) {
2345        webidl.brandCheck(this, _Headers);
2346        webidl.argumentLengthCheck(arguments, 1, { header: "Headers.delete" });
2347        name = webidl.converters.ByteString(name);
2348        if (!isValidHeaderName(name)) {
2349          throw webidl.errors.invalidArgument({
2350            prefix: "Headers.delete",
2351            value: name,
2352            type: "header name"
2353          });
2354        }
2355        if (this[kGuard] === "immutable") {
2356          throw new TypeError("immutable");
2357        } else if (this[kGuard] === "request-no-cors") {
2358        }
2359        if (!this[kHeadersList].contains(name)) {
2360          return;
2361        }
2362        this[kHeadersList].delete(name);
2363      }
2364      // https://fetch.spec.whatwg.org/#dom-headers-get
2365      get(name) {
2366        webidl.brandCheck(this, _Headers);
2367        webidl.argumentLengthCheck(arguments, 1, { header: "Headers.get" });
2368        name = webidl.converters.ByteString(name);
2369        if (!isValidHeaderName(name)) {
2370          throw webidl.errors.invalidArgument({
2371            prefix: "Headers.get",
2372            value: name,
2373            type: "header name"
2374          });
2375        }
2376        return this[kHeadersList].get(name);
2377      }
2378      // https://fetch.spec.whatwg.org/#dom-headers-has
2379      has(name) {
2380        webidl.brandCheck(this, _Headers);
2381        webidl.argumentLengthCheck(arguments, 1, { header: "Headers.has" });
2382        name = webidl.converters.ByteString(name);
2383        if (!isValidHeaderName(name)) {
2384          throw webidl.errors.invalidArgument({
2385            prefix: "Headers.has",
2386            value: name,
2387            type: "header name"
2388          });
2389        }
2390        return this[kHeadersList].contains(name);
2391      }
2392      // https://fetch.spec.whatwg.org/#dom-headers-set
2393      set(name, value) {
2394        webidl.brandCheck(this, _Headers);
2395        webidl.argumentLengthCheck(arguments, 2, { header: "Headers.set" });
2396        name = webidl.converters.ByteString(name);
2397        value = webidl.converters.ByteString(value);
2398        value = headerValueNormalize(value);
2399        if (!isValidHeaderName(name)) {
2400          throw webidl.errors.invalidArgument({
2401            prefix: "Headers.set",
2402            value: name,
2403            type: "header name"
2404          });
2405        } else if (!isValidHeaderValue(value)) {
2406          throw webidl.errors.invalidArgument({
2407            prefix: "Headers.set",
2408            value,
2409            type: "header value"
2410          });
2411        }
2412        if (this[kGuard] === "immutable") {
2413          throw new TypeError("immutable");
2414        } else if (this[kGuard] === "request-no-cors") {
2415        }
2416        this[kHeadersList].set(name, value);
2417      }
2418      // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie
2419      getSetCookie() {
2420        webidl.brandCheck(this, _Headers);
2421        const list = this[kHeadersList].cookies;
2422        if (list) {
2423          return [...list];
2424        }
2425        return [];
2426      }
2427      // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
2428      get [kHeadersSortedMap]() {
2429        if (this[kHeadersList][kHeadersSortedMap]) {
2430          return this[kHeadersList][kHeadersSortedMap];
2431        }
2432        const headers = [];
2433        const names = [...this[kHeadersList]].sort((a, b) => a[0] < b[0] ? -1 : 1);
2434        const cookies = this[kHeadersList].cookies;
2435        for (let i = 0; i < names.length; ++i) {
2436          const [name, value] = names[i];
2437          if (name === "set-cookie") {
2438            for (let j = 0; j < cookies.length; ++j) {
2439              headers.push([name, cookies[j]]);
2440            }
2441          } else {
2442            assert(value !== null);
2443            headers.push([name, value]);
2444          }
2445        }
2446        this[kHeadersList][kHeadersSortedMap] = headers;
2447        return headers;
2448      }
2449      keys() {
2450        webidl.brandCheck(this, _Headers);
2451        if (this[kGuard] === "immutable") {
2452          const value = this[kHeadersSortedMap];
2453          return makeIterator(
2454            () => value,
2455            "Headers",
2456            "key"
2457          );
2458        }
2459        return makeIterator(
2460          () => [...this[kHeadersSortedMap].values()],
2461          "Headers",
2462          "key"
2463        );
2464      }
2465      values() {
2466        webidl.brandCheck(this, _Headers);
2467        if (this[kGuard] === "immutable") {
2468          const value = this[kHeadersSortedMap];
2469          return makeIterator(
2470            () => value,
2471            "Headers",
2472            "value"
2473          );
2474        }
2475        return makeIterator(
2476          () => [...this[kHeadersSortedMap].values()],
2477          "Headers",
2478          "value"
2479        );
2480      }
2481      entries() {
2482        webidl.brandCheck(this, _Headers);
2483        if (this[kGuard] === "immutable") {
2484          const value = this[kHeadersSortedMap];
2485          return makeIterator(
2486            () => value,
2487            "Headers",
2488            "key+value"
2489          );
2490        }
2491        return makeIterator(
2492          () => [...this[kHeadersSortedMap].values()],
2493          "Headers",
2494          "key+value"
2495        );
2496      }
2497      /**
2498       * @param {(value: string, key: string, self: Headers) => void} callbackFn
2499       * @param {unknown} thisArg
2500       */
2501      forEach(callbackFn, thisArg = globalThis) {
2502        webidl.brandCheck(this, _Headers);
2503        webidl.argumentLengthCheck(arguments, 1, { header: "Headers.forEach" });
2504        if (typeof callbackFn !== "function") {
2505          throw new TypeError(
2506            "Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'."
2507          );
2508        }
2509        for (const [key, value] of this) {
2510          callbackFn.apply(thisArg, [value, key, this]);
2511        }
2512      }
2513      [Symbol.for("nodejs.util.inspect.custom")]() {
2514        webidl.brandCheck(this, _Headers);
2515        return this[kHeadersList];
2516      }
2517    };
2518    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
2519    Object.defineProperties(Headers.prototype, {
2520      append: kEnumerableProperty,
2521      delete: kEnumerableProperty,
2522      get: kEnumerableProperty,
2523      has: kEnumerableProperty,
2524      set: kEnumerableProperty,
2525      getSetCookie: kEnumerableProperty,
2526      keys: kEnumerableProperty,
2527      values: kEnumerableProperty,
2528      entries: kEnumerableProperty,
2529      forEach: kEnumerableProperty,
2530      [Symbol.iterator]: { enumerable: false },
2531      [Symbol.toStringTag]: {
2532        value: "Headers",
2533        configurable: true
2534      }
2535    });
2536    webidl.converters.HeadersInit = function(V) {
2537      if (webidl.util.Type(V) === "Object") {
2538        if (V[Symbol.iterator]) {
2539          return webidl.converters["sequence<sequence<ByteString>>"](V);
2540        }
2541        return webidl.converters["record<ByteString, ByteString>"](V);
2542      }
2543      throw webidl.errors.conversionFailed({
2544        prefix: "Headers constructor",
2545        argument: "Argument 1",
2546        types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
2547      });
2548    };
2549    module2.exports = {
2550      fill,
2551      Headers,
2552      HeadersList
2553    };
2554  }
2555});
2556
2557// node_modules/@fastify/busboy/deps/streamsearch/sbmh.js
2558var require_sbmh = __commonJS({
2559  "node_modules/@fastify/busboy/deps/streamsearch/sbmh.js"(exports2, module2) {
2560    "use strict";
2561    var EventEmitter = require("node:events").EventEmitter;
2562    var inherits = require("node:util").inherits;
2563    function SBMH(needle) {
2564      if (typeof needle === "string") {
2565        needle = Buffer.from(needle);
2566      }
2567      if (!Buffer.isBuffer(needle)) {
2568        throw new TypeError("The needle has to be a String or a Buffer.");
2569      }
2570      const needleLength = needle.length;
2571      if (needleLength === 0) {
2572        throw new Error("The needle cannot be an empty String/Buffer.");
2573      }
2574      if (needleLength > 256) {
2575        throw new Error("The needle cannot have a length bigger than 256.");
2576      }
2577      this.maxMatches = Infinity;
2578      this.matches = 0;
2579      this._occ = new Array(256).fill(needleLength);
2580      this._lookbehind_size = 0;
2581      this._needle = needle;
2582      this._bufpos = 0;
2583      this._lookbehind = Buffer.alloc(needleLength);
2584      for (var i = 0; i < needleLength - 1; ++i) {
2585        this._occ[needle[i]] = needleLength - 1 - i;
2586      }
2587    }
2588    __name(SBMH, "SBMH");
2589    inherits(SBMH, EventEmitter);
2590    SBMH.prototype.reset = function() {
2591      this._lookbehind_size = 0;
2592      this.matches = 0;
2593      this._bufpos = 0;
2594    };
2595    SBMH.prototype.push = function(chunk, pos) {
2596      if (!Buffer.isBuffer(chunk)) {
2597        chunk = Buffer.from(chunk, "binary");
2598      }
2599      const chlen = chunk.length;
2600      this._bufpos = pos || 0;
2601      let r;
2602      while (r !== chlen && this.matches < this.maxMatches) {
2603        r = this._sbmh_feed(chunk);
2604      }
2605      return r;
2606    };
2607    SBMH.prototype._sbmh_feed = function(data) {
2608      const len = data.length;
2609      const needle = this._needle;
2610      const needleLength = needle.length;
2611      const lastNeedleChar = needle[needleLength - 1];
2612      let pos = -this._lookbehind_size;
2613      let ch;
2614      if (pos < 0) {
2615        while (pos < 0 && pos <= len - needleLength) {
2616          ch = this._sbmh_lookup_char(data, pos + needleLength - 1);
2617          if (ch === lastNeedleChar && this._sbmh_memcmp(data, pos, needleLength - 1)) {
2618            this._lookbehind_size = 0;
2619            ++this.matches;
2620            this.emit("info", true);
2621            return this._bufpos = pos + needleLength;
2622          }
2623          pos += this._occ[ch];
2624        }
2625        if (pos < 0) {
2626          while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) {
2627            ++pos;
2628          }
2629        }
2630        if (pos >= 0) {
2631          this.emit("info", false, this._lookbehind, 0, this._lookbehind_size);
2632          this._lookbehind_size = 0;
2633        } else {
2634          const bytesToCutOff = this._lookbehind_size + pos;
2635          if (bytesToCutOff > 0) {
2636            this.emit("info", false, this._lookbehind, 0, bytesToCutOff);
2637          }
2638          this._lookbehind.copy(
2639            this._lookbehind,
2640            0,
2641            bytesToCutOff,
2642            this._lookbehind_size - bytesToCutOff
2643          );
2644          this._lookbehind_size -= bytesToCutOff;
2645          data.copy(this._lookbehind, this._lookbehind_size);
2646          this._lookbehind_size += len;
2647          this._bufpos = len;
2648          return len;
2649        }
2650      }
2651      pos += (pos >= 0) * this._bufpos;
2652      if (data.indexOf(needle, pos) !== -1) {
2653        pos = data.indexOf(needle, pos);
2654        ++this.matches;
2655        if (pos > 0) {
2656          this.emit("info", true, data, this._bufpos, pos);
2657        } else {
2658          this.emit("info", true);
2659        }
2660        return this._bufpos = pos + needleLength;
2661      } else {
2662        pos = len - needleLength;
2663      }
2664      while (pos < len && (data[pos] !== needle[0] || Buffer.compare(
2665        data.subarray(pos, pos + len - pos),
2666        needle.subarray(0, len - pos)
2667      ) !== 0)) {
2668        ++pos;
2669      }
2670      if (pos < len) {
2671        data.copy(this._lookbehind, 0, pos, pos + (len - pos));
2672        this._lookbehind_size = len - pos;
2673      }
2674      if (pos > 0) {
2675        this.emit("info", false, data, this._bufpos, pos < len ? pos : len);
2676      }
2677      this._bufpos = len;
2678      return len;
2679    };
2680    SBMH.prototype._sbmh_lookup_char = function(data, pos) {
2681      return pos < 0 ? this._lookbehind[this._lookbehind_size + pos] : data[pos];
2682    };
2683    SBMH.prototype._sbmh_memcmp = function(data, pos, len) {
2684      for (var i = 0; i < len; ++i) {
2685        if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) {
2686          return false;
2687        }
2688      }
2689      return true;
2690    };
2691    module2.exports = SBMH;
2692  }
2693});
2694
2695// node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js
2696var require_PartStream = __commonJS({
2697  "node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js"(exports2, module2) {
2698    "use strict";
2699    var inherits = require("node:util").inherits;
2700    var ReadableStream = require("node:stream").Readable;
2701    function PartStream(opts) {
2702      ReadableStream.call(this, opts);
2703    }
2704    __name(PartStream, "PartStream");
2705    inherits(PartStream, ReadableStream);
2706    PartStream.prototype._read = function(n) {
2707    };
2708    module2.exports = PartStream;
2709  }
2710});
2711
2712// node_modules/@fastify/busboy/lib/utils/getLimit.js
2713var require_getLimit = __commonJS({
2714  "node_modules/@fastify/busboy/lib/utils/getLimit.js"(exports2, module2) {
2715    "use strict";
2716    module2.exports = /* @__PURE__ */ __name(function getLimit(limits, name, defaultLimit) {
2717      if (!limits || limits[name] === void 0 || limits[name] === null) {
2718        return defaultLimit;
2719      }
2720      if (typeof limits[name] !== "number" || isNaN(limits[name])) {
2721        throw new TypeError("Limit " + name + " is not a valid number");
2722      }
2723      return limits[name];
2724    }, "getLimit");
2725  }
2726});
2727
2728// node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js
2729var require_HeaderParser = __commonJS({
2730  "node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js"(exports2, module2) {
2731    "use strict";
2732    var EventEmitter = require("node:events").EventEmitter;
2733    var inherits = require("node:util").inherits;
2734    var getLimit = require_getLimit();
2735    var StreamSearch = require_sbmh();
2736    var B_DCRLF = Buffer.from("\r\n\r\n");
2737    var RE_CRLF = /\r\n/g;
2738    var RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/;
2739    function HeaderParser(cfg) {
2740      EventEmitter.call(this);
2741      cfg = cfg || {};
2742      const self = this;
2743      this.nread = 0;
2744      this.maxed = false;
2745      this.npairs = 0;
2746      this.maxHeaderPairs = getLimit(cfg, "maxHeaderPairs", 2e3);
2747      this.maxHeaderSize = getLimit(cfg, "maxHeaderSize", 80 * 1024);
2748      this.buffer = "";
2749      this.header = {};
2750      this.finished = false;
2751      this.ss = new StreamSearch(B_DCRLF);
2752      this.ss.on("info", function(isMatch, data, start, end) {
2753        if (data && !self.maxed) {
2754          if (self.nread + end - start >= self.maxHeaderSize) {
2755            end = self.maxHeaderSize - self.nread + start;
2756            self.nread = self.maxHeaderSize;
2757            self.maxed = true;
2758          } else {
2759            self.nread += end - start;
2760          }
2761          self.buffer += data.toString("binary", start, end);
2762        }
2763        if (isMatch) {
2764          self._finish();
2765        }
2766      });
2767    }
2768    __name(HeaderParser, "HeaderParser");
2769    inherits(HeaderParser, EventEmitter);
2770    HeaderParser.prototype.push = function(data) {
2771      const r = this.ss.push(data);
2772      if (this.finished) {
2773        return r;
2774      }
2775    };
2776    HeaderParser.prototype.reset = function() {
2777      this.finished = false;
2778      this.buffer = "";
2779      this.header = {};
2780      this.ss.reset();
2781    };
2782    HeaderParser.prototype._finish = function() {
2783      if (this.buffer) {
2784        this._parseHeader();
2785      }
2786      this.ss.matches = this.ss.maxMatches;
2787      const header = this.header;
2788      this.header = {};
2789      this.buffer = "";
2790      this.finished = true;
2791      this.nread = this.npairs = 0;
2792      this.maxed = false;
2793      this.emit("header", header);
2794    };
2795    HeaderParser.prototype._parseHeader = function() {
2796      if (this.npairs === this.maxHeaderPairs) {
2797        return;
2798      }
2799      const lines = this.buffer.split(RE_CRLF);
2800      const len = lines.length;
2801      let m, h;
2802      for (var i = 0; i < len; ++i) {
2803        if (lines[i].length === 0) {
2804          continue;
2805        }
2806        if (lines[i][0] === "	" || lines[i][0] === " ") {
2807          if (h) {
2808            this.header[h][this.header[h].length - 1] += lines[i];
2809            continue;
2810          }
2811        }
2812        const posColon = lines[i].indexOf(":");
2813        if (posColon === -1 || posColon === 0) {
2814          return;
2815        }
2816        m = RE_HDR.exec(lines[i]);
2817        h = m[1].toLowerCase();
2818        this.header[h] = this.header[h] || [];
2819        this.header[h].push(m[2] || "");
2820        if (++this.npairs === this.maxHeaderPairs) {
2821          break;
2822        }
2823      }
2824    };
2825    module2.exports = HeaderParser;
2826  }
2827});
2828
2829// node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js
2830var require_Dicer = __commonJS({
2831  "node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js"(exports2, module2) {
2832    "use strict";
2833    var WritableStream = require("node:stream").Writable;
2834    var inherits = require("node:util").inherits;
2835    var StreamSearch = require_sbmh();
2836    var PartStream = require_PartStream();
2837    var HeaderParser = require_HeaderParser();
2838    var DASH = 45;
2839    var B_ONEDASH = Buffer.from("-");
2840    var B_CRLF = Buffer.from("\r\n");
2841    var EMPTY_FN = /* @__PURE__ */ __name(function() {
2842    }, "EMPTY_FN");
2843    function Dicer(cfg) {
2844      if (!(this instanceof Dicer)) {
2845        return new Dicer(cfg);
2846      }
2847      WritableStream.call(this, cfg);
2848      if (!cfg || !cfg.headerFirst && typeof cfg.boundary !== "string") {
2849        throw new TypeError("Boundary required");
2850      }
2851      if (typeof cfg.boundary === "string") {
2852        this.setBoundary(cfg.boundary);
2853      } else {
2854        this._bparser = void 0;
2855      }
2856      this._headerFirst = cfg.headerFirst;
2857      this._dashes = 0;
2858      this._parts = 0;
2859      this._finished = false;
2860      this._realFinish = false;
2861      this._isPreamble = true;
2862      this._justMatched = false;
2863      this._firstWrite = true;
2864      this._inHeader = true;
2865      this._part = void 0;
2866      this._cb = void 0;
2867      this._ignoreData = false;
2868      this._partOpts = { highWaterMark: cfg.partHwm };
2869      this._pause = false;
2870      const self = this;
2871      this._hparser = new HeaderParser(cfg);
2872      this._hparser.on("header", function(header) {
2873        self._inHeader = false;
2874        self._part.emit("header", header);
2875      });
2876    }
2877    __name(Dicer, "Dicer");
2878    inherits(Dicer, WritableStream);
2879    Dicer.prototype.emit = function(ev) {
2880      if (ev === "finish" && !this._realFinish) {
2881        if (!this._finished) {
2882          const self = this;
2883          process.nextTick(function() {
2884            self.emit("error", new Error("Unexpected end of multipart data"));
2885            if (self._part && !self._ignoreData) {
2886              const type = self._isPreamble ? "Preamble" : "Part";
2887              self._part.emit("error", new Error(type + " terminated early due to unexpected end of multipart data"));
2888              self._part.push(null);
2889              process.nextTick(function() {
2890                self._realFinish = true;
2891                self.emit("finish");
2892                self._realFinish = false;
2893              });
2894              return;
2895            }
2896            self._realFinish = true;
2897            self.emit("finish");
2898            self._realFinish = false;
2899          });
2900        }
2901      } else {
2902        WritableStream.prototype.emit.apply(this, arguments);
2903      }
2904    };
2905    Dicer.prototype._write = function(data, encoding, cb) {
2906      if (!this._hparser && !this._bparser) {
2907        return cb();
2908      }
2909      if (this._headerFirst && this._isPreamble) {
2910        if (!this._part) {
2911          this._part = new PartStream(this._partOpts);
2912          if (this.listenerCount("preamble") !== 0) {
2913            this.emit("preamble", this._part);
2914          } else {
2915            this._ignore();
2916          }
2917        }
2918        const r = this._hparser.push(data);
2919        if (!this._inHeader && r !== void 0 && r < data.length) {
2920          data = data.slice(r);
2921        } else {
2922          return cb();
2923        }
2924      }
2925      if (this._firstWrite) {
2926        this._bparser.push(B_CRLF);
2927        this._firstWrite = false;
2928      }
2929      this._bparser.push(data);
2930      if (this._pause) {
2931        this._cb = cb;
2932      } else {
2933        cb();
2934      }
2935    };
2936    Dicer.prototype.reset = function() {
2937      this._part = void 0;
2938      this._bparser = void 0;
2939      this._hparser = void 0;
2940    };
2941    Dicer.prototype.setBoundary = function(boundary) {
2942      const self = this;
2943      this._bparser = new StreamSearch("\r\n--" + boundary);
2944      this._bparser.on("info", function(isMatch, data, start, end) {
2945        self._oninfo(isMatch, data, start, end);
2946      });
2947    };
2948    Dicer.prototype._ignore = function() {
2949      if (this._part && !this._ignoreData) {
2950        this._ignoreData = true;
2951        this._part.on("error", EMPTY_FN);
2952        this._part.resume();
2953      }
2954    };
2955    Dicer.prototype._oninfo = function(isMatch, data, start, end) {
2956      let buf;
2957      const self = this;
2958      let i = 0;
2959      let r;
2960      let shouldWriteMore = true;
2961      if (!this._part && this._justMatched && data) {
2962        while (this._dashes < 2 && start + i < end) {
2963          if (data[start + i] === DASH) {
2964            ++i;
2965            ++this._dashes;
2966          } else {
2967            if (this._dashes) {
2968              buf = B_ONEDASH;
2969            }
2970            this._dashes = 0;
2971            break;
2972          }
2973        }
2974        if (this._dashes === 2) {
2975          if (start + i < end && this.listenerCount("trailer") !== 0) {
2976            this.emit("trailer", data.slice(start + i, end));
2977          }
2978          this.reset();
2979          this._finished = true;
2980          if (self._parts === 0) {
2981            self._realFinish = true;
2982            self.emit("finish");
2983            self._realFinish = false;
2984          }
2985        }
2986        if (this._dashes) {
2987          return;
2988        }
2989      }
2990      if (this._justMatched) {
2991        this._justMatched = false;
2992      }
2993      if (!this._part) {
2994        this._part = new PartStream(this._partOpts);
2995        this._part._read = function(n) {
2996          self._unpause();
2997        };
2998        if (this._isPreamble && this.listenerCount("preamble") !== 0) {
2999          this.emit("preamble", this._part);
3000        } else if (this._isPreamble !== true && this.listenerCount("part") !== 0) {
3001          this.emit("part", this._part);
3002        } else {
3003          this._ignore();
3004        }
3005        if (!this._isPreamble) {
3006          this._inHeader = true;
3007        }
3008      }
3009      if (data && start < end && !this._ignoreData) {
3010        if (this._isPreamble || !this._inHeader) {
3011          if (buf) {
3012            shouldWriteMore = this._part.push(buf);
3013          }
3014          shouldWriteMore = this._part.push(data.slice(start, end));
3015          if (!shouldWriteMore) {
3016            this._pause = true;
3017          }
3018        } else if (!this._isPreamble && this._inHeader) {
3019          if (buf) {
3020            this._hparser.push(buf);
3021          }
3022          r = this._hparser.push(data.slice(start, end));
3023          if (!this._inHeader && r !== void 0 && r < end) {
3024            this._oninfo(false, data, start + r, end);
3025          }
3026        }
3027      }
3028      if (isMatch) {
3029        this._hparser.reset();
3030        if (this._isPreamble) {
3031          this._isPreamble = false;
3032        } else {
3033          if (start !== end) {
3034            ++this._parts;
3035            this._part.on("end", function() {
3036              if (--self._parts === 0) {
3037                if (self._finished) {
3038                  self._realFinish = true;
3039                  self.emit("finish");
3040                  self._realFinish = false;
3041                } else {
3042                  self._unpause();
3043                }
3044              }
3045            });
3046          }
3047        }
3048        this._part.push(null);
3049        this._part = void 0;
3050        this._ignoreData = false;
3051        this._justMatched = true;
3052        this._dashes = 0;
3053      }
3054    };
3055    Dicer.prototype._unpause = function() {
3056      if (!this._pause) {
3057        return;
3058      }
3059      this._pause = false;
3060      if (this._cb) {
3061        const cb = this._cb;
3062        this._cb = void 0;
3063        cb();
3064      }
3065    };
3066    module2.exports = Dicer;
3067  }
3068});
3069
3070// node_modules/@fastify/busboy/lib/utils/decodeText.js
3071var require_decodeText = __commonJS({
3072  "node_modules/@fastify/busboy/lib/utils/decodeText.js"(exports2, module2) {
3073    "use strict";
3074    var utf8Decoder = new TextDecoder("utf-8");
3075    var textDecoders = /* @__PURE__ */ new Map([
3076      ["utf-8", utf8Decoder],
3077      ["utf8", utf8Decoder]
3078    ]);
3079    function getDecoder(charset) {
3080      let lc;
3081      while (true) {
3082        switch (charset) {
3083          case "utf-8":
3084          case "utf8":
3085            return decoders.utf8;
3086          case "latin1":
3087          case "ascii":
3088          case "us-ascii":
3089          case "iso-8859-1":
3090          case "iso8859-1":
3091          case "iso88591":
3092          case "iso_8859-1":
3093          case "windows-1252":
3094          case "iso_8859-1:1987":
3095          case "cp1252":
3096          case "x-cp1252":
3097            return decoders.latin1;
3098          case "utf16le":
3099          case "utf-16le":
3100          case "ucs2":
3101          case "ucs-2":
3102            return decoders.utf16le;
3103          case "base64":
3104            return decoders.base64;
3105          default:
3106            if (lc === void 0) {
3107              lc = true;
3108              charset = charset.toLowerCase();
3109              continue;
3110            }
3111            return decoders.other.bind(charset);
3112        }
3113      }
3114    }
3115    __name(getDecoder, "getDecoder");
3116    var decoders = {
3117      utf8: (data, sourceEncoding) => {
3118        if (data.length === 0) {
3119          return "";
3120        }
3121        if (typeof data === "string") {
3122          data = Buffer.from(data, sourceEncoding);
3123        }
3124        return data.utf8Slice(0, data.length);
3125      },
3126      latin1: (data, sourceEncoding) => {
3127        if (data.length === 0) {
3128          return "";
3129        }
3130        if (typeof data === "string") {
3131          return data;
3132        }
3133        return data.latin1Slice(0, data.length);
3134      },
3135      utf16le: (data, sourceEncoding) => {
3136        if (data.length === 0) {
3137          return "";
3138        }
3139        if (typeof data === "string") {
3140          data = Buffer.from(data, sourceEncoding);
3141        }
3142        return data.ucs2Slice(0, data.length);
3143      },
3144      base64: (data, sourceEncoding) => {
3145        if (data.length === 0) {
3146          return "";
3147        }
3148        if (typeof data === "string") {
3149          data = Buffer.from(data, sourceEncoding);
3150        }
3151        return data.base64Slice(0, data.length);
3152      },
3153      other: (data, sourceEncoding) => {
3154        if (data.length === 0) {
3155          return "";
3156        }
3157        if (typeof data === "string") {
3158          data = Buffer.from(data, sourceEncoding);
3159        }
3160        if (textDecoders.has(exports2.toString())) {
3161          try {
3162            return textDecoders.get(exports2).decode(data);
3163          } catch {
3164          }
3165        }
3166        return typeof data === "string" ? data : data.toString();
3167      }
3168    };
3169    function decodeText(text, sourceEncoding, destEncoding) {
3170      if (text) {
3171        return getDecoder(destEncoding)(text, sourceEncoding);
3172      }
3173      return text;
3174    }
3175    __name(decodeText, "decodeText");
3176    module2.exports = decodeText;
3177  }
3178});
3179
3180// node_modules/@fastify/busboy/lib/utils/parseParams.js
3181var require_parseParams = __commonJS({
3182  "node_modules/@fastify/busboy/lib/utils/parseParams.js"(exports2, module2) {
3183    "use strict";
3184    var decodeText = require_decodeText();
3185    var RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g;
3186    var EncodedLookup = {
3187      "%00": "\0",
3188      "%01": "",
3189      "%02": "",
3190      "%03": "",
3191      "%04": "",
3192      "%05": "",
3193      "%06": "",
3194      "%07": "\x07",
3195      "%08": "\b",
3196      "%09": "	",
3197      "%0a": "\n",
3198      "%0A": "\n",
3199      "%0b": "\v",
3200      "%0B": "\v",
3201      "%0c": "\f",
3202      "%0C": "\f",
3203      "%0d": "\r",
3204      "%0D": "\r",
3205      "%0e": "",
3206      "%0E": "",
3207      "%0f": "",
3208      "%0F": "",
3209      "%10": "",
3210      "%11": "",
3211      "%12": "",
3212      "%13": "",
3213      "%14": "",
3214      "%15": "",
3215      "%16": "",
3216      "%17": "",
3217      "%18": "",
3218      "%19": "",
3219      "%1a": "",
3220      "%1A": "",
3221      "%1b": "\x1B",
3222      "%1B": "\x1B",
3223      "%1c": "",
3224      "%1C": "",
3225      "%1d": "",
3226      "%1D": "",
3227      "%1e": "",
3228      "%1E": "",
3229      "%1f": "",
3230      "%1F": "",
3231      "%20": " ",
3232      "%21": "!",
3233      "%22": '"',
3234      "%23": "#",
3235      "%24": "$",
3236      "%25": "%",
3237      "%26": "&",
3238      "%27": "'",
3239      "%28": "(",
3240      "%29": ")",
3241      "%2a": "*",
3242      "%2A": "*",
3243      "%2b": "+",
3244      "%2B": "+",
3245      "%2c": ",",
3246      "%2C": ",",
3247      "%2d": "-",
3248      "%2D": "-",
3249      "%2e": ".",
3250      "%2E": ".",
3251      "%2f": "/",
3252      "%2F": "/",
3253      "%30": "0",
3254      "%31": "1",
3255      "%32": "2",
3256      "%33": "3",
3257      "%34": "4",
3258      "%35": "5",
3259      "%36": "6",
3260      "%37": "7",
3261      "%38": "8",
3262      "%39": "9",
3263      "%3a": ":",
3264      "%3A": ":",
3265      "%3b": ";",
3266      "%3B": ";",
3267      "%3c": "<",
3268      "%3C": "<",
3269      "%3d": "=",
3270      "%3D": "=",
3271      "%3e": ">",
3272      "%3E": ">",
3273      "%3f": "?",
3274      "%3F": "?",
3275      "%40": "@",
3276      "%41": "A",
3277      "%42": "B",
3278      "%43": "C",
3279      "%44": "D",
3280      "%45": "E",
3281      "%46": "F",
3282      "%47": "G",
3283      "%48": "H",
3284      "%49": "I",
3285      "%4a": "J",
3286      "%4A": "J",
3287      "%4b": "K",
3288      "%4B": "K",
3289      "%4c": "L",
3290      "%4C": "L",
3291      "%4d": "M",
3292      "%4D": "M",
3293      "%4e": "N",
3294      "%4E": "N",
3295      "%4f": "O",
3296      "%4F": "O",
3297      "%50": "P",
3298      "%51": "Q",
3299      "%52": "R",
3300      "%53": "S",
3301      "%54": "T",
3302      "%55": "U",
3303      "%56": "V",
3304      "%57": "W",
3305      "%58": "X",
3306      "%59": "Y",
3307      "%5a": "Z",
3308      "%5A": "Z",
3309      "%5b": "[",
3310      "%5B": "[",
3311      "%5c": "\\",
3312      "%5C": "\\",
3313      "%5d": "]",
3314      "%5D": "]",
3315      "%5e": "^",
3316      "%5E": "^",
3317      "%5f": "_",
3318      "%5F": "_",
3319      "%60": "`",
3320      "%61": "a",
3321      "%62": "b",
3322      "%63": "c",
3323      "%64": "d",
3324      "%65": "e",
3325      "%66": "f",
3326      "%67": "g",
3327      "%68": "h",
3328      "%69": "i",
3329      "%6a": "j",
3330      "%6A": "j",
3331      "%6b": "k",
3332      "%6B": "k",
3333      "%6c": "l",
3334      "%6C": "l",
3335      "%6d": "m",
3336      "%6D": "m",
3337      "%6e": "n",
3338      "%6E": "n",
3339      "%6f": "o",
3340      "%6F": "o",
3341      "%70": "p",
3342      "%71": "q",
3343      "%72": "r",
3344      "%73": "s",
3345      "%74": "t",
3346      "%75": "u",
3347      "%76": "v",
3348      "%77": "w",
3349      "%78": "x",
3350      "%79": "y",
3351      "%7a": "z",
3352      "%7A": "z",
3353      "%7b": "{",
3354      "%7B": "{",
3355      "%7c": "|",
3356      "%7C": "|",
3357      "%7d": "}",
3358      "%7D": "}",
3359      "%7e": "~",
3360      "%7E": "~",
3361      "%7f": "\x7F",
3362      "%7F": "\x7F",
3363      "%80": "\x80",
3364      "%81": "\x81",
3365      "%82": "\x82",
3366      "%83": "\x83",
3367      "%84": "\x84",
3368      "%85": "\x85",
3369      "%86": "\x86",
3370      "%87": "\x87",
3371      "%88": "\x88",
3372      "%89": "\x89",
3373      "%8a": "\x8A",
3374      "%8A": "\x8A",
3375      "%8b": "\x8B",
3376      "%8B": "\x8B",
3377      "%8c": "\x8C",
3378      "%8C": "\x8C",
3379      "%8d": "\x8D",
3380      "%8D": "\x8D",
3381      "%8e": "\x8E",
3382      "%8E": "\x8E",
3383      "%8f": "\x8F",
3384      "%8F": "\x8F",
3385      "%90": "\x90",
3386      "%91": "\x91",
3387      "%92": "\x92",
3388      "%93": "\x93",
3389      "%94": "\x94",
3390      "%95": "\x95",
3391      "%96": "\x96",
3392      "%97": "\x97",
3393      "%98": "\x98",
3394      "%99": "\x99",
3395      "%9a": "\x9A",
3396      "%9A": "\x9A",
3397      "%9b": "\x9B",
3398      "%9B": "\x9B",
3399      "%9c": "\x9C",
3400      "%9C": "\x9C",
3401      "%9d": "\x9D",
3402      "%9D": "\x9D",
3403      "%9e": "\x9E",
3404      "%9E": "\x9E",
3405      "%9f": "\x9F",
3406      "%9F": "\x9F",
3407      "%a0": "\xA0",
3408      "%A0": "\xA0",
3409      "%a1": "\xA1",
3410      "%A1": "\xA1",
3411      "%a2": "\xA2",
3412      "%A2": "\xA2",
3413      "%a3": "\xA3",
3414      "%A3": "\xA3",
3415      "%a4": "\xA4",
3416      "%A4": "\xA4",
3417      "%a5": "\xA5",
3418      "%A5": "\xA5",
3419      "%a6": "\xA6",
3420      "%A6": "\xA6",
3421      "%a7": "\xA7",
3422      "%A7": "\xA7",
3423      "%a8": "\xA8",
3424      "%A8": "\xA8",
3425      "%a9": "\xA9",
3426      "%A9": "\xA9",
3427      "%aa": "\xAA",
3428      "%Aa": "\xAA",
3429      "%aA": "\xAA",
3430      "%AA": "\xAA",
3431      "%ab": "\xAB",
3432      "%Ab": "\xAB",
3433      "%aB": "\xAB",
3434      "%AB": "\xAB",
3435      "%ac": "\xAC",
3436      "%Ac": "\xAC",
3437      "%aC": "\xAC",
3438      "%AC": "\xAC",
3439      "%ad": "\xAD",
3440      "%Ad": "\xAD",
3441      "%aD": "\xAD",
3442      "%AD": "\xAD",
3443      "%ae": "\xAE",
3444      "%Ae": "\xAE",
3445      "%aE": "\xAE",
3446      "%AE": "\xAE",
3447      "%af": "\xAF",
3448      "%Af": "\xAF",
3449      "%aF": "\xAF",
3450      "%AF": "\xAF",
3451      "%b0": "\xB0",
3452      "%B0": "\xB0",
3453      "%b1": "\xB1",
3454      "%B1": "\xB1",
3455      "%b2": "\xB2",
3456      "%B2": "\xB2",
3457      "%b3": "\xB3",
3458      "%B3": "\xB3",
3459      "%b4": "\xB4",
3460      "%B4": "\xB4",
3461      "%b5": "\xB5",
3462      "%B5": "\xB5",
3463      "%b6": "\xB6",
3464      "%B6": "\xB6",
3465      "%b7": "\xB7",
3466      "%B7": "\xB7",
3467      "%b8": "\xB8",
3468      "%B8": "\xB8",
3469      "%b9": "\xB9",
3470      "%B9": "\xB9",
3471      "%ba": "\xBA",
3472      "%Ba": "\xBA",
3473      "%bA": "\xBA",
3474      "%BA": "\xBA",
3475      "%bb": "\xBB",
3476      "%Bb": "\xBB",
3477      "%bB": "\xBB",
3478      "%BB": "\xBB",
3479      "%bc": "\xBC",
3480      "%Bc": "\xBC",
3481      "%bC": "\xBC",
3482      "%BC": "\xBC",
3483      "%bd": "\xBD",
3484      "%Bd": "\xBD",
3485      "%bD": "\xBD",
3486      "%BD": "\xBD",
3487      "%be": "\xBE",
3488      "%Be": "\xBE",
3489      "%bE": "\xBE",
3490      "%BE": "\xBE",
3491      "%bf": "\xBF",
3492      "%Bf": "\xBF",
3493      "%bF": "\xBF",
3494      "%BF": "\xBF",
3495      "%c0": "\xC0",
3496      "%C0": "\xC0",
3497      "%c1": "\xC1",
3498      "%C1": "\xC1",
3499      "%c2": "\xC2",
3500      "%C2": "\xC2",
3501      "%c3": "\xC3",
3502      "%C3": "\xC3",
3503      "%c4": "\xC4",
3504      "%C4": "\xC4",
3505      "%c5": "\xC5",
3506      "%C5": "\xC5",
3507      "%c6": "\xC6",
3508      "%C6": "\xC6",
3509      "%c7": "\xC7",
3510      "%C7": "\xC7",
3511      "%c8": "\xC8",
3512      "%C8": "\xC8",
3513      "%c9": "\xC9",
3514      "%C9": "\xC9",
3515      "%ca": "\xCA",
3516      "%Ca": "\xCA",
3517      "%cA": "\xCA",
3518      "%CA": "\xCA",
3519      "%cb": "\xCB",
3520      "%Cb": "\xCB",
3521      "%cB": "\xCB",
3522      "%CB": "\xCB",
3523      "%cc": "\xCC",
3524      "%Cc": "\xCC",
3525      "%cC": "\xCC",
3526      "%CC": "\xCC",
3527      "%cd": "\xCD",
3528      "%Cd": "\xCD",
3529      "%cD": "\xCD",
3530      "%CD": "\xCD",
3531      "%ce": "\xCE",
3532      "%Ce": "\xCE",
3533      "%cE": "\xCE",
3534      "%CE": "\xCE",
3535      "%cf": "\xCF",
3536      "%Cf": "\xCF",
3537      "%cF": "\xCF",
3538      "%CF": "\xCF",
3539      "%d0": "\xD0",
3540      "%D0": "\xD0",
3541      "%d1": "\xD1",
3542      "%D1": "\xD1",
3543      "%d2": "\xD2",
3544      "%D2": "\xD2",
3545      "%d3": "\xD3",
3546      "%D3": "\xD3",
3547      "%d4": "\xD4",
3548      "%D4": "\xD4",
3549      "%d5": "\xD5",
3550      "%D5": "\xD5",
3551      "%d6": "\xD6",
3552      "%D6": "\xD6",
3553      "%d7": "\xD7",
3554      "%D7": "\xD7",
3555      "%d8": "\xD8",
3556      "%D8": "\xD8",
3557      "%d9": "\xD9",
3558      "%D9": "\xD9",
3559      "%da": "\xDA",
3560      "%Da": "\xDA",
3561      "%dA": "\xDA",
3562      "%DA": "\xDA",
3563      "%db": "\xDB",
3564      "%Db": "\xDB",
3565      "%dB": "\xDB",
3566      "%DB": "\xDB",
3567      "%dc": "\xDC",
3568      "%Dc": "\xDC",
3569      "%dC": "\xDC",
3570      "%DC": "\xDC",
3571      "%dd": "\xDD",
3572      "%Dd": "\xDD",
3573      "%dD": "\xDD",
3574      "%DD": "\xDD",
3575      "%de": "\xDE",
3576      "%De": "\xDE",
3577      "%dE": "\xDE",
3578      "%DE": "\xDE",
3579      "%df": "\xDF",
3580      "%Df": "\xDF",
3581      "%dF": "\xDF",
3582      "%DF": "\xDF",
3583      "%e0": "\xE0",
3584      "%E0": "\xE0",
3585      "%e1": "\xE1",
3586      "%E1": "\xE1",
3587      "%e2": "\xE2",
3588      "%E2": "\xE2",
3589      "%e3": "\xE3",
3590      "%E3": "\xE3",
3591      "%e4": "\xE4",
3592      "%E4": "\xE4",
3593      "%e5": "\xE5",
3594      "%E5": "\xE5",
3595      "%e6": "\xE6",
3596      "%E6": "\xE6",
3597      "%e7": "\xE7",
3598      "%E7": "\xE7",
3599      "%e8": "\xE8",
3600      "%E8": "\xE8",
3601      "%e9": "\xE9",
3602      "%E9": "\xE9",
3603      "%ea": "\xEA",
3604      "%Ea": "\xEA",
3605      "%eA": "\xEA",
3606      "%EA": "\xEA",
3607      "%eb": "\xEB",
3608      "%Eb": "\xEB",
3609      "%eB": "\xEB",
3610      "%EB": "\xEB",
3611      "%ec": "\xEC",
3612      "%Ec": "\xEC",
3613      "%eC": "\xEC",
3614      "%EC": "\xEC",
3615      "%ed": "\xED",
3616      "%Ed": "\xED",
3617      "%eD": "\xED",
3618      "%ED": "\xED",
3619      "%ee": "\xEE",
3620      "%Ee": "\xEE",
3621      "%eE": "\xEE",
3622      "%EE": "\xEE",
3623      "%ef": "\xEF",
3624      "%Ef": "\xEF",
3625      "%eF": "\xEF",
3626      "%EF": "\xEF",
3627      "%f0": "\xF0",
3628      "%F0": "\xF0",
3629      "%f1": "\xF1",
3630      "%F1": "\xF1",
3631      "%f2": "\xF2",
3632      "%F2": "\xF2",
3633      "%f3": "\xF3",
3634      "%F3": "\xF3",
3635      "%f4": "\xF4",
3636      "%F4": "\xF4",
3637      "%f5": "\xF5",
3638      "%F5": "\xF5",
3639      "%f6": "\xF6",
3640      "%F6": "\xF6",
3641      "%f7": "\xF7",
3642      "%F7": "\xF7",
3643      "%f8": "\xF8",
3644      "%F8": "\xF8",
3645      "%f9": "\xF9",
3646      "%F9": "\xF9",
3647      "%fa": "\xFA",
3648      "%Fa": "\xFA",
3649      "%fA": "\xFA",
3650      "%FA": "\xFA",
3651      "%fb": "\xFB",
3652      "%Fb": "\xFB",
3653      "%fB": "\xFB",
3654      "%FB": "\xFB",
3655      "%fc": "\xFC",
3656      "%Fc": "\xFC",
3657      "%fC": "\xFC",
3658      "%FC": "\xFC",
3659      "%fd": "\xFD",
3660      "%Fd": "\xFD",
3661      "%fD": "\xFD",
3662      "%FD": "\xFD",
3663      "%fe": "\xFE",
3664      "%Fe": "\xFE",
3665      "%fE": "\xFE",
3666      "%FE": "\xFE",
3667      "%ff": "\xFF",
3668      "%Ff": "\xFF",
3669      "%fF": "\xFF",
3670      "%FF": "\xFF"
3671    };
3672    function encodedReplacer(match) {
3673      return EncodedLookup[match];
3674    }
3675    __name(encodedReplacer, "encodedReplacer");
3676    var STATE_KEY = 0;
3677    var STATE_VALUE = 1;
3678    var STATE_CHARSET = 2;
3679    var STATE_LANG = 3;
3680    function parseParams(str) {
3681      const res = [];
3682      let state = STATE_KEY;
3683      let charset = "";
3684      let inquote = false;
3685      let escaping = false;
3686      let p = 0;
3687      let tmp = "";
3688      const len = str.length;
3689      for (var i = 0; i < len; ++i) {
3690        const char = str[i];
3691        if (char === "\\" && inquote) {
3692          if (escaping) {
3693            escaping = false;
3694          } else {
3695            escaping = true;
3696            continue;
3697          }
3698        } else if (char === '"') {
3699          if (!escaping) {
3700            if (inquote) {
3701              inquote = false;
3702              state = STATE_KEY;
3703            } else {
3704              inquote = true;
3705            }
3706            continue;
3707          } else {
3708            escaping = false;
3709          }
3710        } else {
3711          if (escaping && inquote) {
3712            tmp += "\\";
3713          }
3714          escaping = false;
3715          if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") {
3716            if (state === STATE_CHARSET) {
3717              state = STATE_LANG;
3718              charset = tmp.substring(1);
3719            } else {
3720              state = STATE_VALUE;
3721            }
3722            tmp = "";
3723            continue;
3724          } else if (state === STATE_KEY && (char === "*" || char === "=") && res.length) {
3725            state = char === "*" ? STATE_CHARSET : STATE_VALUE;
3726            res[p] = [tmp, void 0];
3727            tmp = "";
3728            continue;
3729          } else if (!inquote && char === ";") {
3730            state = STATE_KEY;
3731            if (charset) {
3732              if (tmp.length) {
3733                tmp = decodeText(
3734                  tmp.replace(RE_ENCODED, encodedReplacer),
3735                  "binary",
3736                  charset
3737                );
3738              }
3739              charset = "";
3740            } else if (tmp.length) {
3741              tmp = decodeText(tmp, "binary", "utf8");
3742            }
3743            if (res[p] === void 0) {
3744              res[p] = tmp;
3745            } else {
3746              res[p][1] = tmp;
3747            }
3748            tmp = "";
3749            ++p;
3750            continue;
3751          } else if (!inquote && (char === " " || char === "	")) {
3752            continue;
3753          }
3754        }
3755        tmp += char;
3756      }
3757      if (charset && tmp.length) {
3758        tmp = decodeText(
3759          tmp.replace(RE_ENCODED, encodedReplacer),
3760          "binary",
3761          charset
3762        );
3763      } else if (tmp) {
3764        tmp = decodeText(tmp, "binary", "utf8");
3765      }
3766      if (res[p] === void 0) {
3767        if (tmp) {
3768          res[p] = tmp;
3769        }
3770      } else {
3771        res[p][1] = tmp;
3772      }
3773      return res;
3774    }
3775    __name(parseParams, "parseParams");
3776    module2.exports = parseParams;
3777  }
3778});
3779
3780// node_modules/@fastify/busboy/lib/utils/basename.js
3781var require_basename = __commonJS({
3782  "node_modules/@fastify/busboy/lib/utils/basename.js"(exports2, module2) {
3783    "use strict";
3784    module2.exports = /* @__PURE__ */ __name(function basename(path) {
3785      if (typeof path !== "string") {
3786        return "";
3787      }
3788      for (var i = path.length - 1; i >= 0; --i) {
3789        switch (path.charCodeAt(i)) {
3790          case 47:
3791          case 92:
3792            path = path.slice(i + 1);
3793            return path === ".." || path === "." ? "" : path;
3794        }
3795      }
3796      return path === ".." || path === "." ? "" : path;
3797    }, "basename");
3798  }
3799});
3800
3801// node_modules/@fastify/busboy/lib/types/multipart.js
3802var require_multipart = __commonJS({
3803  "node_modules/@fastify/busboy/lib/types/multipart.js"(exports2, module2) {
3804    "use strict";
3805    var { Readable } = require("node:stream");
3806    var { inherits } = require("node:util");
3807    var Dicer = require_Dicer();
3808    var parseParams = require_parseParams();
3809    var decodeText = require_decodeText();
3810    var basename = require_basename();
3811    var getLimit = require_getLimit();
3812    var RE_BOUNDARY = /^boundary$/i;
3813    var RE_FIELD = /^form-data$/i;
3814    var RE_CHARSET = /^charset$/i;
3815    var RE_FILENAME = /^filename$/i;
3816    var RE_NAME = /^name$/i;
3817    Multipart.detect = /^multipart\/form-data/i;
3818    function Multipart(boy, cfg) {
3819      let i;
3820      let len;
3821      const self = this;
3822      let boundary;
3823      const limits = cfg.limits;
3824      const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => contentType === "application/octet-stream" || fileName !== void 0);
3825      const parsedConType = cfg.parsedConType || [];
3826      const defCharset = cfg.defCharset || "utf8";
3827      const preservePath = cfg.preservePath;
3828      const fileOpts = { highWaterMark: cfg.fileHwm };
3829      for (i = 0, len = parsedConType.length; i < len; ++i) {
3830        if (Array.isArray(parsedConType[i]) && RE_BOUNDARY.test(parsedConType[i][0])) {
3831          boundary = parsedConType[i][1];
3832          break;
3833        }
3834      }
3835      function checkFinished() {
3836        if (nends === 0 && finished && !boy._done) {
3837          finished = false;
3838          self.end();
3839        }
3840      }
3841      __name(checkFinished, "checkFinished");
3842      if (typeof boundary !== "string") {
3843        throw new Error("Multipart: Boundary not found");
3844      }
3845      const fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024);
3846      const fileSizeLimit = getLimit(limits, "fileSize", Infinity);
3847      const filesLimit = getLimit(limits, "files", Infinity);
3848      const fieldsLimit = getLimit(limits, "fields", Infinity);
3849      const partsLimit = getLimit(limits, "parts", Infinity);
3850      const headerPairsLimit = getLimit(limits, "headerPairs", 2e3);
3851      const headerSizeLimit = getLimit(limits, "headerSize", 80 * 1024);
3852      let nfiles = 0;
3853      let nfields = 0;
3854      let nends = 0;
3855      let curFile;
3856      let curField;
3857      let finished = false;
3858      this._needDrain = false;
3859      this._pause = false;
3860      this._cb = void 0;
3861      this._nparts = 0;
3862      this._boy = boy;
3863      const parserCfg = {
3864        boundary,
3865        maxHeaderPairs: headerPairsLimit,
3866        maxHeaderSize: headerSizeLimit,
3867        partHwm: fileOpts.highWaterMark,
3868        highWaterMark: cfg.highWaterMark
3869      };
3870      this.parser = new Dicer(parserCfg);
3871      this.parser.on("drain", function() {
3872        self._needDrain = false;
3873        if (self._cb && !self._pause) {
3874          const cb = self._cb;
3875          self._cb = void 0;
3876          cb();
3877        }
3878      }).on("part", /* @__PURE__ */ __name(function onPart(part) {
3879        if (++self._nparts > partsLimit) {
3880          self.parser.removeListener("part", onPart);
3881          self.parser.on("part", skipPart);
3882          boy.hitPartsLimit = true;
3883          boy.emit("partsLimit");
3884          return skipPart(part);
3885        }
3886        if (curField) {
3887          const field = curField;
3888          field.emit("end");
3889          field.removeAllListeners("end");
3890        }
3891        part.on("header", function(header) {
3892          let contype;
3893          let fieldname;
3894          let parsed;
3895          let charset;
3896          let encoding;
3897          let filename;
3898          let nsize = 0;
3899          if (header["content-type"]) {
3900            parsed = parseParams(header["content-type"][0]);
3901            if (parsed[0]) {
3902              contype = parsed[0].toLowerCase();
3903              for (i = 0, len = parsed.length; i < len; ++i) {
3904                if (RE_CHARSET.test(parsed[i][0])) {
3905                  charset = parsed[i][1].toLowerCase();
3906                  break;
3907                }
3908              }
3909            }
3910          }
3911          if (contype === void 0) {
3912            contype = "text/plain";
3913          }
3914          if (charset === void 0) {
3915            charset = defCharset;
3916          }
3917          if (header["content-disposition"]) {
3918            parsed = parseParams(header["content-disposition"][0]);
3919            if (!RE_FIELD.test(parsed[0])) {
3920              return skipPart(part);
3921            }
3922            for (i = 0, len = parsed.length; i < len; ++i) {
3923              if (RE_NAME.test(parsed[i][0])) {
3924                fieldname = parsed[i][1];
3925              } else if (RE_FILENAME.test(parsed[i][0])) {
3926                filename = parsed[i][1];
3927                if (!preservePath) {
3928                  filename = basename(filename);
3929                }
3930              }
3931            }
3932          } else {
3933            return skipPart(part);
3934          }
3935          if (header["content-transfer-encoding"]) {
3936            encoding = header["content-transfer-encoding"][0].toLowerCase();
3937          } else {
3938            encoding = "7bit";
3939          }
3940          let onData, onEnd;
3941          if (isPartAFile(fieldname, contype, filename)) {
3942            if (nfiles === filesLimit) {
3943              if (!boy.hitFilesLimit) {
3944                boy.hitFilesLimit = true;
3945                boy.emit("filesLimit");
3946              }
3947              return skipPart(part);
3948            }
3949            ++nfiles;
3950            if (boy.listenerCount("file") === 0) {
3951              self.parser._ignore();
3952              return;
3953            }
3954            ++nends;
3955            const file = new FileStream(fileOpts);
3956            curFile = file;
3957            file.on("end", function() {
3958              --nends;
3959              self._pause = false;
3960              checkFinished();
3961              if (self._cb && !self._needDrain) {
3962                const cb = self._cb;
3963                self._cb = void 0;
3964                cb();
3965              }
3966            });
3967            file._read = function(n) {
3968              if (!self._pause) {
3969                return;
3970              }
3971              self._pause = false;
3972              if (self._cb && !self._needDrain) {
3973                const cb = self._cb;
3974                self._cb = void 0;
3975                cb();
3976              }
3977            };
3978            boy.emit("file", fieldname, file, filename, encoding, contype);
3979            onData = /* @__PURE__ */ __name(function(data) {
3980              if ((nsize += data.length) > fileSizeLimit) {
3981                const extralen = fileSizeLimit - nsize + data.length;
3982                if (extralen > 0) {
3983                  file.push(data.slice(0, extralen));
3984                }
3985                file.truncated = true;
3986                file.bytesRead = fileSizeLimit;
3987                part.removeAllListeners("data");
3988                file.emit("limit");
3989                return;
3990              } else if (!file.push(data)) {
3991                self._pause = true;
3992              }
3993              file.bytesRead = nsize;
3994            }, "onData");
3995            onEnd = /* @__PURE__ */ __name(function() {
3996              curFile = void 0;
3997              file.push(null);
3998            }, "onEnd");
3999          } else {
4000            if (nfields === fieldsLimit) {
4001              if (!boy.hitFieldsLimit) {
4002                boy.hitFieldsLimit = true;
4003                boy.emit("fieldsLimit");
4004              }
4005              return skipPart(part);
4006            }
4007            ++nfields;
4008            ++nends;
4009            let buffer = "";
4010            let truncated = false;
4011            curField = part;
4012            onData = /* @__PURE__ */ __name(function(data) {
4013              if ((nsize += data.length) > fieldSizeLimit) {
4014                const extralen = fieldSizeLimit - (nsize - data.length);
4015                buffer += data.toString("binary", 0, extralen);
4016                truncated = true;
4017                part.removeAllListeners("data");
4018              } else {
4019                buffer += data.toString("binary");
4020              }
4021            }, "onData");
4022            onEnd = /* @__PURE__ */ __name(function() {
4023              curField = void 0;
4024              if (buffer.length) {
4025                buffer = decodeText(buffer, "binary", charset);
4026              }
4027              boy.emit("field", fieldname, buffer, false, truncated, encoding, contype);
4028              --nends;
4029              checkFinished();
4030            }, "onEnd");
4031          }
4032          part._readableState.sync = false;
4033          part.on("data", onData);
4034          part.on("end", onEnd);
4035        }).on("error", function(err) {
4036          if (curFile) {
4037            curFile.emit("error", err);
4038          }
4039        });
4040      }, "onPart")).on("error", function(err) {
4041        boy.emit("error", err);
4042      }).on("finish", function() {
4043        finished = true;
4044        checkFinished();
4045      });
4046    }
4047    __name(Multipart, "Multipart");
4048    Multipart.prototype.write = function(chunk, cb) {
4049      const r = this.parser.write(chunk);
4050      if (r && !this._pause) {
4051        cb();
4052      } else {
4053        this._needDrain = !r;
4054        this._cb = cb;
4055      }
4056    };
4057    Multipart.prototype.end = function() {
4058      const self = this;
4059      if (self.parser.writable) {
4060        self.parser.end();
4061      } else if (!self._boy._done) {
4062        process.nextTick(function() {
4063          self._boy._done = true;
4064          self._boy.emit("finish");
4065        });
4066      }
4067    };
4068    function skipPart(part) {
4069      part.resume();
4070    }
4071    __name(skipPart, "skipPart");
4072    function FileStream(opts) {
4073      Readable.call(this, opts);
4074      this.bytesRead = 0;
4075      this.truncated = false;
4076    }
4077    __name(FileStream, "FileStream");
4078    inherits(FileStream, Readable);
4079    FileStream.prototype._read = function(n) {
4080    };
4081    module2.exports = Multipart;
4082  }
4083});
4084
4085// node_modules/@fastify/busboy/lib/utils/Decoder.js
4086var require_Decoder = __commonJS({
4087  "node_modules/@fastify/busboy/lib/utils/Decoder.js"(exports2, module2) {
4088    "use strict";
4089    var RE_PLUS = /\+/g;
4090    var HEX = [
4091      0,
4092      0,
4093      0,
4094      0,
4095      0,
4096      0,
4097      0,
4098      0,
4099      0,
4100      0,
4101      0,
4102      0,
4103      0,
4104      0,
4105      0,
4106      0,
4107      0,
4108      0,
4109      0,
4110      0,
4111      0,
4112      0,
4113      0,
4114      0,
4115      0,
4116      0,
4117      0,
4118      0,
4119      0,
4120      0,
4121      0,
4122      0,
4123      0,
4124      0,
4125      0,
4126      0,
4127      0,
4128      0,
4129      0,
4130      0,
4131      0,
4132      0,
4133      0,
4134      0,
4135      0,
4136      0,
4137      0,
4138      0,
4139      1,
4140      1,
4141      1,
4142      1,
4143      1,
4144      1,
4145      1,
4146      1,
4147      1,
4148      1,
4149      0,
4150      0,
4151      0,
4152      0,
4153      0,
4154      0,
4155      0,
4156      1,
4157      1,
4158      1,
4159      1,
4160      1,
4161      1,
4162      0,
4163      0,
4164      0,
4165      0,
4166      0,
4167      0,
4168      0,
4169      0,
4170      0,
4171      0,
4172      0,
4173      0,
4174      0,
4175      0,
4176      0,
4177      0,
4178      0,
4179      0,
4180      0,
4181      0,
4182      0,
4183      0,
4184      0,
4185      0,
4186      0,
4187      0,
4188      1,
4189      1,
4190      1,
4191      1,
4192      1,
4193      1,
4194      0,
4195      0,
4196      0,
4197      0,
4198      0,
4199      0,
4200      0,
4201      0,
4202      0,
4203      0,
4204      0,
4205      0,
4206      0,
4207      0,
4208      0,
4209      0,
4210      0,
4211      0,
4212      0,
4213      0,
4214      0,
4215      0,
4216      0,
4217      0,
4218      0
4219    ];
4220    function Decoder() {
4221      this.buffer = void 0;
4222    }
4223    __name(Decoder, "Decoder");
4224    Decoder.prototype.write = function(str) {
4225      str = str.replace(RE_PLUS, " ");
4226      let res = "";
4227      let i = 0;
4228      let p = 0;
4229      const len = str.length;
4230      for (; i < len; ++i) {
4231        if (this.buffer !== void 0) {
4232          if (!HEX[str.charCodeAt(i)]) {
4233            res += "%" + this.buffer;
4234            this.buffer = void 0;
4235            --i;
4236          } else {
4237            this.buffer += str[i];
4238            ++p;
4239            if (this.buffer.length === 2) {
4240              res += String.fromCharCode(parseInt(this.buffer, 16));
4241              this.buffer = void 0;
4242            }
4243          }
4244        } else if (str[i] === "%") {
4245          if (i > p) {
4246            res += str.substring(p, i);
4247            p = i;
4248          }
4249          this.buffer = "";
4250          ++p;
4251        }
4252      }
4253      if (p < len && this.buffer === void 0) {
4254        res += str.substring(p);
4255      }
4256      return res;
4257    };
4258    Decoder.prototype.reset = function() {
4259      this.buffer = void 0;
4260    };
4261    module2.exports = Decoder;
4262  }
4263});
4264
4265// node_modules/@fastify/busboy/lib/types/urlencoded.js
4266var require_urlencoded = __commonJS({
4267  "node_modules/@fastify/busboy/lib/types/urlencoded.js"(exports2, module2) {
4268    "use strict";
4269    var Decoder = require_Decoder();
4270    var decodeText = require_decodeText();
4271    var getLimit = require_getLimit();
4272    var RE_CHARSET = /^charset$/i;
4273    UrlEncoded.detect = /^application\/x-www-form-urlencoded/i;
4274    function UrlEncoded(boy, cfg) {
4275      const limits = cfg.limits;
4276      const parsedConType = cfg.parsedConType;
4277      this.boy = boy;
4278      this.fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024);
4279      this.fieldNameSizeLimit = getLimit(limits, "fieldNameSize", 100);
4280      this.fieldsLimit = getLimit(limits, "fields", Infinity);
4281      let charset;
4282      for (var i = 0, len = parsedConType.length; i < len; ++i) {
4283        if (Array.isArray(parsedConType[i]) && RE_CHARSET.test(parsedConType[i][0])) {
4284          charset = parsedConType[i][1].toLowerCase();
4285          break;
4286        }
4287      }
4288      if (charset === void 0) {
4289        charset = cfg.defCharset || "utf8";
4290      }
4291      this.decoder = new Decoder();
4292      this.charset = charset;
4293      this._fields = 0;
4294      this._state = "key";
4295      this._checkingBytes = true;
4296      this._bytesKey = 0;
4297      this._bytesVal = 0;
4298      this._key = "";
4299      this._val = "";
4300      this._keyTrunc = false;
4301      this._valTrunc = false;
4302      this._hitLimit = false;
4303    }
4304    __name(UrlEncoded, "UrlEncoded");
4305    UrlEncoded.prototype.write = function(data, cb) {
4306      if (this._fields === this.fieldsLimit) {
4307        if (!this.boy.hitFieldsLimit) {
4308          this.boy.hitFieldsLimit = true;
4309          this.boy.emit("fieldsLimit");
4310        }
4311        return cb();
4312      }
4313      let idxeq;
4314      let idxamp;
4315      let i;
4316      let p = 0;
4317      const len = data.length;
4318      while (p < len) {
4319        if (this._state === "key") {
4320          idxeq = idxamp = void 0;
4321          for (i = p; i < len; ++i) {
4322            if (!this._checkingBytes) {
4323              ++p;
4324            }
4325            if (data[i] === 61) {
4326              idxeq = i;
4327              break;
4328            } else if (data[i] === 38) {
4329              idxamp = i;
4330              break;
4331            }
4332            if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) {
4333              this._hitLimit = true;
4334              break;
4335            } else if (this._checkingBytes) {
4336              ++this._bytesKey;
4337            }
4338          }
4339          if (idxeq !== void 0) {
4340            if (idxeq > p) {
4341              this._key += this.decoder.write(data.toString("binary", p, idxeq));
4342            }
4343            this._state = "val";
4344            this._hitLimit = false;
4345            this._checkingBytes = true;
4346            this._val = "";
4347            this._bytesVal = 0;
4348            this._valTrunc = false;
4349            this.decoder.reset();
4350            p = idxeq + 1;
4351          } else if (idxamp !== void 0) {
4352            ++this._fields;
4353            let key;
4354            const keyTrunc = this._keyTrunc;
4355            if (idxamp > p) {
4356              key = this._key += this.decoder.write(data.toString("binary", p, idxamp));
4357            } else {
4358              key = this._key;
4359            }
4360            this._hitLimit = false;
4361            this._checkingBytes = true;
4362            this._key = "";
4363            this._bytesKey = 0;
4364            this._keyTrunc = false;
4365            this.decoder.reset();
4366            if (key.length) {
4367              this.boy.emit(
4368                "field",
4369                decodeText(key, "binary", this.charset),
4370                "",
4371                keyTrunc,
4372                false
4373              );
4374            }
4375            p = idxamp + 1;
4376            if (this._fields === this.fieldsLimit) {
4377              return cb();
4378            }
4379          } else if (this._hitLimit) {
4380            if (i > p) {
4381              this._key += this.decoder.write(data.toString("binary", p, i));
4382            }
4383            p = i;
4384            if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) {
4385              this._checkingBytes = false;
4386              this._keyTrunc = true;
4387            }
4388          } else {
4389            if (p < len) {
4390              this._key += this.decoder.write(data.toString("binary", p));
4391            }
4392            p = len;
4393          }
4394        } else {
4395          idxamp = void 0;
4396          for (i = p; i < len; ++i) {
4397            if (!this._checkingBytes) {
4398              ++p;
4399            }
4400            if (data[i] === 38) {
4401              idxamp = i;
4402              break;
4403            }
4404            if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) {
4405              this._hitLimit = true;
4406              break;
4407            } else if (this._checkingBytes) {
4408              ++this._bytesVal;
4409            }
4410          }
4411          if (idxamp !== void 0) {
4412            ++this._fields;
4413            if (idxamp > p) {
4414              this._val += this.decoder.write(data.toString("binary", p, idxamp));
4415            }
4416            this.boy.emit(
4417              "field",
4418              decodeText(this._key, "binary", this.charset),
4419              decodeText(this._val, "binary", this.charset),
4420              this._keyTrunc,
4421              this._valTrunc
4422            );
4423            this._state = "key";
4424            this._hitLimit = false;
4425            this._checkingBytes = true;
4426            this._key = "";
4427            this._bytesKey = 0;
4428            this._keyTrunc = false;
4429            this.decoder.reset();
4430            p = idxamp + 1;
4431            if (this._fields === this.fieldsLimit) {
4432              return cb();
4433            }
4434          } else if (this._hitLimit) {
4435            if (i > p) {
4436              this._val += this.decoder.write(data.toString("binary", p, i));
4437            }
4438            p = i;
4439            if (this._val === "" && this.fieldSizeLimit === 0 || (this._bytesVal = this._val.length) === this.fieldSizeLimit) {
4440              this._checkingBytes = false;
4441              this._valTrunc = true;
4442            }
4443          } else {
4444            if (p < len) {
4445              this._val += this.decoder.write(data.toString("binary", p));
4446            }
4447            p = len;
4448          }
4449        }
4450      }
4451      cb();
4452    };
4453    UrlEncoded.prototype.end = function() {
4454      if (this.boy._done) {
4455        return;
4456      }
4457      if (this._state === "key" && this._key.length > 0) {
4458        this.boy.emit(
4459          "field",
4460          decodeText(this._key, "binary", this.charset),
4461          "",
4462          this._keyTrunc,
4463          false
4464        );
4465      } else if (this._state === "val") {
4466        this.boy.emit(
4467          "field",
4468          decodeText(this._key, "binary", this.charset),
4469          decodeText(this._val, "binary", this.charset),
4470          this._keyTrunc,
4471          this._valTrunc
4472        );
4473      }
4474      this.boy._done = true;
4475      this.boy.emit("finish");
4476    };
4477    module2.exports = UrlEncoded;
4478  }
4479});
4480
4481// node_modules/@fastify/busboy/lib/main.js
4482var require_main = __commonJS({
4483  "node_modules/@fastify/busboy/lib/main.js"(exports2, module2) {
4484    "use strict";
4485    var WritableStream = require("node:stream").Writable;
4486    var { inherits } = require("node:util");
4487    var Dicer = require_Dicer();
4488    var MultipartParser = require_multipart();
4489    var UrlencodedParser = require_urlencoded();
4490    var parseParams = require_parseParams();
4491    function Busboy(opts) {
4492      if (!(this instanceof Busboy)) {
4493        return new Busboy(opts);
4494      }
4495      if (typeof opts !== "object") {
4496        throw new TypeError("Busboy expected an options-Object.");
4497      }
4498      if (typeof opts.headers !== "object") {
4499        throw new TypeError("Busboy expected an options-Object with headers-attribute.");
4500      }
4501      if (typeof opts.headers["content-type"] !== "string") {
4502        throw new TypeError("Missing Content-Type-header.");
4503      }
4504      const {
4505        headers,
4506        ...streamOptions
4507      } = opts;
4508      this.opts = {
4509        autoDestroy: false,
4510        ...streamOptions
4511      };
4512      WritableStream.call(this, this.opts);
4513      this._done = false;
4514      this._parser = this.getParserByHeaders(headers);
4515      this._finished = false;
4516    }
4517    __name(Busboy, "Busboy");
4518    inherits(Busboy, WritableStream);
4519    Busboy.prototype.emit = function(ev) {
4520      if (ev === "finish") {
4521        if (!this._done) {
4522          this._parser?.end();
4523          return;
4524        } else if (this._finished) {
4525          return;
4526        }
4527        this._finished = true;
4528      }
4529      WritableStream.prototype.emit.apply(this, arguments);
4530    };
4531    Busboy.prototype.getParserByHeaders = function(headers) {
4532      const parsed = parseParams(headers["content-type"]);
4533      const cfg = {
4534        defCharset: this.opts.defCharset,
4535        fileHwm: this.opts.fileHwm,
4536        headers,
4537        highWaterMark: this.opts.highWaterMark,
4538        isPartAFile: this.opts.isPartAFile,
4539        limits: this.opts.limits,
4540        parsedConType: parsed,
4541        preservePath: this.opts.preservePath
4542      };
4543      if (MultipartParser.detect.test(parsed[0])) {
4544        return new MultipartParser(this, cfg);
4545      }
4546      if (UrlencodedParser.detect.test(parsed[0])) {
4547        return new UrlencodedParser(this, cfg);
4548      }
4549      throw new Error("Unsupported Content-Type.");
4550    };
4551    Busboy.prototype._write = function(chunk, encoding, cb) {
4552      this._parser.write(chunk, cb);
4553    };
4554    module2.exports = Busboy;
4555    module2.exports.default = Busboy;
4556    module2.exports.Busboy = Busboy;
4557    module2.exports.Dicer = Dicer;
4558  }
4559});
4560
4561// lib/fetch/dataURL.js
4562var require_dataURL = __commonJS({
4563  "lib/fetch/dataURL.js"(exports2, module2) {
4564    var assert = require("assert");
4565    var { atob: atob2 } = require("buffer");
4566    var { isomorphicDecode } = require_util2();
4567    var encoder = new TextEncoder();
4568    var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-Za-z0-9]+$/;
4569    var HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/;
4570    var HTTP_QUOTED_STRING_TOKENS = /[\u0009|\u0020-\u007E|\u0080-\u00FF]/;
4571    function dataURLProcessor(dataURL) {
4572      assert(dataURL.protocol === "data:");
4573      let input = URLSerializer(dataURL, true);
4574      input = input.slice(5);
4575      const position = { position: 0 };
4576      let mimeType = collectASequenceOfCodePointsFast(
4577        ",",
4578        input,
4579        position
4580      );
4581      const mimeTypeLength = mimeType.length;
4582      mimeType = removeASCIIWhitespace(mimeType, true, true);
4583      if (position.position >= input.length) {
4584        return "failure";
4585      }
4586      position.position++;
4587      const encodedBody = input.slice(mimeTypeLength + 1);
4588      let body = stringPercentDecode(encodedBody);
4589      if (/;(\u0020){0,}base64$/i.test(mimeType)) {
4590        const stringBody = isomorphicDecode(body);
4591        body = forgivingBase64(stringBody);
4592        if (body === "failure") {
4593          return "failure";
4594        }
4595        mimeType = mimeType.slice(0, -6);
4596        mimeType = mimeType.replace(/(\u0020)+$/, "");
4597        mimeType = mimeType.slice(0, -1);
4598      }
4599      if (mimeType.startsWith(";")) {
4600        mimeType = "text/plain" + mimeType;
4601      }
4602      let mimeTypeRecord = parseMIMEType(mimeType);
4603      if (mimeTypeRecord === "failure") {
4604        mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII");
4605      }
4606      return { mimeType: mimeTypeRecord, body };
4607    }
4608    __name(dataURLProcessor, "dataURLProcessor");
4609    function URLSerializer(url, excludeFragment = false) {
4610      if (!excludeFragment) {
4611        return url.href;
4612      }
4613      const href = url.href;
4614      const hashLength = url.hash.length;
4615      return hashLength === 0 ? href : href.substring(0, href.length - hashLength);
4616    }
4617    __name(URLSerializer, "URLSerializer");
4618    function collectASequenceOfCodePoints(condition, input, position) {
4619      let result = "";
4620      while (position.position < input.length && condition(input[position.position])) {
4621        result += input[position.position];
4622        position.position++;
4623      }
4624      return result;
4625    }
4626    __name(collectASequenceOfCodePoints, "collectASequenceOfCodePoints");
4627    function collectASequenceOfCodePointsFast(char, input, position) {
4628      const idx = input.indexOf(char, position.position);
4629      const start = position.position;
4630      if (idx === -1) {
4631        position.position = input.length;
4632        return input.slice(start);
4633      }
4634      position.position = idx;
4635      return input.slice(start, position.position);
4636    }
4637    __name(collectASequenceOfCodePointsFast, "collectASequenceOfCodePointsFast");
4638    function stringPercentDecode(input) {
4639      const bytes = encoder.encode(input);
4640      return percentDecode(bytes);
4641    }
4642    __name(stringPercentDecode, "stringPercentDecode");
4643    function percentDecode(input) {
4644      const output = [];
4645      for (let i = 0; i < input.length; i++) {
4646        const byte = input[i];
4647        if (byte !== 37) {
4648          output.push(byte);
4649        } else if (byte === 37 && !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i + 1], input[i + 2]))) {
4650          output.push(37);
4651        } else {
4652          const nextTwoBytes = String.fromCharCode(input[i + 1], input[i + 2]);
4653          const bytePoint = Number.parseInt(nextTwoBytes, 16);
4654          output.push(bytePoint);
4655          i += 2;
4656        }
4657      }
4658      return Uint8Array.from(output);
4659    }
4660    __name(percentDecode, "percentDecode");
4661    function parseMIMEType(input) {
4662      input = removeHTTPWhitespace(input, true, true);
4663      const position = { position: 0 };
4664      const type = collectASequenceOfCodePointsFast(
4665        "/",
4666        input,
4667        position
4668      );
4669      if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
4670        return "failure";
4671      }
4672      if (position.position > input.length) {
4673        return "failure";
4674      }
4675      position.position++;
4676      let subtype = collectASequenceOfCodePointsFast(
4677        ";",
4678        input,
4679        position
4680      );
4681      subtype = removeHTTPWhitespace(subtype, false, true);
4682      if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
4683        return "failure";
4684      }
4685      const typeLowercase = type.toLowerCase();
4686      const subtypeLowercase = subtype.toLowerCase();
4687      const mimeType = {
4688        type: typeLowercase,
4689        subtype: subtypeLowercase,
4690        /** @type {Map<string, string>} */
4691        parameters: /* @__PURE__ */ new Map(),
4692        // https://mimesniff.spec.whatwg.org/#mime-type-essence
4693        essence: `${typeLowercase}/${subtypeLowercase}`
4694      };
4695      while (position.position < input.length) {
4696        position.position++;
4697        collectASequenceOfCodePoints(
4698          // https://fetch.spec.whatwg.org/#http-whitespace
4699          (char) => HTTP_WHITESPACE_REGEX.test(char),
4700          input,
4701          position
4702        );
4703        let parameterName = collectASequenceOfCodePoints(
4704          (char) => char !== ";" && char !== "=",
4705          input,
4706          position
4707        );
4708        parameterName = parameterName.toLowerCase();
4709        if (position.position < input.length) {
4710          if (input[position.position] === ";") {
4711            continue;
4712          }
4713          position.position++;
4714        }
4715        if (position.position > input.length) {
4716          break;
4717        }
4718        let parameterValue = null;
4719        if (input[position.position] === '"') {
4720          parameterValue = collectAnHTTPQuotedString(input, position, true);
4721          collectASequenceOfCodePointsFast(
4722            ";",
4723            input,
4724            position
4725          );
4726        } else {
4727          parameterValue = collectASequenceOfCodePointsFast(
4728            ";",
4729            input,
4730            position
4731          );
4732          parameterValue = removeHTTPWhitespace(parameterValue, false, true);
4733          if (parameterValue.length === 0) {
4734            continue;
4735          }
4736        }
4737        if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) {
4738          mimeType.parameters.set(parameterName, parameterValue);
4739        }
4740      }
4741      return mimeType;
4742    }
4743    __name(parseMIMEType, "parseMIMEType");
4744    function forgivingBase64(data) {
4745      data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, "");
4746      if (data.length % 4 === 0) {
4747        data = data.replace(/=?=$/, "");
4748      }
4749      if (data.length % 4 === 1) {
4750        return "failure";
4751      }
4752      if (/[^+/0-9A-Za-z]/.test(data)) {
4753        return "failure";
4754      }
4755      const binary = atob2(data);
4756      const bytes = new Uint8Array(binary.length);
4757      for (let byte = 0; byte < binary.length; byte++) {
4758        bytes[byte] = binary.charCodeAt(byte);
4759      }
4760      return bytes;
4761    }
4762    __name(forgivingBase64, "forgivingBase64");
4763    function collectAnHTTPQuotedString(input, position, extractValue) {
4764      const positionStart = position.position;
4765      let value = "";
4766      assert(input[position.position] === '"');
4767      position.position++;
4768      while (true) {
4769        value += collectASequenceOfCodePoints(
4770          (char) => char !== '"' && char !== "\\",
4771          input,
4772          position
4773        );
4774        if (position.position >= input.length) {
4775          break;
4776        }
4777        const quoteOrBackslash = input[position.position];
4778        position.position++;
4779        if (quoteOrBackslash === "\\") {
4780          if (position.position >= input.length) {
4781            value += "\\";
4782            break;
4783          }
4784          value += input[position.position];
4785          position.position++;
4786        } else {
4787          assert(quoteOrBackslash === '"');
4788          break;
4789        }
4790      }
4791      if (extractValue) {
4792        return value;
4793      }
4794      return input.slice(positionStart, position.position);
4795    }
4796    __name(collectAnHTTPQuotedString, "collectAnHTTPQuotedString");
4797    function serializeAMimeType(mimeType) {
4798      assert(mimeType !== "failure");
4799      const { parameters, essence } = mimeType;
4800      let serialization = essence;
4801      for (let [name, value] of parameters.entries()) {
4802        serialization += ";";
4803        serialization += name;
4804        serialization += "=";
4805        if (!HTTP_TOKEN_CODEPOINTS.test(value)) {
4806          value = value.replace(/(\\|")/g, "\\$1");
4807          value = '"' + value;
4808          value += '"';
4809        }
4810        serialization += value;
4811      }
4812      return serialization;
4813    }
4814    __name(serializeAMimeType, "serializeAMimeType");
4815    function isHTTPWhiteSpace(char) {
4816      return char === "\r" || char === "\n" || char === "	" || char === " ";
4817    }
4818    __name(isHTTPWhiteSpace, "isHTTPWhiteSpace");
4819    function removeHTTPWhitespace(str, leading = true, trailing = true) {
4820      let lead = 0;
4821      let trail = str.length - 1;
4822      if (leading) {
4823        for (; lead < str.length && isHTTPWhiteSpace(str[lead]); lead++)
4824          ;
4825      }
4826      if (trailing) {
4827        for (; trail > 0 && isHTTPWhiteSpace(str[trail]); trail--)
4828          ;
4829      }
4830      return str.slice(lead, trail + 1);
4831    }
4832    __name(removeHTTPWhitespace, "removeHTTPWhitespace");
4833    function isASCIIWhitespace(char) {
4834      return char === "\r" || char === "\n" || char === "	" || char === "\f" || char === " ";
4835    }
4836    __name(isASCIIWhitespace, "isASCIIWhitespace");
4837    function removeASCIIWhitespace(str, leading = true, trailing = true) {
4838      let lead = 0;
4839      let trail = str.length - 1;
4840      if (leading) {
4841        for (; lead < str.length && isASCIIWhitespace(str[lead]); lead++)
4842          ;
4843      }
4844      if (trailing) {
4845        for (; trail > 0 && isASCIIWhitespace(str[trail]); trail--)
4846          ;
4847      }
4848      return str.slice(lead, trail + 1);
4849    }
4850    __name(removeASCIIWhitespace, "removeASCIIWhitespace");
4851    module2.exports = {
4852      dataURLProcessor,
4853      URLSerializer,
4854      collectASequenceOfCodePoints,
4855      collectASequenceOfCodePointsFast,
4856      stringPercentDecode,
4857      parseMIMEType,
4858      collectAnHTTPQuotedString,
4859      serializeAMimeType
4860    };
4861  }
4862});
4863
4864// lib/fetch/file.js
4865var require_file = __commonJS({
4866  "lib/fetch/file.js"(exports2, module2) {
4867    "use strict";
4868    var { Blob: Blob2, File: NativeFile } = require("buffer");
4869    var { types } = require("util");
4870    var { kState } = require_symbols2();
4871    var { isBlobLike } = require_util2();
4872    var { webidl } = require_webidl();
4873    var { parseMIMEType, serializeAMimeType } = require_dataURL();
4874    var { kEnumerableProperty } = require_util();
4875    var encoder = new TextEncoder();
4876    var File = class _File extends Blob2 {
4877      static {
4878        __name(this, "File");
4879      }
4880      constructor(fileBits, fileName, options = {}) {
4881        webidl.argumentLengthCheck(arguments, 2, { header: "File constructor" });
4882        fileBits = webidl.converters["sequence<BlobPart>"](fileBits);
4883        fileName = webidl.converters.USVString(fileName);
4884        options = webidl.converters.FilePropertyBag(options);
4885        const n = fileName;
4886        let t = options.type;
4887        let d;
4888        substep: {
4889          if (t) {
4890            t = parseMIMEType(t);
4891            if (t === "failure") {
4892              t = "";
4893              break substep;
4894            }
4895            t = serializeAMimeType(t).toLowerCase();
4896          }
4897          d = options.lastModified;
4898        }
4899        super(processBlobParts(fileBits, options), { type: t });
4900        this[kState] = {
4901          name: n,
4902          lastModified: d,
4903          type: t
4904        };
4905      }
4906      get name() {
4907        webidl.brandCheck(this, _File);
4908        return this[kState].name;
4909      }
4910      get lastModified() {
4911        webidl.brandCheck(this, _File);
4912        return this[kState].lastModified;
4913      }
4914      get type() {
4915        webidl.brandCheck(this, _File);
4916        return this[kState].type;
4917      }
4918    };
4919    var FileLike = class _FileLike {
4920      static {
4921        __name(this, "FileLike");
4922      }
4923      constructor(blobLike, fileName, options = {}) {
4924        const n = fileName;
4925        const t = options.type;
4926        const d = options.lastModified ?? Date.now();
4927        this[kState] = {
4928          blobLike,
4929          name: n,
4930          type: t,
4931          lastModified: d
4932        };
4933      }
4934      stream(...args) {
4935        webidl.brandCheck(this, _FileLike);
4936        return this[kState].blobLike.stream(...args);
4937      }
4938      arrayBuffer(...args) {
4939        webidl.brandCheck(this, _FileLike);
4940        return this[kState].blobLike.arrayBuffer(...args);
4941      }
4942      slice(...args) {
4943        webidl.brandCheck(this, _FileLike);
4944        return this[kState].blobLike.slice(...args);
4945      }
4946      text(...args) {
4947        webidl.brandCheck(this, _FileLike);
4948        return this[kState].blobLike.text(...args);
4949      }
4950      get size() {
4951        webidl.brandCheck(this, _FileLike);
4952        return this[kState].blobLike.size;
4953      }
4954      get type() {
4955        webidl.brandCheck(this, _FileLike);
4956        return this[kState].blobLike.type;
4957      }
4958      get name() {
4959        webidl.brandCheck(this, _FileLike);
4960        return this[kState].name;
4961      }
4962      get lastModified() {
4963        webidl.brandCheck(this, _FileLike);
4964        return this[kState].lastModified;
4965      }
4966      get [Symbol.toStringTag]() {
4967        return "File";
4968      }
4969    };
4970    Object.defineProperties(File.prototype, {
4971      [Symbol.toStringTag]: {
4972        value: "File",
4973        configurable: true
4974      },
4975      name: kEnumerableProperty,
4976      lastModified: kEnumerableProperty
4977    });
4978    webidl.converters.Blob = webidl.interfaceConverter(Blob2);
4979    webidl.converters.BlobPart = function(V, opts) {
4980      if (webidl.util.Type(V) === "Object") {
4981        if (isBlobLike(V)) {
4982          return webidl.converters.Blob(V, { strict: false });
4983        }
4984        if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) {
4985          return webidl.converters.BufferSource(V, opts);
4986        }
4987      }
4988      return webidl.converters.USVString(V, opts);
4989    };
4990    webidl.converters["sequence<BlobPart>"] = webidl.sequenceConverter(
4991      webidl.converters.BlobPart
4992    );
4993    webidl.converters.FilePropertyBag = webidl.dictionaryConverter([
4994      {
4995        key: "lastModified",
4996        converter: webidl.converters["long long"],
4997        get defaultValue() {
4998          return Date.now();
4999        }
5000      },
5001      {
5002        key: "type",
5003        converter: webidl.converters.DOMString,
5004        defaultValue: ""
5005      },
5006      {
5007        key: "endings",
5008        converter: (value) => {
5009          value = webidl.converters.DOMString(value);
5010          value = value.toLowerCase();
5011          if (value !== "native") {
5012            value = "transparent";
5013          }
5014          return value;
5015        },
5016        defaultValue: "transparent"
5017      }
5018    ]);
5019    function processBlobParts(parts, options) {
5020      const bytes = [];
5021      for (const element of parts) {
5022        if (typeof element === "string") {
5023          let s = element;
5024          if (options.endings === "native") {
5025            s = convertLineEndingsNative(s);
5026          }
5027          bytes.push(encoder.encode(s));
5028        } else if (types.isAnyArrayBuffer(element) || types.isTypedArray(element)) {
5029          if (!element.buffer) {
5030            bytes.push(new Uint8Array(element));
5031          } else {
5032            bytes.push(
5033              new Uint8Array(element.buffer, element.byteOffset, element.byteLength)
5034            );
5035          }
5036        } else if (isBlobLike(element)) {
5037          bytes.push(element);
5038        }
5039      }
5040      return bytes;
5041    }
5042    __name(processBlobParts, "processBlobParts");
5043    function convertLineEndingsNative(s) {
5044      let nativeLineEnding = "\n";
5045      if (process.platform === "win32") {
5046        nativeLineEnding = "\r\n";
5047      }
5048      return s.replace(/\r?\n/g, nativeLineEnding);
5049    }
5050    __name(convertLineEndingsNative, "convertLineEndingsNative");
5051    function isFileLike(object) {
5052      return NativeFile && object instanceof NativeFile || object instanceof File || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File";
5053    }
5054    __name(isFileLike, "isFileLike");
5055    module2.exports = { File, FileLike, isFileLike };
5056  }
5057});
5058
5059// lib/fetch/formdata.js
5060var require_formdata = __commonJS({
5061  "lib/fetch/formdata.js"(exports2, module2) {
5062    "use strict";
5063    var { isBlobLike, toUSVString, makeIterator } = require_util2();
5064    var { kState } = require_symbols2();
5065    var { File: UndiciFile, FileLike, isFileLike } = require_file();
5066    var { webidl } = require_webidl();
5067    var { Blob: Blob2, File: NativeFile } = require("buffer");
5068    var File = NativeFile ?? UndiciFile;
5069    var FormData = class _FormData {
5070      static {
5071        __name(this, "FormData");
5072      }
5073      constructor(form) {
5074        if (form !== void 0) {
5075          throw webidl.errors.conversionFailed({
5076            prefix: "FormData constructor",
5077            argument: "Argument 1",
5078            types: ["undefined"]
5079          });
5080        }
5081        this[kState] = [];
5082      }
5083      append(name, value, filename = void 0) {
5084        webidl.brandCheck(this, _FormData);
5085        webidl.argumentLengthCheck(arguments, 2, { header: "FormData.append" });
5086        if (arguments.length === 3 && !isBlobLike(value)) {
5087          throw new TypeError(
5088            "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'"
5089          );
5090        }
5091        name = webidl.converters.USVString(name);
5092        value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value);
5093        filename = arguments.length === 3 ? webidl.converters.USVString(filename) : void 0;
5094        const entry = makeEntry(name, value, filename);
5095        this[kState].push(entry);
5096      }
5097      delete(name) {
5098        webidl.brandCheck(this, _FormData);
5099        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.delete" });
5100        name = webidl.converters.USVString(name);
5101        this[kState] = this[kState].filter((entry) => entry.name !== name);
5102      }
5103      get(name) {
5104        webidl.brandCheck(this, _FormData);
5105        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.get" });
5106        name = webidl.converters.USVString(name);
5107        const idx = this[kState].findIndex((entry) => entry.name === name);
5108        if (idx === -1) {
5109          return null;
5110        }
5111        return this[kState][idx].value;
5112      }
5113      getAll(name) {
5114        webidl.brandCheck(this, _FormData);
5115        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.getAll" });
5116        name = webidl.converters.USVString(name);
5117        return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value);
5118      }
5119      has(name) {
5120        webidl.brandCheck(this, _FormData);
5121        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.has" });
5122        name = webidl.converters.USVString(name);
5123        return this[kState].findIndex((entry) => entry.name === name) !== -1;
5124      }
5125      set(name, value, filename = void 0) {
5126        webidl.brandCheck(this, _FormData);
5127        webidl.argumentLengthCheck(arguments, 2, { header: "FormData.set" });
5128        if (arguments.length === 3 && !isBlobLike(value)) {
5129          throw new TypeError(
5130            "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'"
5131          );
5132        }
5133        name = webidl.converters.USVString(name);
5134        value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value);
5135        filename = arguments.length === 3 ? toUSVString(filename) : void 0;
5136        const entry = makeEntry(name, value, filename);
5137        const idx = this[kState].findIndex((entry2) => entry2.name === name);
5138        if (idx !== -1) {
5139          this[kState] = [
5140            ...this[kState].slice(0, idx),
5141            entry,
5142            ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name)
5143          ];
5144        } else {
5145          this[kState].push(entry);
5146        }
5147      }
5148      entries() {
5149        webidl.brandCheck(this, _FormData);
5150        return makeIterator(
5151          () => this[kState].map((pair) => [pair.name, pair.value]),
5152          "FormData",
5153          "key+value"
5154        );
5155      }
5156      keys() {
5157        webidl.brandCheck(this, _FormData);
5158        return makeIterator(
5159          () => this[kState].map((pair) => [pair.name, pair.value]),
5160          "FormData",
5161          "key"
5162        );
5163      }
5164      values() {
5165        webidl.brandCheck(this, _FormData);
5166        return makeIterator(
5167          () => this[kState].map((pair) => [pair.name, pair.value]),
5168          "FormData",
5169          "value"
5170        );
5171      }
5172      /**
5173       * @param {(value: string, key: string, self: FormData) => void} callbackFn
5174       * @param {unknown} thisArg
5175       */
5176      forEach(callbackFn, thisArg = globalThis) {
5177        webidl.brandCheck(this, _FormData);
5178        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.forEach" });
5179        if (typeof callbackFn !== "function") {
5180          throw new TypeError(
5181            "Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'."
5182          );
5183        }
5184        for (const [key, value] of this) {
5185          callbackFn.apply(thisArg, [value, key, this]);
5186        }
5187      }
5188    };
5189    FormData.prototype[Symbol.iterator] = FormData.prototype.entries;
5190    Object.defineProperties(FormData.prototype, {
5191      [Symbol.toStringTag]: {
5192        value: "FormData",
5193        configurable: true
5194      }
5195    });
5196    function makeEntry(name, value, filename) {
5197      name = Buffer.from(name).toString("utf8");
5198      if (typeof value === "string") {
5199        value = Buffer.from(value).toString("utf8");
5200      } else {
5201        if (!isFileLike(value)) {
5202          value = value instanceof Blob2 ? new File([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type });
5203        }
5204        if (filename !== void 0) {
5205          const options = {
5206            type: value.type,
5207            lastModified: value.lastModified
5208          };
5209          value = NativeFile && value instanceof NativeFile || value instanceof UndiciFile ? new File([value], filename, options) : new FileLike(value, filename, options);
5210        }
5211      }
5212      return { name, value };
5213    }
5214    __name(makeEntry, "makeEntry");
5215    module2.exports = { FormData };
5216  }
5217});
5218
5219// lib/fetch/body.js
5220var require_body = __commonJS({
5221  "lib/fetch/body.js"(exports2, module2) {
5222    "use strict";
5223    var Busboy = require_main();
5224    var util = require_util();
5225    var {
5226      ReadableStreamFrom,
5227      isBlobLike,
5228      isReadableStreamLike,
5229      readableStreamClose,
5230      createDeferredPromise,
5231      fullyReadBody
5232    } = require_util2();
5233    var { FormData } = require_formdata();
5234    var { kState } = require_symbols2();
5235    var { webidl } = require_webidl();
5236    var { DOMException, structuredClone } = require_constants2();
5237    var { Blob: Blob2, File: NativeFile } = require("buffer");
5238    var { kBodyUsed } = require_symbols();
5239    var assert = require("assert");
5240    var { isErrored } = require_util();
5241    var { isUint8Array, isArrayBuffer } = require("util/types");
5242    var { File: UndiciFile } = require_file();
5243    var { parseMIMEType, serializeAMimeType } = require_dataURL();
5244    var ReadableStream = globalThis.ReadableStream;
5245    var File = NativeFile ?? UndiciFile;
5246    var textEncoder = new TextEncoder();
5247    var textDecoder = new TextDecoder();
5248    function extractBody(object, keepalive = false) {
5249      if (!ReadableStream) {
5250        ReadableStream = require("stream/web").ReadableStream;
5251      }
5252      let stream = null;
5253      if (object instanceof ReadableStream) {
5254        stream = object;
5255      } else if (isBlobLike(object)) {
5256        stream = object.stream();
5257      } else {
5258        stream = new ReadableStream({
5259          async pull(controller) {
5260            controller.enqueue(
5261              typeof source === "string" ? textEncoder.encode(source) : source
5262            );
5263            queueMicrotask(() => readableStreamClose(controller));
5264          },
5265          start() {
5266          },
5267          type: void 0
5268        });
5269      }
5270      assert(isReadableStreamLike(stream));
5271      let action = null;
5272      let source = null;
5273      let length = null;
5274      let type = null;
5275      if (typeof object === "string") {
5276        source = object;
5277        type = "text/plain;charset=UTF-8";
5278      } else if (object instanceof URLSearchParams) {
5279        source = object.toString();
5280        type = "application/x-www-form-urlencoded;charset=UTF-8";
5281      } else if (isArrayBuffer(object)) {
5282        source = new Uint8Array(object.slice());
5283      } else if (ArrayBuffer.isView(object)) {
5284        source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength));
5285      } else if (util.isFormDataLike(object)) {
5286        const boundary = `----formdata-undici-0${`${Math.floor(Math.random() * 1e11)}`.padStart(11, "0")}`;
5287        const prefix = `--${boundary}\r
5288Content-Disposition: form-data`;
5289        const escape = /* @__PURE__ */ __name((str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), "escape");
5290        const normalizeLinefeeds = /* @__PURE__ */ __name((value) => value.replace(/\r?\n|\r/g, "\r\n"), "normalizeLinefeeds");
5291        const blobParts = [];
5292        const rn = new Uint8Array([13, 10]);
5293        length = 0;
5294        let hasUnknownSizeValue = false;
5295        for (const [name, value] of object) {
5296          if (typeof value === "string") {
5297            const chunk2 = textEncoder.encode(prefix + `; name="${escape(normalizeLinefeeds(name))}"\r
5298\r
5299${normalizeLinefeeds(value)}\r
5300`);
5301            blobParts.push(chunk2);
5302            length += chunk2.byteLength;
5303          } else {
5304            const chunk2 = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape(value.name)}"` : "") + `\r
5305Content-Type: ${value.type || "application/octet-stream"}\r
5306\r
5307`);
5308            blobParts.push(chunk2, value, rn);
5309            if (typeof value.size === "number") {
5310              length += chunk2.byteLength + value.size + rn.byteLength;
5311            } else {
5312              hasUnknownSizeValue = true;
5313            }
5314          }
5315        }
5316        const chunk = textEncoder.encode(`--${boundary}--`);
5317        blobParts.push(chunk);
5318        length += chunk.byteLength;
5319        if (hasUnknownSizeValue) {
5320          length = null;
5321        }
5322        source = object;
5323        action = /* @__PURE__ */ __name(async function* () {
5324          for (const part of blobParts) {
5325            if (part.stream) {
5326              yield* part.stream();
5327            } else {
5328              yield part;
5329            }
5330          }
5331        }, "action");
5332        type = "multipart/form-data; boundary=" + boundary;
5333      } else if (isBlobLike(object)) {
5334        source = object;
5335        length = object.size;
5336        if (object.type) {
5337          type = object.type;
5338        }
5339      } else if (typeof object[Symbol.asyncIterator] === "function") {
5340        if (keepalive) {
5341          throw new TypeError("keepalive");
5342        }
5343        if (util.isDisturbed(object) || object.locked) {
5344          throw new TypeError(
5345            "Response body object should not be disturbed or locked"
5346          );
5347        }
5348        stream = object instanceof ReadableStream ? object : ReadableStreamFrom(object);
5349      }
5350      if (typeof source === "string" || util.isBuffer(source)) {
5351        length = Buffer.byteLength(source);
5352      }
5353      if (action != null) {
5354        let iterator;
5355        stream = new ReadableStream({
5356          async start() {
5357            iterator = action(object)[Symbol.asyncIterator]();
5358          },
5359          async pull(controller) {
5360            const { value, done } = await iterator.next();
5361            if (done) {
5362              queueMicrotask(() => {
5363                controller.close();
5364              });
5365            } else {
5366              if (!isErrored(stream)) {
5367                controller.enqueue(new Uint8Array(value));
5368              }
5369            }
5370            return controller.desiredSize > 0;
5371          },
5372          async cancel(reason) {
5373            await iterator.return();
5374          },
5375          type: void 0
5376        });
5377      }
5378      const body = { stream, source, length };
5379      return [body, type];
5380    }
5381    __name(extractBody, "extractBody");
5382    function safelyExtractBody(object, keepalive = false) {
5383      if (!ReadableStream) {
5384        ReadableStream = require("stream/web").ReadableStream;
5385      }
5386      if (object instanceof ReadableStream) {
5387        assert(!util.isDisturbed(object), "The body has already been consumed.");
5388        assert(!object.locked, "The stream is locked.");
5389      }
5390      return extractBody(object, keepalive);
5391    }
5392    __name(safelyExtractBody, "safelyExtractBody");
5393    function cloneBody(body) {
5394      const [out1, out2] = body.stream.tee();
5395      const out2Clone = structuredClone(out2, { transfer: [out2] });
5396      const [, finalClone] = out2Clone.tee();
5397      body.stream = out1;
5398      return {
5399        stream: finalClone,
5400        length: body.length,
5401        source: body.source
5402      };
5403    }
5404    __name(cloneBody, "cloneBody");
5405    async function* consumeBody(body) {
5406      if (body) {
5407        if (isUint8Array(body)) {
5408          yield body;
5409        } else {
5410          const stream = body.stream;
5411          if (util.isDisturbed(stream)) {
5412            throw new TypeError("The body has already been consumed.");
5413          }
5414          if (stream.locked) {
5415            throw new TypeError("The stream is locked.");
5416          }
5417          stream[kBodyUsed] = true;
5418          yield* stream;
5419        }
5420      }
5421    }
5422    __name(consumeBody, "consumeBody");
5423    function throwIfAborted(state) {
5424      if (state.aborted) {
5425        throw new DOMException("The operation was aborted.", "AbortError");
5426      }
5427    }
5428    __name(throwIfAborted, "throwIfAborted");
5429    function bodyMixinMethods(instance) {
5430      const methods = {
5431        blob() {
5432          return specConsumeBody(this, (bytes) => {
5433            let mimeType = bodyMimeType(this);
5434            if (mimeType === "failure") {
5435              mimeType = "";
5436            } else if (mimeType) {
5437              mimeType = serializeAMimeType(mimeType);
5438            }
5439            return new Blob2([bytes], { type: mimeType });
5440          }, instance);
5441        },
5442        arrayBuffer() {
5443          return specConsumeBody(this, (bytes) => {
5444            return new Uint8Array(bytes).buffer;
5445          }, instance);
5446        },
5447        text() {
5448          return specConsumeBody(this, utf8DecodeBytes, instance);
5449        },
5450        json() {
5451          return specConsumeBody(this, parseJSONFromBytes, instance);
5452        },
5453        async formData() {
5454          webidl.brandCheck(this, instance);
5455          throwIfAborted(this[kState]);
5456          const contentType = this.headers.get("Content-Type");
5457          if (/multipart\/form-data/.test(contentType)) {
5458            const headers = {};
5459            for (const [key, value] of this.headers)
5460              headers[key.toLowerCase()] = value;
5461            const responseFormData = new FormData();
5462            let busboy;
5463            try {
5464              busboy = new Busboy({
5465                headers,
5466                preservePath: true
5467              });
5468            } catch (err) {
5469              throw new DOMException(`${err}`, "AbortError");
5470            }
5471            busboy.on("field", (name, value) => {
5472              responseFormData.append(name, value);
5473            });
5474            busboy.on("file", (name, value, filename, encoding, mimeType) => {
5475              const chunks = [];
5476              if (encoding === "base64" || encoding.toLowerCase() === "base64") {
5477                let base64chunk = "";
5478                value.on("data", (chunk) => {
5479                  base64chunk += chunk.toString().replace(/[\r\n]/gm, "");
5480                  const end = base64chunk.length - base64chunk.length % 4;
5481                  chunks.push(Buffer.from(base64chunk.slice(0, end), "base64"));
5482                  base64chunk = base64chunk.slice(end);
5483                });
5484                value.on("end", () => {
5485                  chunks.push(Buffer.from(base64chunk, "base64"));
5486                  responseFormData.append(name, new File(chunks, filename, { type: mimeType }));
5487                });
5488              } else {
5489                value.on("data", (chunk) => {
5490                  chunks.push(chunk);
5491                });
5492                value.on("end", () => {
5493                  responseFormData.append(name, new File(chunks, filename, { type: mimeType }));
5494                });
5495              }
5496            });
5497            const busboyResolve = new Promise((resolve, reject) => {
5498              busboy.on("finish", resolve);
5499              busboy.on("error", (err) => reject(new TypeError(err)));
5500            });
5501            if (this.body !== null)
5502              for await (const chunk of consumeBody(this[kState].body))
5503                busboy.write(chunk);
5504            busboy.end();
5505            await busboyResolve;
5506            return responseFormData;
5507          } else if (/application\/x-www-form-urlencoded/.test(contentType)) {
5508            let entries;
5509            try {
5510              let text = "";
5511              const streamingDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
5512              for await (const chunk of consumeBody(this[kState].body)) {
5513                if (!isUint8Array(chunk)) {
5514                  throw new TypeError("Expected Uint8Array chunk");
5515                }
5516                text += streamingDecoder.decode(chunk, { stream: true });
5517              }
5518              text += streamingDecoder.decode();
5519              entries = new URLSearchParams(text);
5520            } catch (err) {
5521              throw Object.assign(new TypeError(), { cause: err });
5522            }
5523            const formData = new FormData();
5524            for (const [name, value] of entries) {
5525              formData.append(name, value);
5526            }
5527            return formData;
5528          } else {
5529            await Promise.resolve();
5530            throwIfAborted(this[kState]);
5531            throw webidl.errors.exception({
5532              header: `${instance.name}.formData`,
5533              message: "Could not parse content as FormData."
5534            });
5535          }
5536        }
5537      };
5538      return methods;
5539    }
5540    __name(bodyMixinMethods, "bodyMixinMethods");
5541    function mixinBody(prototype) {
5542      Object.assign(prototype.prototype, bodyMixinMethods(prototype));
5543    }
5544    __name(mixinBody, "mixinBody");
5545    async function specConsumeBody(object, convertBytesToJSValue, instance) {
5546      webidl.brandCheck(object, instance);
5547      throwIfAborted(object[kState]);
5548      if (bodyUnusable(object[kState].body)) {
5549        throw new TypeError("Body is unusable");
5550      }
5551      const promise = createDeferredPromise();
5552      const errorSteps = /* @__PURE__ */ __name((error) => promise.reject(error), "errorSteps");
5553      const successSteps = /* @__PURE__ */ __name((data) => {
5554        try {
5555          promise.resolve(convertBytesToJSValue(data));
5556        } catch (e) {
5557          errorSteps(e);
5558        }
5559      }, "successSteps");
5560      if (object[kState].body == null) {
5561        successSteps(new Uint8Array());
5562        return promise.promise;
5563      }
5564      await fullyReadBody(object[kState].body, successSteps, errorSteps);
5565      return promise.promise;
5566    }
5567    __name(specConsumeBody, "specConsumeBody");
5568    function bodyUnusable(body) {
5569      return body != null && (body.stream.locked || util.isDisturbed(body.stream));
5570    }
5571    __name(bodyUnusable, "bodyUnusable");
5572    function utf8DecodeBytes(buffer) {
5573      if (buffer.length === 0) {
5574        return "";
5575      }
5576      if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
5577        buffer = buffer.subarray(3);
5578      }
5579      const output = textDecoder.decode(buffer);
5580      return output;
5581    }
5582    __name(utf8DecodeBytes, "utf8DecodeBytes");
5583    function parseJSONFromBytes(bytes) {
5584      return JSON.parse(utf8DecodeBytes(bytes));
5585    }
5586    __name(parseJSONFromBytes, "parseJSONFromBytes");
5587    function bodyMimeType(object) {
5588      const { headersList } = object[kState];
5589      const contentType = headersList.get("content-type");
5590      if (contentType === null) {
5591        return "failure";
5592      }
5593      return parseMIMEType(contentType);
5594    }
5595    __name(bodyMimeType, "bodyMimeType");
5596    module2.exports = {
5597      extractBody,
5598      safelyExtractBody,
5599      cloneBody,
5600      mixinBody
5601    };
5602  }
5603});
5604
5605// lib/fetch/response.js
5606var require_response = __commonJS({
5607  "lib/fetch/response.js"(exports2, module2) {
5608    "use strict";
5609    var { Headers, HeadersList, fill } = require_headers();
5610    var { extractBody, cloneBody, mixinBody } = require_body();
5611    var util = require_util();
5612    var { kEnumerableProperty } = util;
5613    var {
5614      isValidReasonPhrase,
5615      isCancelled,
5616      isAborted,
5617      isBlobLike,
5618      serializeJavascriptValueToJSONString,
5619      isErrorLike,
5620      isomorphicEncode
5621    } = require_util2();
5622    var {
5623      redirectStatusSet,
5624      nullBodyStatus,
5625      DOMException
5626    } = require_constants2();
5627    var { kState, kHeaders, kGuard, kRealm } = require_symbols2();
5628    var { webidl } = require_webidl();
5629    var { FormData } = require_formdata();
5630    var { getGlobalOrigin } = require_global();
5631    var { URLSerializer } = require_dataURL();
5632    var { kHeadersList, kConstruct } = require_symbols();
5633    var assert = require("assert");
5634    var { types } = require("util");
5635    var ReadableStream = globalThis.ReadableStream || require("stream/web").ReadableStream;
5636    var textEncoder = new TextEncoder("utf-8");
5637    var Response = class _Response {
5638      static {
5639        __name(this, "Response");
5640      }
5641      // Creates network error Response.
5642      static error() {
5643        const relevantRealm = { settingsObject: {} };
5644        const responseObject = new _Response();
5645        responseObject[kState] = makeNetworkError();
5646        responseObject[kRealm] = relevantRealm;
5647        responseObject[kHeaders][kHeadersList] = responseObject[kState].headersList;
5648        responseObject[kHeaders][kGuard] = "immutable";
5649        responseObject[kHeaders][kRealm] = relevantRealm;
5650        return responseObject;
5651      }
5652      // https://fetch.spec.whatwg.org/#dom-response-json
5653      static json(data, init = {}) {
5654        webidl.argumentLengthCheck(arguments, 1, { header: "Response.json" });
5655        if (init !== null) {
5656          init = webidl.converters.ResponseInit(init);
5657        }
5658        const bytes = textEncoder.encode(
5659          serializeJavascriptValueToJSONString(data)
5660        );
5661        const body = extractBody(bytes);
5662        const relevantRealm = { settingsObject: {} };
5663        const responseObject = new _Response();
5664        responseObject[kRealm] = relevantRealm;
5665        responseObject[kHeaders][kGuard] = "response";
5666        responseObject[kHeaders][kRealm] = relevantRealm;
5667        initializeResponse(responseObject, init, { body: body[0], type: "application/json" });
5668        return responseObject;
5669      }
5670      // Creates a redirect Response that redirects to url with status status.
5671      static redirect(url, status = 302) {
5672        const relevantRealm = { settingsObject: {} };
5673        webidl.argumentLengthCheck(arguments, 1, { header: "Response.redirect" });
5674        url = webidl.converters.USVString(url);
5675        status = webidl.converters["unsigned short"](status);
5676        let parsedURL;
5677        try {
5678          parsedURL = new URL(url, getGlobalOrigin());
5679        } catch (err) {
5680          throw Object.assign(new TypeError("Failed to parse URL from " + url), {
5681            cause: err
5682          });
5683        }
5684        if (!redirectStatusSet.has(status)) {
5685          throw new RangeError("Invalid status code " + status);
5686        }
5687        const responseObject = new _Response();
5688        responseObject[kRealm] = relevantRealm;
5689        responseObject[kHeaders][kGuard] = "immutable";
5690        responseObject[kHeaders][kRealm] = relevantRealm;
5691        responseObject[kState].status = status;
5692        const value = isomorphicEncode(URLSerializer(parsedURL));
5693        responseObject[kState].headersList.append("location", value);
5694        return responseObject;
5695      }
5696      // https://fetch.spec.whatwg.org/#dom-response
5697      constructor(body = null, init = {}) {
5698        if (body !== null) {
5699          body = webidl.converters.BodyInit(body);
5700        }
5701        init = webidl.converters.ResponseInit(init);
5702        this[kRealm] = { settingsObject: {} };
5703        this[kState] = makeResponse({});
5704        this[kHeaders] = new Headers(kConstruct);
5705        this[kHeaders][kGuard] = "response";
5706        this[kHeaders][kHeadersList] = this[kState].headersList;
5707        this[kHeaders][kRealm] = this[kRealm];
5708        let bodyWithType = null;
5709        if (body != null) {
5710          const [extractedBody, type] = extractBody(body);
5711          bodyWithType = { body: extractedBody, type };
5712        }
5713        initializeResponse(this, init, bodyWithType);
5714      }
5715      // Returns response’s type, e.g., "cors".
5716      get type() {
5717        webidl.brandCheck(this, _Response);
5718        return this[kState].type;
5719      }
5720      // Returns response’s URL, if it has one; otherwise the empty string.
5721      get url() {
5722        webidl.brandCheck(this, _Response);
5723        const urlList = this[kState].urlList;
5724        const url = urlList[urlList.length - 1] ?? null;
5725        if (url === null) {
5726          return "";
5727        }
5728        return URLSerializer(url, true);
5729      }
5730      // Returns whether response was obtained through a redirect.
5731      get redirected() {
5732        webidl.brandCheck(this, _Response);
5733        return this[kState].urlList.length > 1;
5734      }
5735      // Returns response’s status.
5736      get status() {
5737        webidl.brandCheck(this, _Response);
5738        return this[kState].status;
5739      }
5740      // Returns whether response’s status is an ok status.
5741      get ok() {
5742        webidl.brandCheck(this, _Response);
5743        return this[kState].status >= 200 && this[kState].status <= 299;
5744      }
5745      // Returns response’s status message.
5746      get statusText() {
5747        webidl.brandCheck(this, _Response);
5748        return this[kState].statusText;
5749      }
5750      // Returns response’s headers as Headers.
5751      get headers() {
5752        webidl.brandCheck(this, _Response);
5753        return this[kHeaders];
5754      }
5755      get body() {
5756        webidl.brandCheck(this, _Response);
5757        return this[kState].body ? this[kState].body.stream : null;
5758      }
5759      get bodyUsed() {
5760        webidl.brandCheck(this, _Response);
5761        return !!this[kState].body && util.isDisturbed(this[kState].body.stream);
5762      }
5763      // Returns a clone of response.
5764      clone() {
5765        webidl.brandCheck(this, _Response);
5766        if (this.bodyUsed || this.body && this.body.locked) {
5767          throw webidl.errors.exception({
5768            header: "Response.clone",
5769            message: "Body has already been consumed."
5770          });
5771        }
5772        const clonedResponse = cloneResponse(this[kState]);
5773        const clonedResponseObject = new _Response();
5774        clonedResponseObject[kState] = clonedResponse;
5775        clonedResponseObject[kRealm] = this[kRealm];
5776        clonedResponseObject[kHeaders][kHeadersList] = clonedResponse.headersList;
5777        clonedResponseObject[kHeaders][kGuard] = this[kHeaders][kGuard];
5778        clonedResponseObject[kHeaders][kRealm] = this[kHeaders][kRealm];
5779        return clonedResponseObject;
5780      }
5781    };
5782    mixinBody(Response);
5783    Object.defineProperties(Response.prototype, {
5784      type: kEnumerableProperty,
5785      url: kEnumerableProperty,
5786      status: kEnumerableProperty,
5787      ok: kEnumerableProperty,
5788      redirected: kEnumerableProperty,
5789      statusText: kEnumerableProperty,
5790      headers: kEnumerableProperty,
5791      clone: kEnumerableProperty,
5792      body: kEnumerableProperty,
5793      bodyUsed: kEnumerableProperty,
5794      [Symbol.toStringTag]: {
5795        value: "Response",
5796        configurable: true
5797      }
5798    });
5799    Object.defineProperties(Response, {
5800      json: kEnumerableProperty,
5801      redirect: kEnumerableProperty,
5802      error: kEnumerableProperty
5803    });
5804    function cloneResponse(response) {
5805      if (response.internalResponse) {
5806        return filterResponse(
5807          cloneResponse(response.internalResponse),
5808          response.type
5809        );
5810      }
5811      const newResponse = makeResponse({ ...response, body: null });
5812      if (response.body != null) {
5813        newResponse.body = cloneBody(response.body);
5814      }
5815      return newResponse;
5816    }
5817    __name(cloneResponse, "cloneResponse");
5818    function makeResponse(init) {
5819      return {
5820        aborted: false,
5821        rangeRequested: false,
5822        timingAllowPassed: false,
5823        requestIncludesCredentials: false,
5824        type: "default",
5825        status: 200,
5826        timingInfo: null,
5827        cacheState: "",
5828        statusText: "",
5829        ...init,
5830        headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList(),
5831        urlList: init.urlList ? [...init.urlList] : []
5832      };
5833    }
5834    __name(makeResponse, "makeResponse");
5835    function makeNetworkError(reason) {
5836      const isError = isErrorLike(reason);
5837      return makeResponse({
5838        type: "error",
5839        status: 0,
5840        error: isError ? reason : new Error(reason ? String(reason) : reason),
5841        aborted: reason && reason.name === "AbortError"
5842      });
5843    }
5844    __name(makeNetworkError, "makeNetworkError");
5845    function makeFilteredResponse(response, state) {
5846      state = {
5847        internalResponse: response,
5848        ...state
5849      };
5850      return new Proxy(response, {
5851        get(target, p) {
5852          return p in state ? state[p] : target[p];
5853        },
5854        set(target, p, value) {
5855          assert(!(p in state));
5856          target[p] = value;
5857          return true;
5858        }
5859      });
5860    }
5861    __name(makeFilteredResponse, "makeFilteredResponse");
5862    function filterResponse(response, type) {
5863      if (type === "basic") {
5864        return makeFilteredResponse(response, {
5865          type: "basic",
5866          headersList: response.headersList
5867        });
5868      } else if (type === "cors") {
5869        return makeFilteredResponse(response, {
5870          type: "cors",
5871          headersList: response.headersList
5872        });
5873      } else if (type === "opaque") {
5874        return makeFilteredResponse(response, {
5875          type: "opaque",
5876          urlList: Object.freeze([]),
5877          status: 0,
5878          statusText: "",
5879          body: null
5880        });
5881      } else if (type === "opaqueredirect") {
5882        return makeFilteredResponse(response, {
5883          type: "opaqueredirect",
5884          status: 0,
5885          statusText: "",
5886          headersList: [],
5887          body: null
5888        });
5889      } else {
5890        assert(false);
5891      }
5892    }
5893    __name(filterResponse, "filterResponse");
5894    function makeAppropriateNetworkError(fetchParams, err = null) {
5895      assert(isCancelled(fetchParams));
5896      return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException("Request was cancelled."), { cause: err }));
5897    }
5898    __name(makeAppropriateNetworkError, "makeAppropriateNetworkError");
5899    function initializeResponse(response, init, body) {
5900      if (init.status !== null && (init.status < 200 || init.status > 599)) {
5901        throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.');
5902      }
5903      if ("statusText" in init && init.statusText != null) {
5904        if (!isValidReasonPhrase(String(init.statusText))) {
5905          throw new TypeError("Invalid statusText");
5906        }
5907      }
5908      if ("status" in init && init.status != null) {
5909        response[kState].status = init.status;
5910      }
5911      if ("statusText" in init && init.statusText != null) {
5912        response[kState].statusText = init.statusText;
5913      }
5914      if ("headers" in init && init.headers != null) {
5915        fill(response[kHeaders], init.headers);
5916      }
5917      if (body) {
5918        if (nullBodyStatus.includes(response.status)) {
5919          throw webidl.errors.exception({
5920            header: "Response constructor",
5921            message: "Invalid response status code " + response.status
5922          });
5923        }
5924        response[kState].body = body.body;
5925        if (body.type != null && !response[kState].headersList.contains("Content-Type")) {
5926          response[kState].headersList.append("content-type", body.type);
5927        }
5928      }
5929    }
5930    __name(initializeResponse, "initializeResponse");
5931    webidl.converters.ReadableStream = webidl.interfaceConverter(
5932      ReadableStream
5933    );
5934    webidl.converters.FormData = webidl.interfaceConverter(
5935      FormData
5936    );
5937    webidl.converters.URLSearchParams = webidl.interfaceConverter(
5938      URLSearchParams
5939    );
5940    webidl.converters.XMLHttpRequestBodyInit = function(V) {
5941      if (typeof V === "string") {
5942        return webidl.converters.USVString(V);
5943      }
5944      if (isBlobLike(V)) {
5945        return webidl.converters.Blob(V, { strict: false });
5946      }
5947      if (types.isArrayBuffer(V) || types.isTypedArray(V) || types.isDataView(V)) {
5948        return webidl.converters.BufferSource(V);
5949      }
5950      if (util.isFormDataLike(V)) {
5951        return webidl.converters.FormData(V, { strict: false });
5952      }
5953      if (V instanceof URLSearchParams) {
5954        return webidl.converters.URLSearchParams(V);
5955      }
5956      return webidl.converters.DOMString(V);
5957    };
5958    webidl.converters.BodyInit = function(V) {
5959      if (V instanceof ReadableStream) {
5960        return webidl.converters.ReadableStream(V);
5961      }
5962      if (V?.[Symbol.asyncIterator]) {
5963        return V;
5964      }
5965      return webidl.converters.XMLHttpRequestBodyInit(V);
5966    };
5967    webidl.converters.ResponseInit = webidl.dictionaryConverter([
5968      {
5969        key: "status",
5970        converter: webidl.converters["unsigned short"],
5971        defaultValue: 200
5972      },
5973      {
5974        key: "statusText",
5975        converter: webidl.converters.ByteString,
5976        defaultValue: ""
5977      },
5978      {
5979        key: "headers",
5980        converter: webidl.converters.HeadersInit
5981      }
5982    ]);
5983    module2.exports = {
5984      makeNetworkError,
5985      makeResponse,
5986      makeAppropriateNetworkError,
5987      filterResponse,
5988      Response,
5989      cloneResponse
5990    };
5991  }
5992});
5993
5994// lib/compat/dispatcher-weakref.js
5995var require_dispatcher_weakref = __commonJS({
5996  "lib/compat/dispatcher-weakref.js"(exports2, module2) {
5997    "use strict";
5998    var { kConnected, kSize } = require_symbols();
5999    var CompatWeakRef = class {
6000      static {
6001        __name(this, "CompatWeakRef");
6002      }
6003      constructor(value) {
6004        this.value = value;
6005      }
6006      deref() {
6007        return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value;
6008      }
6009    };
6010    var CompatFinalizer = class {
6011      static {
6012        __name(this, "CompatFinalizer");
6013      }
6014      constructor(finalizer) {
6015        this.finalizer = finalizer;
6016      }
6017      register(dispatcher, key) {
6018        if (dispatcher.on) {
6019          dispatcher.on("disconnect", () => {
6020            if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) {
6021              this.finalizer(key);
6022            }
6023          });
6024        }
6025      }
6026    };
6027    module2.exports = function() {
6028      if (process.env.NODE_V8_COVERAGE) {
6029        return {
6030          WeakRef: CompatWeakRef,
6031          FinalizationRegistry: CompatFinalizer
6032        };
6033      }
6034      return {
6035        WeakRef: global.WeakRef || CompatWeakRef,
6036        FinalizationRegistry: global.FinalizationRegistry || CompatFinalizer
6037      };
6038    };
6039  }
6040});
6041
6042// lib/fetch/request.js
6043var require_request = __commonJS({
6044  "lib/fetch/request.js"(exports2, module2) {
6045    "use strict";
6046    var { extractBody, mixinBody, cloneBody } = require_body();
6047    var { Headers, fill: fillHeaders, HeadersList } = require_headers();
6048    var { FinalizationRegistry } = require_dispatcher_weakref()();
6049    var util = require_util();
6050    var {
6051      isValidHTTPToken,
6052      sameOrigin,
6053      normalizeMethod,
6054      makePolicyContainer,
6055      normalizeMethodRecord
6056    } = require_util2();
6057    var {
6058      forbiddenMethodsSet,
6059      corsSafeListedMethodsSet,
6060      referrerPolicy,
6061      requestRedirect,
6062      requestMode,
6063      requestCredentials,
6064      requestCache,
6065      requestDuplex
6066    } = require_constants2();
6067    var { kEnumerableProperty } = util;
6068    var { kHeaders, kSignal, kState, kGuard, kRealm } = require_symbols2();
6069    var { webidl } = require_webidl();
6070    var { getGlobalOrigin } = require_global();
6071    var { URLSerializer } = require_dataURL();
6072    var { kHeadersList, kConstruct } = require_symbols();
6073    var assert = require("assert");
6074    var { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = require("events");
6075    var TransformStream = globalThis.TransformStream;
6076    var kAbortController = Symbol("abortController");
6077    var requestFinalizer = new FinalizationRegistry(({ signal, abort }) => {
6078      signal.removeEventListener("abort", abort);
6079    });
6080    var Request = class _Request {
6081      static {
6082        __name(this, "Request");
6083      }
6084      // https://fetch.spec.whatwg.org/#dom-request
6085      constructor(input, init = {}) {
6086        if (input === kConstruct) {
6087          return;
6088        }
6089        webidl.argumentLengthCheck(arguments, 1, { header: "Request constructor" });
6090        input = webidl.converters.RequestInfo(input);
6091        init = webidl.converters.RequestInit(init);
6092        this[kRealm] = {
6093          settingsObject: {
6094            baseUrl: getGlobalOrigin(),
6095            get origin() {
6096              return this.baseUrl?.origin;
6097            },
6098            policyContainer: makePolicyContainer()
6099          }
6100        };
6101        let request = null;
6102        let fallbackMode = null;
6103        const baseUrl = this[kRealm].settingsObject.baseUrl;
6104        let signal = null;
6105        if (typeof input === "string") {
6106          let parsedURL;
6107          try {
6108            parsedURL = new URL(input, baseUrl);
6109          } catch (err) {
6110            throw new TypeError("Failed to parse URL from " + input, { cause: err });
6111          }
6112          if (parsedURL.username || parsedURL.password) {
6113            throw new TypeError(
6114              "Request cannot be constructed from a URL that includes credentials: " + input
6115            );
6116          }
6117          request = makeRequest({ urlList: [parsedURL] });
6118          fallbackMode = "cors";
6119        } else {
6120          assert(input instanceof _Request);
6121          request = input[kState];
6122          signal = input[kSignal];
6123        }
6124        const origin = this[kRealm].settingsObject.origin;
6125        let window = "client";
6126        if (request.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request.window, origin)) {
6127          window = request.window;
6128        }
6129        if (init.window != null) {
6130          throw new TypeError(`'window' option '${window}' must be null`);
6131        }
6132        if ("window" in init) {
6133          window = "no-window";
6134        }
6135        request = makeRequest({
6136          // URL request’s URL.
6137          // undici implementation note: this is set as the first item in request's urlList in makeRequest
6138          // method request’s method.
6139          method: request.method,
6140          // header list A copy of request’s header list.
6141          // undici implementation note: headersList is cloned in makeRequest
6142          headersList: request.headersList,
6143          // unsafe-request flag Set.
6144          unsafeRequest: request.unsafeRequest,
6145          // client This’s relevant settings object.
6146          client: this[kRealm].settingsObject,
6147          // window window.
6148          window,
6149          // priority request’s priority.
6150          priority: request.priority,
6151          // origin request’s origin. The propagation of the origin is only significant for navigation requests
6152          // being handled by a service worker. In this scenario a request can have an origin that is different
6153          // from the current client.
6154          origin: request.origin,
6155          // referrer request’s referrer.
6156          referrer: request.referrer,
6157          // referrer policy request’s referrer policy.
6158          referrerPolicy: request.referrerPolicy,
6159          // mode request’s mode.
6160          mode: request.mode,
6161          // credentials mode request’s credentials mode.
6162          credentials: request.credentials,
6163          // cache mode request’s cache mode.
6164          cache: request.cache,
6165          // redirect mode request’s redirect mode.
6166          redirect: request.redirect,
6167          // integrity metadata request’s integrity metadata.
6168          integrity: request.integrity,
6169          // keepalive request’s keepalive.
6170          keepalive: request.keepalive,
6171          // reload-navigation flag request’s reload-navigation flag.
6172          reloadNavigation: request.reloadNavigation,
6173          // history-navigation flag request’s history-navigation flag.
6174          historyNavigation: request.historyNavigation,
6175          // URL list A clone of request’s URL list.
6176          urlList: [...request.urlList]
6177        });
6178        const initHasKey = Object.keys(init).length !== 0;
6179        if (initHasKey) {
6180          if (request.mode === "navigate") {
6181            request.mode = "same-origin";
6182          }
6183          request.reloadNavigation = false;
6184          request.historyNavigation = false;
6185          request.origin = "client";
6186          request.referrer = "client";
6187          request.referrerPolicy = "";
6188          request.url = request.urlList[request.urlList.length - 1];
6189          request.urlList = [request.url];
6190        }
6191        if (init.referrer !== void 0) {
6192          const referrer = init.referrer;
6193          if (referrer === "") {
6194            request.referrer = "no-referrer";
6195          } else {
6196            let parsedReferrer;
6197            try {
6198              parsedReferrer = new URL(referrer, baseUrl);
6199            } catch (err) {
6200              throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err });
6201            }
6202            if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, this[kRealm].settingsObject.baseUrl)) {
6203              request.referrer = "client";
6204            } else {
6205              request.referrer = parsedReferrer;
6206            }
6207          }
6208        }
6209        if (init.referrerPolicy !== void 0) {
6210          request.referrerPolicy = init.referrerPolicy;
6211        }
6212        let mode;
6213        if (init.mode !== void 0) {
6214          mode = init.mode;
6215        } else {
6216          mode = fallbackMode;
6217        }
6218        if (mode === "navigate") {
6219          throw webidl.errors.exception({
6220            header: "Request constructor",
6221            message: "invalid request mode navigate."
6222          });
6223        }
6224        if (mode != null) {
6225          request.mode = mode;
6226        }
6227        if (init.credentials !== void 0) {
6228          request.credentials = init.credentials;
6229        }
6230        if (init.cache !== void 0) {
6231          request.cache = init.cache;
6232        }
6233        if (request.cache === "only-if-cached" && request.mode !== "same-origin") {
6234          throw new TypeError(
6235            "'only-if-cached' can be set only with 'same-origin' mode"
6236          );
6237        }
6238        if (init.redirect !== void 0) {
6239          request.redirect = init.redirect;
6240        }
6241        if (init.integrity != null) {
6242          request.integrity = String(init.integrity);
6243        }
6244        if (init.keepalive !== void 0) {
6245          request.keepalive = Boolean(init.keepalive);
6246        }
6247        if (init.method !== void 0) {
6248          let method = init.method;
6249          if (!isValidHTTPToken(method)) {
6250            throw new TypeError(`'${method}' is not a valid HTTP method.`);
6251          }
6252          if (forbiddenMethodsSet.has(method.toUpperCase())) {
6253            throw new TypeError(`'${method}' HTTP method is unsupported.`);
6254          }
6255          method = normalizeMethodRecord[method] ?? normalizeMethod(method);
6256          request.method = method;
6257        }
6258        if (init.signal !== void 0) {
6259          signal = init.signal;
6260        }
6261        this[kState] = request;
6262        const ac = new AbortController();
6263        this[kSignal] = ac.signal;
6264        this[kSignal][kRealm] = this[kRealm];
6265        if (signal != null) {
6266          if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") {
6267            throw new TypeError(
6268              "Failed to construct 'Request': member signal is not of type AbortSignal."
6269            );
6270          }
6271          if (signal.aborted) {
6272            ac.abort(signal.reason);
6273          } else {
6274            this[kAbortController] = ac;
6275            const acRef = new WeakRef(ac);
6276            const abort = /* @__PURE__ */ __name(function() {
6277              const ac2 = acRef.deref();
6278              if (ac2 !== void 0) {
6279                ac2.abort(this.reason);
6280              }
6281            }, "abort");
6282            try {
6283              if (typeof getMaxListeners === "function" && getMaxListeners(signal) === defaultMaxListeners) {
6284                setMaxListeners(100, signal);
6285              } else if (getEventListeners(signal, "abort").length >= defaultMaxListeners) {
6286                setMaxListeners(100, signal);
6287              }
6288            } catch {
6289            }
6290            util.addAbortListener(signal, abort);
6291            requestFinalizer.register(ac, { signal, abort });
6292          }
6293        }
6294        this[kHeaders] = new Headers(kConstruct);
6295        this[kHeaders][kHeadersList] = request.headersList;
6296        this[kHeaders][kGuard] = "request";
6297        this[kHeaders][kRealm] = this[kRealm];
6298        if (mode === "no-cors") {
6299          if (!corsSafeListedMethodsSet.has(request.method)) {
6300            throw new TypeError(
6301              `'${request.method} is unsupported in no-cors mode.`
6302            );
6303          }
6304          this[kHeaders][kGuard] = "request-no-cors";
6305        }
6306        if (initHasKey) {
6307          const headersList = this[kHeaders][kHeadersList];
6308          const headers = init.headers !== void 0 ? init.headers : new HeadersList(headersList);
6309          headersList.clear();
6310          if (headers instanceof HeadersList) {
6311            for (const [key, val] of headers) {
6312              headersList.append(key, val);
6313            }
6314            headersList.cookies = headers.cookies;
6315          } else {
6316            fillHeaders(this[kHeaders], headers);
6317          }
6318        }
6319        const inputBody = input instanceof _Request ? input[kState].body : null;
6320        if ((init.body != null || inputBody != null) && (request.method === "GET" || request.method === "HEAD")) {
6321          throw new TypeError("Request with GET/HEAD method cannot have body.");
6322        }
6323        let initBody = null;
6324        if (init.body != null) {
6325          const [extractedBody, contentType] = extractBody(
6326            init.body,
6327            request.keepalive
6328          );
6329          initBody = extractedBody;
6330          if (contentType && !this[kHeaders][kHeadersList].contains("content-type")) {
6331            this[kHeaders].append("content-type", contentType);
6332          }
6333        }
6334        const inputOrInitBody = initBody ?? inputBody;
6335        if (inputOrInitBody != null && inputOrInitBody.source == null) {
6336          if (initBody != null && init.duplex == null) {
6337            throw new TypeError("RequestInit: duplex option is required when sending a body.");
6338          }
6339          if (request.mode !== "same-origin" && request.mode !== "cors") {
6340            throw new TypeError(
6341              'If request is made from ReadableStream, mode should be "same-origin" or "cors"'
6342            );
6343          }
6344          request.useCORSPreflightFlag = true;
6345        }
6346        let finalBody = inputOrInitBody;
6347        if (initBody == null && inputBody != null) {
6348          if (util.isDisturbed(inputBody.stream) || inputBody.stream.locked) {
6349            throw new TypeError(
6350              "Cannot construct a Request with a Request object that has already been used."
6351            );
6352          }
6353          if (!TransformStream) {
6354            TransformStream = require("stream/web").TransformStream;
6355          }
6356          const identityTransform = new TransformStream();
6357          inputBody.stream.pipeThrough(identityTransform);
6358          finalBody = {
6359            source: inputBody.source,
6360            length: inputBody.length,
6361            stream: identityTransform.readable
6362          };
6363        }
6364        this[kState].body = finalBody;
6365      }
6366      // Returns request’s HTTP method, which is "GET" by default.
6367      get method() {
6368        webidl.brandCheck(this, _Request);
6369        return this[kState].method;
6370      }
6371      // Returns the URL of request as a string.
6372      get url() {
6373        webidl.brandCheck(this, _Request);
6374        return URLSerializer(this[kState].url);
6375      }
6376      // Returns a Headers object consisting of the headers associated with request.
6377      // Note that headers added in the network layer by the user agent will not
6378      // be accounted for in this object, e.g., the "Host" header.
6379      get headers() {
6380        webidl.brandCheck(this, _Request);
6381        return this[kHeaders];
6382      }
6383      // Returns the kind of resource requested by request, e.g., "document"
6384      // or "script".
6385      get destination() {
6386        webidl.brandCheck(this, _Request);
6387        return this[kState].destination;
6388      }
6389      // Returns the referrer of request. Its value can be a same-origin URL if
6390      // explicitly set in init, the empty string to indicate no referrer, and
6391      // "about:client" when defaulting to the global’s default. This is used
6392      // during fetching to determine the value of the `Referer` header of the
6393      // request being made.
6394      get referrer() {
6395        webidl.brandCheck(this, _Request);
6396        if (this[kState].referrer === "no-referrer") {
6397          return "";
6398        }
6399        if (this[kState].referrer === "client") {
6400          return "about:client";
6401        }
6402        return this[kState].referrer.toString();
6403      }
6404      // Returns the referrer policy associated with request.
6405      // This is used during fetching to compute the value of the request’s
6406      // referrer.
6407      get referrerPolicy() {
6408        webidl.brandCheck(this, _Request);
6409        return this[kState].referrerPolicy;
6410      }
6411      // Returns the mode associated with request, which is a string indicating
6412      // whether the request will use CORS, or will be restricted to same-origin
6413      // URLs.
6414      get mode() {
6415        webidl.brandCheck(this, _Request);
6416        return this[kState].mode;
6417      }
6418      // Returns the credentials mode associated with request,
6419      // which is a string indicating whether credentials will be sent with the
6420      // request always, never, or only when sent to a same-origin URL.
6421      get credentials() {
6422        return this[kState].credentials;
6423      }
6424      // Returns the cache mode associated with request,
6425      // which is a string indicating how the request will
6426      // interact with the browser’s cache when fetching.
6427      get cache() {
6428        webidl.brandCheck(this, _Request);
6429        return this[kState].cache;
6430      }
6431      // Returns the redirect mode associated with request,
6432      // which is a string indicating how redirects for the
6433      // request will be handled during fetching. A request
6434      // will follow redirects by default.
6435      get redirect() {
6436        webidl.brandCheck(this, _Request);
6437        return this[kState].redirect;
6438      }
6439      // Returns request’s subresource integrity metadata, which is a
6440      // cryptographic hash of the resource being fetched. Its value
6441      // consists of multiple hashes separated by whitespace. [SRI]
6442      get integrity() {
6443        webidl.brandCheck(this, _Request);
6444        return this[kState].integrity;
6445      }
6446      // Returns a boolean indicating whether or not request can outlive the
6447      // global in which it was created.
6448      get keepalive() {
6449        webidl.brandCheck(this, _Request);
6450        return this[kState].keepalive;
6451      }
6452      // Returns a boolean indicating whether or not request is for a reload
6453      // navigation.
6454      get isReloadNavigation() {
6455        webidl.brandCheck(this, _Request);
6456        return this[kState].reloadNavigation;
6457      }
6458      // Returns a boolean indicating whether or not request is for a history
6459      // navigation (a.k.a. back-foward navigation).
6460      get isHistoryNavigation() {
6461        webidl.brandCheck(this, _Request);
6462        return this[kState].historyNavigation;
6463      }
6464      // Returns the signal associated with request, which is an AbortSignal
6465      // object indicating whether or not request has been aborted, and its
6466      // abort event handler.
6467      get signal() {
6468        webidl.brandCheck(this, _Request);
6469        return this[kSignal];
6470      }
6471      get body() {
6472        webidl.brandCheck(this, _Request);
6473        return this[kState].body ? this[kState].body.stream : null;
6474      }
6475      get bodyUsed() {
6476        webidl.brandCheck(this, _Request);
6477        return !!this[kState].body && util.isDisturbed(this[kState].body.stream);
6478      }
6479      get duplex() {
6480        webidl.brandCheck(this, _Request);
6481        return "half";
6482      }
6483      // Returns a clone of request.
6484      clone() {
6485        webidl.brandCheck(this, _Request);
6486        if (this.bodyUsed || this.body?.locked) {
6487          throw new TypeError("unusable");
6488        }
6489        const clonedRequest = cloneRequest(this[kState]);
6490        const clonedRequestObject = new _Request(kConstruct);
6491        clonedRequestObject[kState] = clonedRequest;
6492        clonedRequestObject[kRealm] = this[kRealm];
6493        clonedRequestObject[kHeaders] = new Headers(kConstruct);
6494        clonedRequestObject[kHeaders][kHeadersList] = clonedRequest.headersList;
6495        clonedRequestObject[kHeaders][kGuard] = this[kHeaders][kGuard];
6496        clonedRequestObject[kHeaders][kRealm] = this[kHeaders][kRealm];
6497        const ac = new AbortController();
6498        if (this.signal.aborted) {
6499          ac.abort(this.signal.reason);
6500        } else {
6501          util.addAbortListener(
6502            this.signal,
6503            () => {
6504              ac.abort(this.signal.reason);
6505            }
6506          );
6507        }
6508        clonedRequestObject[kSignal] = ac.signal;
6509        return clonedRequestObject;
6510      }
6511    };
6512    mixinBody(Request);
6513    function makeRequest(init) {
6514      const request = {
6515        method: "GET",
6516        localURLsOnly: false,
6517        unsafeRequest: false,
6518        body: null,
6519        client: null,
6520        reservedClient: null,
6521        replacesClientId: "",
6522        window: "client",
6523        keepalive: false,
6524        serviceWorkers: "all",
6525        initiator: "",
6526        destination: "",
6527        priority: null,
6528        origin: "client",
6529        policyContainer: "client",
6530        referrer: "client",
6531        referrerPolicy: "",
6532        mode: "no-cors",
6533        useCORSPreflightFlag: false,
6534        credentials: "same-origin",
6535        useCredentials: false,
6536        cache: "default",
6537        redirect: "follow",
6538        integrity: "",
6539        cryptoGraphicsNonceMetadata: "",
6540        parserMetadata: "",
6541        reloadNavigation: false,
6542        historyNavigation: false,
6543        userActivation: false,
6544        taintedOrigin: false,
6545        redirectCount: 0,
6546        responseTainting: "basic",
6547        preventNoCacheCacheControlHeaderModification: false,
6548        done: false,
6549        timingAllowFailed: false,
6550        ...init,
6551        headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList()
6552      };
6553      request.url = request.urlList[0];
6554      return request;
6555    }
6556    __name(makeRequest, "makeRequest");
6557    function cloneRequest(request) {
6558      const newRequest = makeRequest({ ...request, body: null });
6559      if (request.body != null) {
6560        newRequest.body = cloneBody(request.body);
6561      }
6562      return newRequest;
6563    }
6564    __name(cloneRequest, "cloneRequest");
6565    Object.defineProperties(Request.prototype, {
6566      method: kEnumerableProperty,
6567      url: kEnumerableProperty,
6568      headers: kEnumerableProperty,
6569      redirect: kEnumerableProperty,
6570      clone: kEnumerableProperty,
6571      signal: kEnumerableProperty,
6572      duplex: kEnumerableProperty,
6573      destination: kEnumerableProperty,
6574      body: kEnumerableProperty,
6575      bodyUsed: kEnumerableProperty,
6576      isHistoryNavigation: kEnumerableProperty,
6577      isReloadNavigation: kEnumerableProperty,
6578      keepalive: kEnumerableProperty,
6579      integrity: kEnumerableProperty,
6580      cache: kEnumerableProperty,
6581      credentials: kEnumerableProperty,
6582      attribute: kEnumerableProperty,
6583      referrerPolicy: kEnumerableProperty,
6584      referrer: kEnumerableProperty,
6585      mode: kEnumerableProperty,
6586      [Symbol.toStringTag]: {
6587        value: "Request",
6588        configurable: true
6589      }
6590    });
6591    webidl.converters.Request = webidl.interfaceConverter(
6592      Request
6593    );
6594    webidl.converters.RequestInfo = function(V) {
6595      if (typeof V === "string") {
6596        return webidl.converters.USVString(V);
6597      }
6598      if (V instanceof Request) {
6599        return webidl.converters.Request(V);
6600      }
6601      return webidl.converters.USVString(V);
6602    };
6603    webidl.converters.AbortSignal = webidl.interfaceConverter(
6604      AbortSignal
6605    );
6606    webidl.converters.RequestInit = webidl.dictionaryConverter([
6607      {
6608        key: "method",
6609        converter: webidl.converters.ByteString
6610      },
6611      {
6612        key: "headers",
6613        converter: webidl.converters.HeadersInit
6614      },
6615      {
6616        key: "body",
6617        converter: webidl.nullableConverter(
6618          webidl.converters.BodyInit
6619        )
6620      },
6621      {
6622        key: "referrer",
6623        converter: webidl.converters.USVString
6624      },
6625      {
6626        key: "referrerPolicy",
6627        converter: webidl.converters.DOMString,
6628        // https://w3c.github.io/webappsec-referrer-policy/#referrer-policy
6629        allowedValues: referrerPolicy
6630      },
6631      {
6632        key: "mode",
6633        converter: webidl.converters.DOMString,
6634        // https://fetch.spec.whatwg.org/#concept-request-mode
6635        allowedValues: requestMode
6636      },
6637      {
6638        key: "credentials",
6639        converter: webidl.converters.DOMString,
6640        // https://fetch.spec.whatwg.org/#requestcredentials
6641        allowedValues: requestCredentials
6642      },
6643      {
6644        key: "cache",
6645        converter: webidl.converters.DOMString,
6646        // https://fetch.spec.whatwg.org/#requestcache
6647        allowedValues: requestCache
6648      },
6649      {
6650        key: "redirect",
6651        converter: webidl.converters.DOMString,
6652        // https://fetch.spec.whatwg.org/#requestredirect
6653        allowedValues: requestRedirect
6654      },
6655      {
6656        key: "integrity",
6657        converter: webidl.converters.DOMString
6658      },
6659      {
6660        key: "keepalive",
6661        converter: webidl.converters.boolean
6662      },
6663      {
6664        key: "signal",
6665        converter: webidl.nullableConverter(
6666          (signal) => webidl.converters.AbortSignal(
6667            signal,
6668            { strict: false }
6669          )
6670        )
6671      },
6672      {
6673        key: "window",
6674        converter: webidl.converters.any
6675      },
6676      {
6677        key: "duplex",
6678        converter: webidl.converters.DOMString,
6679        allowedValues: requestDuplex
6680      }
6681    ]);
6682    module2.exports = { Request, makeRequest };
6683  }
6684});
6685
6686// lib/dispatcher.js
6687var require_dispatcher = __commonJS({
6688  "lib/dispatcher.js"(exports2, module2) {
6689    "use strict";
6690    var EventEmitter = require("events");
6691    var Dispatcher = class extends EventEmitter {
6692      static {
6693        __name(this, "Dispatcher");
6694      }
6695      dispatch() {
6696        throw new Error("not implemented");
6697      }
6698      close() {
6699        throw new Error("not implemented");
6700      }
6701      destroy() {
6702        throw new Error("not implemented");
6703      }
6704    };
6705    module2.exports = Dispatcher;
6706  }
6707});
6708
6709// lib/dispatcher-base.js
6710var require_dispatcher_base = __commonJS({
6711  "lib/dispatcher-base.js"(exports2, module2) {
6712    "use strict";
6713    var Dispatcher = require_dispatcher();
6714    var {
6715      ClientDestroyedError,
6716      ClientClosedError,
6717      InvalidArgumentError
6718    } = require_errors();
6719    var { kDestroy, kClose, kDispatch, kInterceptors } = require_symbols();
6720    var kDestroyed = Symbol("destroyed");
6721    var kClosed = Symbol("closed");
6722    var kOnDestroyed = Symbol("onDestroyed");
6723    var kOnClosed = Symbol("onClosed");
6724    var kInterceptedDispatch = Symbol("Intercepted Dispatch");
6725    var DispatcherBase = class extends Dispatcher {
6726      static {
6727        __name(this, "DispatcherBase");
6728      }
6729      constructor() {
6730        super();
6731        this[kDestroyed] = false;
6732        this[kOnDestroyed] = null;
6733        this[kClosed] = false;
6734        this[kOnClosed] = [];
6735      }
6736      get destroyed() {
6737        return this[kDestroyed];
6738      }
6739      get closed() {
6740        return this[kClosed];
6741      }
6742      get interceptors() {
6743        return this[kInterceptors];
6744      }
6745      set interceptors(newInterceptors) {
6746        if (newInterceptors) {
6747          for (let i = newInterceptors.length - 1; i >= 0; i--) {
6748            const interceptor = this[kInterceptors][i];
6749            if (typeof interceptor !== "function") {
6750              throw new InvalidArgumentError("interceptor must be an function");
6751            }
6752          }
6753        }
6754        this[kInterceptors] = newInterceptors;
6755      }
6756      close(callback) {
6757        if (callback === void 0) {
6758          return new Promise((resolve, reject) => {
6759            this.close((err, data) => {
6760              return err ? reject(err) : resolve(data);
6761            });
6762          });
6763        }
6764        if (typeof callback !== "function") {
6765          throw new InvalidArgumentError("invalid callback");
6766        }
6767        if (this[kDestroyed]) {
6768          queueMicrotask(() => callback(new ClientDestroyedError(), null));
6769          return;
6770        }
6771        if (this[kClosed]) {
6772          if (this[kOnClosed]) {
6773            this[kOnClosed].push(callback);
6774          } else {
6775            queueMicrotask(() => callback(null, null));
6776          }
6777          return;
6778        }
6779        this[kClosed] = true;
6780        this[kOnClosed].push(callback);
6781        const onClosed = /* @__PURE__ */ __name(() => {
6782          const callbacks = this[kOnClosed];
6783          this[kOnClosed] = null;
6784          for (let i = 0; i < callbacks.length; i++) {
6785            callbacks[i](null, null);
6786          }
6787        }, "onClosed");
6788        this[kClose]().then(() => this.destroy()).then(() => {
6789          queueMicrotask(onClosed);
6790        });
6791      }
6792      destroy(err, callback) {
6793        if (typeof err === "function") {
6794          callback = err;
6795          err = null;
6796        }
6797        if (callback === void 0) {
6798          return new Promise((resolve, reject) => {
6799            this.destroy(err, (err2, data) => {
6800              return err2 ? (
6801                /* istanbul ignore next: should never error */
6802                reject(err2)
6803              ) : resolve(data);
6804            });
6805          });
6806        }
6807        if (typeof callback !== "function") {
6808          throw new InvalidArgumentError("invalid callback");
6809        }
6810        if (this[kDestroyed]) {
6811          if (this[kOnDestroyed]) {
6812            this[kOnDestroyed].push(callback);
6813          } else {
6814            queueMicrotask(() => callback(null, null));
6815          }
6816          return;
6817        }
6818        if (!err) {
6819          err = new ClientDestroyedError();
6820        }
6821        this[kDestroyed] = true;
6822        this[kOnDestroyed] = this[kOnDestroyed] || [];
6823        this[kOnDestroyed].push(callback);
6824        const onDestroyed = /* @__PURE__ */ __name(() => {
6825          const callbacks = this[kOnDestroyed];
6826          this[kOnDestroyed] = null;
6827          for (let i = 0; i < callbacks.length; i++) {
6828            callbacks[i](null, null);
6829          }
6830        }, "onDestroyed");
6831        this[kDestroy](err).then(() => {
6832          queueMicrotask(onDestroyed);
6833        });
6834      }
6835      [kInterceptedDispatch](opts, handler) {
6836        if (!this[kInterceptors] || this[kInterceptors].length === 0) {
6837          this[kInterceptedDispatch] = this[kDispatch];
6838          return this[kDispatch](opts, handler);
6839        }
6840        let dispatch = this[kDispatch].bind(this);
6841        for (let i = this[kInterceptors].length - 1; i >= 0; i--) {
6842          dispatch = this[kInterceptors][i](dispatch);
6843        }
6844        this[kInterceptedDispatch] = dispatch;
6845        return dispatch(opts, handler);
6846      }
6847      dispatch(opts, handler) {
6848        if (!handler || typeof handler !== "object") {
6849          throw new InvalidArgumentError("handler must be an object");
6850        }
6851        try {
6852          if (!opts || typeof opts !== "object") {
6853            throw new InvalidArgumentError("opts must be an object.");
6854          }
6855          if (this[kDestroyed] || this[kOnDestroyed]) {
6856            throw new ClientDestroyedError();
6857          }
6858          if (this[kClosed]) {
6859            throw new ClientClosedError();
6860          }
6861          return this[kInterceptedDispatch](opts, handler);
6862        } catch (err) {
6863          if (typeof handler.onError !== "function") {
6864            throw new InvalidArgumentError("invalid onError method");
6865          }
6866          handler.onError(err);
6867          return false;
6868        }
6869      }
6870    };
6871    module2.exports = DispatcherBase;
6872  }
6873});
6874
6875// lib/node/fixed-queue.js
6876var require_fixed_queue = __commonJS({
6877  "lib/node/fixed-queue.js"(exports2, module2) {
6878    "use strict";
6879    var kSize = 2048;
6880    var kMask = kSize - 1;
6881    var FixedCircularBuffer = class {
6882      static {
6883        __name(this, "FixedCircularBuffer");
6884      }
6885      constructor() {
6886        this.bottom = 0;
6887        this.top = 0;
6888        this.list = new Array(kSize);
6889        this.next = null;
6890      }
6891      isEmpty() {
6892        return this.top === this.bottom;
6893      }
6894      isFull() {
6895        return (this.top + 1 & kMask) === this.bottom;
6896      }
6897      push(data) {
6898        this.list[this.top] = data;
6899        this.top = this.top + 1 & kMask;
6900      }
6901      shift() {
6902        const nextItem = this.list[this.bottom];
6903        if (nextItem === void 0)
6904          return null;
6905        this.list[this.bottom] = void 0;
6906        this.bottom = this.bottom + 1 & kMask;
6907        return nextItem;
6908      }
6909    };
6910    module2.exports = class FixedQueue {
6911      static {
6912        __name(this, "FixedQueue");
6913      }
6914      constructor() {
6915        this.head = this.tail = new FixedCircularBuffer();
6916      }
6917      isEmpty() {
6918        return this.head.isEmpty();
6919      }
6920      push(data) {
6921        if (this.head.isFull()) {
6922          this.head = this.head.next = new FixedCircularBuffer();
6923        }
6924        this.head.push(data);
6925      }
6926      shift() {
6927        const tail = this.tail;
6928        const next = tail.shift();
6929        if (tail.isEmpty() && tail.next !== null) {
6930          this.tail = tail.next;
6931        }
6932        return next;
6933      }
6934    };
6935  }
6936});
6937
6938// lib/pool-stats.js
6939var require_pool_stats = __commonJS({
6940  "lib/pool-stats.js"(exports2, module2) {
6941    var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols();
6942    var kPool = Symbol("pool");
6943    var PoolStats = class {
6944      static {
6945        __name(this, "PoolStats");
6946      }
6947      constructor(pool) {
6948        this[kPool] = pool;
6949      }
6950      get connected() {
6951        return this[kPool][kConnected];
6952      }
6953      get free() {
6954        return this[kPool][kFree];
6955      }
6956      get pending() {
6957        return this[kPool][kPending];
6958      }
6959      get queued() {
6960        return this[kPool][kQueued];
6961      }
6962      get running() {
6963        return this[kPool][kRunning];
6964      }
6965      get size() {
6966        return this[kPool][kSize];
6967      }
6968    };
6969    module2.exports = PoolStats;
6970  }
6971});
6972
6973// lib/pool-base.js
6974var require_pool_base = __commonJS({
6975  "lib/pool-base.js"(exports2, module2) {
6976    "use strict";
6977    var DispatcherBase = require_dispatcher_base();
6978    var FixedQueue = require_fixed_queue();
6979    var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols();
6980    var PoolStats = require_pool_stats();
6981    var kClients = Symbol("clients");
6982    var kNeedDrain = Symbol("needDrain");
6983    var kQueue = Symbol("queue");
6984    var kClosedResolve = Symbol("closed resolve");
6985    var kOnDrain = Symbol("onDrain");
6986    var kOnConnect = Symbol("onConnect");
6987    var kOnDisconnect = Symbol("onDisconnect");
6988    var kOnConnectionError = Symbol("onConnectionError");
6989    var kGetDispatcher = Symbol("get dispatcher");
6990    var kAddClient = Symbol("add client");
6991    var kRemoveClient = Symbol("remove client");
6992    var kStats = Symbol("stats");
6993    var PoolBase = class extends DispatcherBase {
6994      static {
6995        __name(this, "PoolBase");
6996      }
6997      constructor() {
6998        super();
6999        this[kQueue] = new FixedQueue();
7000        this[kClients] = [];
7001        this[kQueued] = 0;
7002        const pool = this;
7003        this[kOnDrain] = /* @__PURE__ */ __name(function onDrain(origin, targets) {
7004          const queue = pool[kQueue];
7005          let needDrain = false;
7006          while (!needDrain) {
7007            const item = queue.shift();
7008            if (!item) {
7009              break;
7010            }
7011            pool[kQueued]--;
7012            needDrain = !this.dispatch(item.opts, item.handler);
7013          }
7014          this[kNeedDrain] = needDrain;
7015          if (!this[kNeedDrain] && pool[kNeedDrain]) {
7016            pool[kNeedDrain] = false;
7017            pool.emit("drain", origin, [pool, ...targets]);
7018          }
7019          if (pool[kClosedResolve] && queue.isEmpty()) {
7020            Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]);
7021          }
7022        }, "onDrain");
7023        this[kOnConnect] = (origin, targets) => {
7024          pool.emit("connect", origin, [pool, ...targets]);
7025        };
7026        this[kOnDisconnect] = (origin, targets, err) => {
7027          pool.emit("disconnect", origin, [pool, ...targets], err);
7028        };
7029        this[kOnConnectionError] = (origin, targets, err) => {
7030          pool.emit("connectionError", origin, [pool, ...targets], err);
7031        };
7032        this[kStats] = new PoolStats(this);
7033      }
7034      get [kBusy]() {
7035        return this[kNeedDrain];
7036      }
7037      get [kConnected]() {
7038        return this[kClients].filter((client) => client[kConnected]).length;
7039      }
7040      get [kFree]() {
7041        return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length;
7042      }
7043      get [kPending]() {
7044        let ret = this[kQueued];
7045        for (const { [kPending]: pending } of this[kClients]) {
7046          ret += pending;
7047        }
7048        return ret;
7049      }
7050      get [kRunning]() {
7051        let ret = 0;
7052        for (const { [kRunning]: running } of this[kClients]) {
7053          ret += running;
7054        }
7055        return ret;
7056      }
7057      get [kSize]() {
7058        let ret = this[kQueued];
7059        for (const { [kSize]: size } of this[kClients]) {
7060          ret += size;
7061        }
7062        return ret;
7063      }
7064      get stats() {
7065        return this[kStats];
7066      }
7067      async [kClose]() {
7068        if (this[kQueue].isEmpty()) {
7069          return Promise.all(this[kClients].map((c) => c.close()));
7070        } else {
7071          return new Promise((resolve) => {
7072            this[kClosedResolve] = resolve;
7073          });
7074        }
7075      }
7076      async [kDestroy](err) {
7077        while (true) {
7078          const item = this[kQueue].shift();
7079          if (!item) {
7080            break;
7081          }
7082          item.handler.onError(err);
7083        }
7084        return Promise.all(this[kClients].map((c) => c.destroy(err)));
7085      }
7086      [kDispatch](opts, handler) {
7087        const dispatcher = this[kGetDispatcher]();
7088        if (!dispatcher) {
7089          this[kNeedDrain] = true;
7090          this[kQueue].push({ opts, handler });
7091          this[kQueued]++;
7092        } else if (!dispatcher.dispatch(opts, handler)) {
7093          dispatcher[kNeedDrain] = true;
7094          this[kNeedDrain] = !this[kGetDispatcher]();
7095        }
7096        return !this[kNeedDrain];
7097      }
7098      [kAddClient](client) {
7099        client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
7100        this[kClients].push(client);
7101        if (this[kNeedDrain]) {
7102          process.nextTick(() => {
7103            if (this[kNeedDrain]) {
7104              this[kOnDrain](client[kUrl], [this, client]);
7105            }
7106          });
7107        }
7108        return this;
7109      }
7110      [kRemoveClient](client) {
7111        client.close(() => {
7112          const idx = this[kClients].indexOf(client);
7113          if (idx !== -1) {
7114            this[kClients].splice(idx, 1);
7115          }
7116        });
7117        this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true);
7118      }
7119    };
7120    module2.exports = {
7121      PoolBase,
7122      kClients,
7123      kNeedDrain,
7124      kAddClient,
7125      kRemoveClient,
7126      kGetDispatcher
7127    };
7128  }
7129});
7130
7131// lib/timers.js
7132var require_timers = __commonJS({
7133  "lib/timers.js"(exports2, module2) {
7134    "use strict";
7135    var fastNow = Date.now();
7136    var fastNowTimeout;
7137    var fastTimers = [];
7138    function onTimeout() {
7139      fastNow = Date.now();
7140      let len = fastTimers.length;
7141      let idx = 0;
7142      while (idx < len) {
7143        const timer = fastTimers[idx];
7144        if (timer.state === 0) {
7145          timer.state = fastNow + timer.delay;
7146        } else if (timer.state > 0 && fastNow >= timer.state) {
7147          timer.state = -1;
7148          timer.callback(timer.opaque);
7149        }
7150        if (timer.state === -1) {
7151          timer.state = -2;
7152          if (idx !== len - 1) {
7153            fastTimers[idx] = fastTimers.pop();
7154          } else {
7155            fastTimers.pop();
7156          }
7157          len -= 1;
7158        } else {
7159          idx += 1;
7160        }
7161      }
7162      if (fastTimers.length > 0) {
7163        refreshTimeout();
7164      }
7165    }
7166    __name(onTimeout, "onTimeout");
7167    function refreshTimeout() {
7168      if (fastNowTimeout && fastNowTimeout.refresh) {
7169        fastNowTimeout.refresh();
7170      } else {
7171        clearTimeout(fastNowTimeout);
7172        fastNowTimeout = setTimeout(onTimeout, 1e3);
7173        if (fastNowTimeout.unref) {
7174          fastNowTimeout.unref();
7175        }
7176      }
7177    }
7178    __name(refreshTimeout, "refreshTimeout");
7179    var Timeout = class {
7180      static {
7181        __name(this, "Timeout");
7182      }
7183      constructor(callback, delay, opaque) {
7184        this.callback = callback;
7185        this.delay = delay;
7186        this.opaque = opaque;
7187        this.state = -2;
7188        this.refresh();
7189      }
7190      refresh() {
7191        if (this.state === -2) {
7192          fastTimers.push(this);
7193          if (!fastNowTimeout || fastTimers.length === 1) {
7194            refreshTimeout();
7195          }
7196        }
7197        this.state = 0;
7198      }
7199      clear() {
7200        this.state = -1;
7201      }
7202    };
7203    module2.exports = {
7204      setTimeout(callback, delay, opaque) {
7205        return delay < 1e3 ? setTimeout(callback, delay, opaque) : new Timeout(callback, delay, opaque);
7206      },
7207      clearTimeout(timeout) {
7208        if (timeout instanceof Timeout) {
7209          timeout.clear();
7210        } else {
7211          clearTimeout(timeout);
7212        }
7213      }
7214    };
7215  }
7216});
7217
7218// lib/core/request.js
7219var require_request2 = __commonJS({
7220  "lib/core/request.js"(exports2, module2) {
7221    "use strict";
7222    var {
7223      InvalidArgumentError,
7224      NotSupportedError
7225    } = require_errors();
7226    var assert = require("assert");
7227    var { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require_symbols();
7228    var util = require_util();
7229    var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
7230    var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
7231    var invalidPathRegex = /[^\u0021-\u00ff]/;
7232    var kHandler = Symbol("handler");
7233    var channels = {};
7234    var extractBody;
7235    try {
7236      const diagnosticsChannel = require("diagnostics_channel");
7237      channels.create = diagnosticsChannel.channel("undici:request:create");
7238      channels.bodySent = diagnosticsChannel.channel("undici:request:bodySent");
7239      channels.headers = diagnosticsChannel.channel("undici:request:headers");
7240      channels.trailers = diagnosticsChannel.channel("undici:request:trailers");
7241      channels.error = diagnosticsChannel.channel("undici:request:error");
7242    } catch {
7243      channels.create = { hasSubscribers: false };
7244      channels.bodySent = { hasSubscribers: false };
7245      channels.headers = { hasSubscribers: false };
7246      channels.trailers = { hasSubscribers: false };
7247      channels.error = { hasSubscribers: false };
7248    }
7249    var Request = class _Request {
7250      static {
7251        __name(this, "Request");
7252      }
7253      constructor(origin, {
7254        path,
7255        method,
7256        body,
7257        headers,
7258        query,
7259        idempotent,
7260        blocking,
7261        upgrade,
7262        headersTimeout,
7263        bodyTimeout,
7264        reset,
7265        throwOnError,
7266        expectContinue
7267      }, handler) {
7268        if (typeof path !== "string") {
7269          throw new InvalidArgumentError("path must be a string");
7270        } else if (path[0] !== "/" && !(path.startsWith("http://") || path.startsWith("https://")) && method !== "CONNECT") {
7271          throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
7272        } else if (invalidPathRegex.exec(path) !== null) {
7273          throw new InvalidArgumentError("invalid request path");
7274        }
7275        if (typeof method !== "string") {
7276          throw new InvalidArgumentError("method must be a string");
7277        } else if (tokenRegExp.exec(method) === null) {
7278          throw new InvalidArgumentError("invalid request method");
7279        }
7280        if (upgrade && typeof upgrade !== "string") {
7281          throw new InvalidArgumentError("upgrade must be a string");
7282        }
7283        if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
7284          throw new InvalidArgumentError("invalid headersTimeout");
7285        }
7286        if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
7287          throw new InvalidArgumentError("invalid bodyTimeout");
7288        }
7289        if (reset != null && typeof reset !== "boolean") {
7290          throw new InvalidArgumentError("invalid reset");
7291        }
7292        if (expectContinue != null && typeof expectContinue !== "boolean") {
7293          throw new InvalidArgumentError("invalid expectContinue");
7294        }
7295        this.headersTimeout = headersTimeout;
7296        this.bodyTimeout = bodyTimeout;
7297        this.throwOnError = throwOnError === true;
7298        this.method = method;
7299        this.abort = null;
7300        if (body == null) {
7301          this.body = null;
7302        } else if (util.isStream(body)) {
7303          this.body = body;
7304          const rState = this.body._readableState;
7305          if (!rState || !rState.autoDestroy) {
7306            this.endHandler = /* @__PURE__ */ __name(function autoDestroy() {
7307              util.destroy(this);
7308            }, "autoDestroy");
7309            this.body.on("end", this.endHandler);
7310          }
7311          this.errorHandler = (err) => {
7312            if (this.abort) {
7313              this.abort(err);
7314            } else {
7315              this.error = err;
7316            }
7317          };
7318          this.body.on("error", this.errorHandler);
7319        } else if (util.isBuffer(body)) {
7320          this.body = body.byteLength ? body : null;
7321        } else if (ArrayBuffer.isView(body)) {
7322          this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null;
7323        } else if (body instanceof ArrayBuffer) {
7324          this.body = body.byteLength ? Buffer.from(body) : null;
7325        } else if (typeof body === "string") {
7326          this.body = body.length ? Buffer.from(body) : null;
7327        } else if (util.isFormDataLike(body) || util.isIterable(body) || util.isBlobLike(body)) {
7328          this.body = body;
7329        } else {
7330          throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable");
7331        }
7332        this.completed = false;
7333        this.aborted = false;
7334        this.upgrade = upgrade || null;
7335        this.path = query ? util.buildURL(path, query) : path;
7336        this.origin = origin;
7337        this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
7338        this.blocking = blocking == null ? false : blocking;
7339        this.reset = reset == null ? null : reset;
7340        this.host = null;
7341        this.contentLength = null;
7342        this.contentType = null;
7343        this.headers = "";
7344        this.expectContinue = expectContinue != null ? expectContinue : false;
7345        if (Array.isArray(headers)) {
7346          if (headers.length % 2 !== 0) {
7347            throw new InvalidArgumentError("headers array must be even");
7348          }
7349          for (let i = 0; i < headers.length; i += 2) {
7350            processHeader(this, headers[i], headers[i + 1]);
7351          }
7352        } else if (headers && typeof headers === "object") {
7353          const keys = Object.keys(headers);
7354          for (let i = 0; i < keys.length; i++) {
7355            const key = keys[i];
7356            processHeader(this, key, headers[key]);
7357          }
7358        } else if (headers != null) {
7359          throw new InvalidArgumentError("headers must be an object or an array");
7360        }
7361        if (util.isFormDataLike(this.body)) {
7362          if (util.nodeMajor < 16 || util.nodeMajor === 16 && util.nodeMinor < 8) {
7363            throw new InvalidArgumentError("Form-Data bodies are only supported in node v16.8 and newer.");
7364          }
7365          if (!extractBody) {
7366            extractBody = require_body().extractBody;
7367          }
7368          const [bodyStream, contentType] = extractBody(body);
7369          if (this.contentType == null) {
7370            this.contentType = contentType;
7371            this.headers += `content-type: ${contentType}\r
7372`;
7373          }
7374          this.body = bodyStream.stream;
7375          this.contentLength = bodyStream.length;
7376        } else if (util.isBlobLike(body) && this.contentType == null && body.type) {
7377          this.contentType = body.type;
7378          this.headers += `content-type: ${body.type}\r
7379`;
7380        }
7381        util.validateHandler(handler, method, upgrade);
7382        this.servername = util.getServerName(this.host);
7383        this[kHandler] = handler;
7384        if (channels.create.hasSubscribers) {
7385          channels.create.publish({ request: this });
7386        }
7387      }
7388      onBodySent(chunk) {
7389        if (this[kHandler].onBodySent) {
7390          try {
7391            return this[kHandler].onBodySent(chunk);
7392          } catch (err) {
7393            this.abort(err);
7394          }
7395        }
7396      }
7397      onRequestSent() {
7398        if (channels.bodySent.hasSubscribers) {
7399          channels.bodySent.publish({ request: this });
7400        }
7401        if (this[kHandler].onRequestSent) {
7402          try {
7403            return this[kHandler].onRequestSent();
7404          } catch (err) {
7405            this.abort(err);
7406          }
7407        }
7408      }
7409      onConnect(abort) {
7410        assert(!this.aborted);
7411        assert(!this.completed);
7412        if (this.error) {
7413          abort(this.error);
7414        } else {
7415          this.abort = abort;
7416          return this[kHandler].onConnect(abort);
7417        }
7418      }
7419      onHeaders(statusCode, headers, resume, statusText) {
7420        assert(!this.aborted);
7421        assert(!this.completed);
7422        if (channels.headers.hasSubscribers) {
7423          channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
7424        }
7425        try {
7426          return this[kHandler].onHeaders(statusCode, headers, resume, statusText);
7427        } catch (err) {
7428          this.abort(err);
7429        }
7430      }
7431      onData(chunk) {
7432        assert(!this.aborted);
7433        assert(!this.completed);
7434        try {
7435          return this[kHandler].onData(chunk);
7436        } catch (err) {
7437          this.abort(err);
7438          return false;
7439        }
7440      }
7441      onUpgrade(statusCode, headers, socket) {
7442        assert(!this.aborted);
7443        assert(!this.completed);
7444        return this[kHandler].onUpgrade(statusCode, headers, socket);
7445      }
7446      onComplete(trailers) {
7447        this.onFinally();
7448        assert(!this.aborted);
7449        this.completed = true;
7450        if (channels.trailers.hasSubscribers) {
7451          channels.trailers.publish({ request: this, trailers });
7452        }
7453        try {
7454          return this[kHandler].onComplete(trailers);
7455        } catch (err) {
7456          this.onError(err);
7457        }
7458      }
7459      onError(error) {
7460        this.onFinally();
7461        if (channels.error.hasSubscribers) {
7462          channels.error.publish({ request: this, error });
7463        }
7464        if (this.aborted) {
7465          return;
7466        }
7467        this.aborted = true;
7468        return this[kHandler].onError(error);
7469      }
7470      onFinally() {
7471        if (this.errorHandler) {
7472          this.body.off("error", this.errorHandler);
7473          this.errorHandler = null;
7474        }
7475        if (this.endHandler) {
7476          this.body.off("end", this.endHandler);
7477          this.endHandler = null;
7478        }
7479      }
7480      // TODO: adjust to support H2
7481      addHeader(key, value) {
7482        processHeader(this, key, value);
7483        return this;
7484      }
7485      static [kHTTP1BuildRequest](origin, opts, handler) {
7486        return new _Request(origin, opts, handler);
7487      }
7488      static [kHTTP2BuildRequest](origin, opts, handler) {
7489        const headers = opts.headers;
7490        opts = { ...opts, headers: null };
7491        const request = new _Request(origin, opts, handler);
7492        request.headers = {};
7493        if (Array.isArray(headers)) {
7494          if (headers.length % 2 !== 0) {
7495            throw new InvalidArgumentError("headers array must be even");
7496          }
7497          for (let i = 0; i < headers.length; i += 2) {
7498            processHeader(request, headers[i], headers[i + 1], true);
7499          }
7500        } else if (headers && typeof headers === "object") {
7501          const keys = Object.keys(headers);
7502          for (let i = 0; i < keys.length; i++) {
7503            const key = keys[i];
7504            processHeader(request, key, headers[key], true);
7505          }
7506        } else if (headers != null) {
7507          throw new InvalidArgumentError("headers must be an object or an array");
7508        }
7509        return request;
7510      }
7511      static [kHTTP2CopyHeaders](raw) {
7512        const rawHeaders = raw.split("\r\n");
7513        const headers = {};
7514        for (const header of rawHeaders) {
7515          const [key, value] = header.split(": ");
7516          if (value == null || value.length === 0)
7517            continue;
7518          if (headers[key])
7519            headers[key] += `,${value}`;
7520          else
7521            headers[key] = value;
7522        }
7523        return headers;
7524      }
7525    };
7526    function processHeaderValue(key, val, skipAppend) {
7527      if (val && typeof val === "object") {
7528        throw new InvalidArgumentError(`invalid ${key} header`);
7529      }
7530      val = val != null ? `${val}` : "";
7531      if (headerCharRegex.exec(val) !== null) {
7532        throw new InvalidArgumentError(`invalid ${key} header`);
7533      }
7534      return skipAppend ? val : `${key}: ${val}\r
7535`;
7536    }
7537    __name(processHeaderValue, "processHeaderValue");
7538    function processHeader(request, key, val, skipAppend = false) {
7539      if (val && (typeof val === "object" && !Array.isArray(val))) {
7540        throw new InvalidArgumentError(`invalid ${key} header`);
7541      } else if (val === void 0) {
7542        return;
7543      }
7544      if (request.host === null && key.length === 4 && key.toLowerCase() === "host") {
7545        if (headerCharRegex.exec(val) !== null) {
7546          throw new InvalidArgumentError(`invalid ${key} header`);
7547        }
7548        request.host = val;
7549      } else if (request.contentLength === null && key.length === 14 && key.toLowerCase() === "content-length") {
7550        request.contentLength = parseInt(val, 10);
7551        if (!Number.isFinite(request.contentLength)) {
7552          throw new InvalidArgumentError("invalid content-length header");
7553        }
7554      } else if (request.contentType === null && key.length === 12 && key.toLowerCase() === "content-type") {
7555        request.contentType = val;
7556        if (skipAppend)
7557          request.headers[key] = processHeaderValue(key, val, skipAppend);
7558        else
7559          request.headers += processHeaderValue(key, val);
7560      } else if (key.length === 17 && key.toLowerCase() === "transfer-encoding") {
7561        throw new InvalidArgumentError("invalid transfer-encoding header");
7562      } else if (key.length === 10 && key.toLowerCase() === "connection") {
7563        const value = typeof val === "string" ? val.toLowerCase() : null;
7564        if (value !== "close" && value !== "keep-alive") {
7565          throw new InvalidArgumentError("invalid connection header");
7566        } else if (value === "close") {
7567          request.reset = true;
7568        }
7569      } else if (key.length === 10 && key.toLowerCase() === "keep-alive") {
7570        throw new InvalidArgumentError("invalid keep-alive header");
7571      } else if (key.length === 7 && key.toLowerCase() === "upgrade") {
7572        throw new InvalidArgumentError("invalid upgrade header");
7573      } else if (key.length === 6 && key.toLowerCase() === "expect") {
7574        throw new NotSupportedError("expect header not supported");
7575      } else if (tokenRegExp.exec(key) === null) {
7576        throw new InvalidArgumentError("invalid header key");
7577      } else {
7578        if (Array.isArray(val)) {
7579          for (let i = 0; i < val.length; i++) {
7580            if (skipAppend) {
7581              if (request.headers[key])
7582                request.headers[key] += `,${processHeaderValue(key, val[i], skipAppend)}`;
7583              else
7584                request.headers[key] = processHeaderValue(key, val[i], skipAppend);
7585            } else {
7586              request.headers += processHeaderValue(key, val[i]);
7587            }
7588          }
7589        } else {
7590          if (skipAppend)
7591            request.headers[key] = processHeaderValue(key, val, skipAppend);
7592          else
7593            request.headers += processHeaderValue(key, val);
7594        }
7595      }
7596    }
7597    __name(processHeader, "processHeader");
7598    module2.exports = Request;
7599  }
7600});
7601
7602// lib/core/connect.js
7603var require_connect = __commonJS({
7604  "lib/core/connect.js"(exports2, module2) {
7605    "use strict";
7606    var net = require("net");
7607    var assert = require("assert");
7608    var util = require_util();
7609    var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
7610    var tls;
7611    var SessionCache;
7612    if (global.FinalizationRegistry && !process.env.NODE_V8_COVERAGE) {
7613      SessionCache = class WeakSessionCache {
7614        static {
7615          __name(this, "WeakSessionCache");
7616        }
7617        constructor(maxCachedSessions) {
7618          this._maxCachedSessions = maxCachedSessions;
7619          this._sessionCache = /* @__PURE__ */ new Map();
7620          this._sessionRegistry = new global.FinalizationRegistry((key) => {
7621            if (this._sessionCache.size < this._maxCachedSessions) {
7622              return;
7623            }
7624            const ref = this._sessionCache.get(key);
7625            if (ref !== void 0 && ref.deref() === void 0) {
7626              this._sessionCache.delete(key);
7627            }
7628          });
7629        }
7630        get(sessionKey) {
7631          const ref = this._sessionCache.get(sessionKey);
7632          return ref ? ref.deref() : null;
7633        }
7634        set(sessionKey, session) {
7635          if (this._maxCachedSessions === 0) {
7636            return;
7637          }
7638          this._sessionCache.set(sessionKey, new WeakRef(session));
7639          this._sessionRegistry.register(session, sessionKey);
7640        }
7641      };
7642    } else {
7643      SessionCache = class SimpleSessionCache {
7644        static {
7645          __name(this, "SimpleSessionCache");
7646        }
7647        constructor(maxCachedSessions) {
7648          this._maxCachedSessions = maxCachedSessions;
7649          this._sessionCache = /* @__PURE__ */ new Map();
7650        }
7651        get(sessionKey) {
7652          return this._sessionCache.get(sessionKey);
7653        }
7654        set(sessionKey, session) {
7655          if (this._maxCachedSessions === 0) {
7656            return;
7657          }
7658          if (this._sessionCache.size >= this._maxCachedSessions) {
7659            const { value: oldestKey } = this._sessionCache.keys().next();
7660            this._sessionCache.delete(oldestKey);
7661          }
7662          this._sessionCache.set(sessionKey, session);
7663        }
7664      };
7665    }
7666    function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, ...opts }) {
7667      if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
7668        throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero");
7669      }
7670      const options = { path: socketPath, ...opts };
7671      const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
7672      timeout = timeout == null ? 1e4 : timeout;
7673      allowH2 = allowH2 != null ? allowH2 : false;
7674      return /* @__PURE__ */ __name(function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
7675        let socket;
7676        if (protocol === "https:") {
7677          if (!tls) {
7678            tls = require("tls");
7679          }
7680          servername = servername || options.servername || util.getServerName(host) || null;
7681          const sessionKey = servername || hostname;
7682          const session = sessionCache.get(sessionKey) || null;
7683          assert(sessionKey);
7684          socket = tls.connect({
7685            highWaterMark: 16384,
7686            // TLS in node can't have bigger HWM anyway...
7687            ...options,
7688            servername,
7689            session,
7690            localAddress,
7691            // TODO(HTTP/2): Add support for h2c
7692            ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"],
7693            socket: httpSocket,
7694            // upgrade socket connection
7695            port: port || 443,
7696            host: hostname
7697          });
7698          socket.on("session", function(session2) {
7699            sessionCache.set(sessionKey, session2);
7700          });
7701        } else {
7702          assert(!httpSocket, "httpSocket can only be sent on TLS update");
7703          socket = net.connect({
7704            highWaterMark: 64 * 1024,
7705            // Same as nodejs fs streams.
7706            ...options,
7707            localAddress,
7708            port: port || 80,
7709            host: hostname
7710          });
7711        }
7712        if (options.keepAlive == null || options.keepAlive) {
7713          const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay;
7714          socket.setKeepAlive(true, keepAliveInitialDelay);
7715        }
7716        const cancelTimeout = setupTimeout(() => onConnectTimeout(socket), timeout);
7717        socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() {
7718          cancelTimeout();
7719          if (callback) {
7720            const cb = callback;
7721            callback = null;
7722            cb(null, this);
7723          }
7724        }).on("error", function(err) {
7725          cancelTimeout();
7726          if (callback) {
7727            const cb = callback;
7728            callback = null;
7729            cb(err);
7730          }
7731        });
7732        return socket;
7733      }, "connect");
7734    }
7735    __name(buildConnector, "buildConnector");
7736    function setupTimeout(onConnectTimeout2, timeout) {
7737      if (!timeout) {
7738        return () => {
7739        };
7740      }
7741      let s1 = null;
7742      let s2 = null;
7743      const timeoutId = setTimeout(() => {
7744        s1 = setImmediate(() => {
7745          if (process.platform === "win32") {
7746            s2 = setImmediate(() => onConnectTimeout2());
7747          } else {
7748            onConnectTimeout2();
7749          }
7750        });
7751      }, timeout);
7752      return () => {
7753        clearTimeout(timeoutId);
7754        clearImmediate(s1);
7755        clearImmediate(s2);
7756      };
7757    }
7758    __name(setupTimeout, "setupTimeout");
7759    function onConnectTimeout(socket) {
7760      util.destroy(socket, new ConnectTimeoutError());
7761    }
7762    __name(onConnectTimeout, "onConnectTimeout");
7763    module2.exports = buildConnector;
7764  }
7765});
7766
7767// lib/llhttp/utils.js
7768var require_utils = __commonJS({
7769  "lib/llhttp/utils.js"(exports2) {
7770    "use strict";
7771    Object.defineProperty(exports2, "__esModule", { value: true });
7772    exports2.enumToMap = void 0;
7773    function enumToMap(obj) {
7774      const res = {};
7775      Object.keys(obj).forEach((key) => {
7776        const value = obj[key];
7777        if (typeof value === "number") {
7778          res[key] = value;
7779        }
7780      });
7781      return res;
7782    }
7783    __name(enumToMap, "enumToMap");
7784    exports2.enumToMap = enumToMap;
7785  }
7786});
7787
7788// lib/llhttp/constants.js
7789var require_constants3 = __commonJS({
7790  "lib/llhttp/constants.js"(exports2) {
7791    "use strict";
7792    Object.defineProperty(exports2, "__esModule", { value: true });
7793    exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0;
7794    var utils_1 = require_utils();
7795    var ERROR;
7796    (function(ERROR2) {
7797      ERROR2[ERROR2["OK"] = 0] = "OK";
7798      ERROR2[ERROR2["INTERNAL"] = 1] = "INTERNAL";
7799      ERROR2[ERROR2["STRICT"] = 2] = "STRICT";
7800      ERROR2[ERROR2["LF_EXPECTED"] = 3] = "LF_EXPECTED";
7801      ERROR2[ERROR2["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH";
7802      ERROR2[ERROR2["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION";
7803      ERROR2[ERROR2["INVALID_METHOD"] = 6] = "INVALID_METHOD";
7804      ERROR2[ERROR2["INVALID_URL"] = 7] = "INVALID_URL";
7805      ERROR2[ERROR2["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT";
7806      ERROR2[ERROR2["INVALID_VERSION"] = 9] = "INVALID_VERSION";
7807      ERROR2[ERROR2["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN";
7808      ERROR2[ERROR2["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH";
7809      ERROR2[ERROR2["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE";
7810      ERROR2[ERROR2["INVALID_STATUS"] = 13] = "INVALID_STATUS";
7811      ERROR2[ERROR2["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE";
7812      ERROR2[ERROR2["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING";
7813      ERROR2[ERROR2["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN";
7814      ERROR2[ERROR2["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE";
7815      ERROR2[ERROR2["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE";
7816      ERROR2[ERROR2["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER";
7817      ERROR2[ERROR2["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE";
7818      ERROR2[ERROR2["PAUSED"] = 21] = "PAUSED";
7819      ERROR2[ERROR2["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE";
7820      ERROR2[ERROR2["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE";
7821      ERROR2[ERROR2["USER"] = 24] = "USER";
7822    })(ERROR = exports2.ERROR || (exports2.ERROR = {}));
7823    var TYPE;
7824    (function(TYPE2) {
7825      TYPE2[TYPE2["BOTH"] = 0] = "BOTH";
7826      TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST";
7827      TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE";
7828    })(TYPE = exports2.TYPE || (exports2.TYPE = {}));
7829    var FLAGS;
7830    (function(FLAGS2) {
7831      FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE";
7832      FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE";
7833      FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE";
7834      FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED";
7835      FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE";
7836      FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH";
7837      FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY";
7838      FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING";
7839      FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING";
7840    })(FLAGS = exports2.FLAGS || (exports2.FLAGS = {}));
7841    var LENIENT_FLAGS;
7842    (function(LENIENT_FLAGS2) {
7843      LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS";
7844      LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH";
7845      LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE";
7846    })(LENIENT_FLAGS = exports2.LENIENT_FLAGS || (exports2.LENIENT_FLAGS = {}));
7847    var METHODS;
7848    (function(METHODS2) {
7849      METHODS2[METHODS2["DELETE"] = 0] = "DELETE";
7850      METHODS2[METHODS2["GET"] = 1] = "GET";
7851      METHODS2[METHODS2["HEAD"] = 2] = "HEAD";
7852      METHODS2[METHODS2["POST"] = 3] = "POST";
7853      METHODS2[METHODS2["PUT"] = 4] = "PUT";
7854      METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT";
7855      METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS";
7856      METHODS2[METHODS2["TRACE"] = 7] = "TRACE";
7857      METHODS2[METHODS2["COPY"] = 8] = "COPY";
7858      METHODS2[METHODS2["LOCK"] = 9] = "LOCK";
7859      METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL";
7860      METHODS2[METHODS2["MOVE"] = 11] = "MOVE";
7861      METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND";
7862      METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH";
7863      METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH";
7864      METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK";
7865      METHODS2[METHODS2["BIND"] = 16] = "BIND";
7866      METHODS2[METHODS2["REBIND"] = 17] = "REBIND";
7867      METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND";
7868      METHODS2[METHODS2["ACL"] = 19] = "ACL";
7869      METHODS2[METHODS2["REPORT"] = 20] = "REPORT";
7870      METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY";
7871      METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT";
7872      METHODS2[METHODS2["MERGE"] = 23] = "MERGE";
7873      METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH";
7874      METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY";
7875      METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE";
7876      METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE";
7877      METHODS2[METHODS2["PATCH"] = 28] = "PATCH";
7878      METHODS2[METHODS2["PURGE"] = 29] = "PURGE";
7879      METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR";
7880      METHODS2[METHODS2["LINK"] = 31] = "LINK";
7881      METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK";
7882      METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE";
7883      METHODS2[METHODS2["PRI"] = 34] = "PRI";
7884      METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE";
7885      METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE";
7886      METHODS2[METHODS2["SETUP"] = 37] = "SETUP";
7887      METHODS2[METHODS2["PLAY"] = 38] = "PLAY";
7888      METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE";
7889      METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN";
7890      METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER";
7891      METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER";
7892      METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT";
7893      METHODS2[METHODS2["RECORD"] = 44] = "RECORD";
7894      METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH";
7895    })(METHODS = exports2.METHODS || (exports2.METHODS = {}));
7896    exports2.METHODS_HTTP = [
7897      METHODS.DELETE,
7898      METHODS.GET,
7899      METHODS.HEAD,
7900      METHODS.POST,
7901      METHODS.PUT,
7902      METHODS.CONNECT,
7903      METHODS.OPTIONS,
7904      METHODS.TRACE,
7905      METHODS.COPY,
7906      METHODS.LOCK,
7907      METHODS.MKCOL,
7908      METHODS.MOVE,
7909      METHODS.PROPFIND,
7910      METHODS.PROPPATCH,
7911      METHODS.SEARCH,
7912      METHODS.UNLOCK,
7913      METHODS.BIND,
7914      METHODS.REBIND,
7915      METHODS.UNBIND,
7916      METHODS.ACL,
7917      METHODS.REPORT,
7918      METHODS.MKACTIVITY,
7919      METHODS.CHECKOUT,
7920      METHODS.MERGE,
7921      METHODS["M-SEARCH"],
7922      METHODS.NOTIFY,
7923      METHODS.SUBSCRIBE,
7924      METHODS.UNSUBSCRIBE,
7925      METHODS.PATCH,
7926      METHODS.PURGE,
7927      METHODS.MKCALENDAR,
7928      METHODS.LINK,
7929      METHODS.UNLINK,
7930      METHODS.PRI,
7931      // TODO(indutny): should we allow it with HTTP?
7932      METHODS.SOURCE
7933    ];
7934    exports2.METHODS_ICE = [
7935      METHODS.SOURCE
7936    ];
7937    exports2.METHODS_RTSP = [
7938      METHODS.OPTIONS,
7939      METHODS.DESCRIBE,
7940      METHODS.ANNOUNCE,
7941      METHODS.SETUP,
7942      METHODS.PLAY,
7943      METHODS.PAUSE,
7944      METHODS.TEARDOWN,
7945      METHODS.GET_PARAMETER,
7946      METHODS.SET_PARAMETER,
7947      METHODS.REDIRECT,
7948      METHODS.RECORD,
7949      METHODS.FLUSH,
7950      // For AirPlay
7951      METHODS.GET,
7952      METHODS.POST
7953    ];
7954    exports2.METHOD_MAP = utils_1.enumToMap(METHODS);
7955    exports2.H_METHOD_MAP = {};
7956    Object.keys(exports2.METHOD_MAP).forEach((key) => {
7957      if (/^H/.test(key)) {
7958        exports2.H_METHOD_MAP[key] = exports2.METHOD_MAP[key];
7959      }
7960    });
7961    var FINISH;
7962    (function(FINISH2) {
7963      FINISH2[FINISH2["SAFE"] = 0] = "SAFE";
7964      FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB";
7965      FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE";
7966    })(FINISH = exports2.FINISH || (exports2.FINISH = {}));
7967    exports2.ALPHA = [];
7968    for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) {
7969      exports2.ALPHA.push(String.fromCharCode(i));
7970      exports2.ALPHA.push(String.fromCharCode(i + 32));
7971    }
7972    exports2.NUM_MAP = {
7973      0: 0,
7974      1: 1,
7975      2: 2,
7976      3: 3,
7977      4: 4,
7978      5: 5,
7979      6: 6,
7980      7: 7,
7981      8: 8,
7982      9: 9
7983    };
7984    exports2.HEX_MAP = {
7985      0: 0,
7986      1: 1,
7987      2: 2,
7988      3: 3,
7989      4: 4,
7990      5: 5,
7991      6: 6,
7992      7: 7,
7993      8: 8,
7994      9: 9,
7995      A: 10,
7996      B: 11,
7997      C: 12,
7998      D: 13,
7999      E: 14,
8000      F: 15,
8001      a: 10,
8002      b: 11,
8003      c: 12,
8004      d: 13,
8005      e: 14,
8006      f: 15
8007    };
8008    exports2.NUM = [
8009      "0",
8010      "1",
8011      "2",
8012      "3",
8013      "4",
8014      "5",
8015      "6",
8016      "7",
8017      "8",
8018      "9"
8019    ];
8020    exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM);
8021    exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"];
8022    exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]);
8023    exports2.STRICT_URL_CHAR = [
8024      "!",
8025      '"',
8026      "$",
8027      "%",
8028      "&",
8029      "'",
8030      "(",
8031      ")",
8032      "*",
8033      "+",
8034      ",",
8035      "-",
8036      ".",
8037      "/",
8038      ":",
8039      ";",
8040      "<",
8041      "=",
8042      ">",
8043      "@",
8044      "[",
8045      "\\",
8046      "]",
8047      "^",
8048      "_",
8049      "`",
8050      "{",
8051      "|",
8052      "}",
8053      "~"
8054    ].concat(exports2.ALPHANUM);
8055    exports2.URL_CHAR = exports2.STRICT_URL_CHAR.concat(["	", "\f"]);
8056    for (let i = 128; i <= 255; i++) {
8057      exports2.URL_CHAR.push(i);
8058    }
8059    exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]);
8060    exports2.STRICT_TOKEN = [
8061      "!",
8062      "#",
8063      "$",
8064      "%",
8065      "&",
8066      "'",
8067      "*",
8068      "+",
8069      "-",
8070      ".",
8071      "^",
8072      "_",
8073      "`",
8074      "|",
8075      "~"
8076    ].concat(exports2.ALPHANUM);
8077    exports2.TOKEN = exports2.STRICT_TOKEN.concat([" "]);
8078    exports2.HEADER_CHARS = ["	"];
8079    for (let i = 32; i <= 255; i++) {
8080      if (i !== 127) {
8081        exports2.HEADER_CHARS.push(i);
8082      }
8083    }
8084    exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c) => c !== 44);
8085    exports2.MAJOR = exports2.NUM_MAP;
8086    exports2.MINOR = exports2.MAJOR;
8087    var HEADER_STATE;
8088    (function(HEADER_STATE2) {
8089      HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL";
8090      HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION";
8091      HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH";
8092      HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING";
8093      HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE";
8094      HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE";
8095      HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE";
8096      HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE";
8097      HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED";
8098    })(HEADER_STATE = exports2.HEADER_STATE || (exports2.HEADER_STATE = {}));
8099    exports2.SPECIAL_HEADERS = {
8100      "connection": HEADER_STATE.CONNECTION,
8101      "content-length": HEADER_STATE.CONTENT_LENGTH,
8102      "proxy-connection": HEADER_STATE.CONNECTION,
8103      "transfer-encoding": HEADER_STATE.TRANSFER_ENCODING,
8104      "upgrade": HEADER_STATE.UPGRADE
8105    };
8106  }
8107});
8108
8109// lib/handler/RedirectHandler.js
8110var require_RedirectHandler = __commonJS({
8111  "lib/handler/RedirectHandler.js"(exports2, module2) {
8112    "use strict";
8113    var util = require_util();
8114    var { kBodyUsed } = require_symbols();
8115    var assert = require("assert");
8116    var { InvalidArgumentError } = require_errors();
8117    var EE = require("events");
8118    var redirectableStatusCodes = [300, 301, 302, 303, 307, 308];
8119    var kBody = Symbol("body");
8120    var BodyAsyncIterable = class {
8121      static {
8122        __name(this, "BodyAsyncIterable");
8123      }
8124      constructor(body) {
8125        this[kBody] = body;
8126        this[kBodyUsed] = false;
8127      }
8128      async *[Symbol.asyncIterator]() {
8129        assert(!this[kBodyUsed], "disturbed");
8130        this[kBodyUsed] = true;
8131        yield* this[kBody];
8132      }
8133    };
8134    var RedirectHandler = class {
8135      static {
8136        __name(this, "RedirectHandler");
8137      }
8138      constructor(dispatch, maxRedirections, opts, handler) {
8139        if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
8140          throw new InvalidArgumentError("maxRedirections must be a positive number");
8141        }
8142        util.validateHandler(handler, opts.method, opts.upgrade);
8143        this.dispatch = dispatch;
8144        this.location = null;
8145        this.abort = null;
8146        this.opts = { ...opts, maxRedirections: 0 };
8147        this.maxRedirections = maxRedirections;
8148        this.handler = handler;
8149        this.history = [];
8150        if (util.isStream(this.opts.body)) {
8151          if (util.bodyLength(this.opts.body) === 0) {
8152            this.opts.body.on("data", function() {
8153              assert(false);
8154            });
8155          }
8156          if (typeof this.opts.body.readableDidRead !== "boolean") {
8157            this.opts.body[kBodyUsed] = false;
8158            EE.prototype.on.call(this.opts.body, "data", function() {
8159              this[kBodyUsed] = true;
8160            });
8161          }
8162        } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") {
8163          this.opts.body = new BodyAsyncIterable(this.opts.body);
8164        } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util.isIterable(this.opts.body)) {
8165          this.opts.body = new BodyAsyncIterable(this.opts.body);
8166        }
8167      }
8168      onConnect(abort) {
8169        this.abort = abort;
8170        this.handler.onConnect(abort, { history: this.history });
8171      }
8172      onUpgrade(statusCode, headers, socket) {
8173        this.handler.onUpgrade(statusCode, headers, socket);
8174      }
8175      onError(error) {
8176        this.handler.onError(error);
8177      }
8178      onHeaders(statusCode, headers, resume, statusText) {
8179        this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers);
8180        if (this.opts.origin) {
8181          this.history.push(new URL(this.opts.path, this.opts.origin));
8182        }
8183        if (!this.location) {
8184          return this.handler.onHeaders(statusCode, headers, resume, statusText);
8185        }
8186        const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
8187        const path = search ? `${pathname}${search}` : pathname;
8188        this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
8189        this.opts.path = path;
8190        this.opts.origin = origin;
8191        this.opts.maxRedirections = 0;
8192        this.opts.query = null;
8193        if (statusCode === 303 && this.opts.method !== "HEAD") {
8194          this.opts.method = "GET";
8195          this.opts.body = null;
8196        }
8197      }
8198      onData(chunk) {
8199        if (this.location) {
8200        } else {
8201          return this.handler.onData(chunk);
8202        }
8203      }
8204      onComplete(trailers) {
8205        if (this.location) {
8206          this.location = null;
8207          this.abort = null;
8208          this.dispatch(this.opts, this);
8209        } else {
8210          this.handler.onComplete(trailers);
8211        }
8212      }
8213      onBodySent(chunk) {
8214        if (this.handler.onBodySent) {
8215          this.handler.onBodySent(chunk);
8216        }
8217      }
8218    };
8219    function parseLocation(statusCode, headers) {
8220      if (redirectableStatusCodes.indexOf(statusCode) === -1) {
8221        return null;
8222      }
8223      for (let i = 0; i < headers.length; i += 2) {
8224        if (headers[i].toString().toLowerCase() === "location") {
8225          return headers[i + 1];
8226        }
8227      }
8228    }
8229    __name(parseLocation, "parseLocation");
8230    function shouldRemoveHeader(header, removeContent, unknownOrigin) {
8231      if (header.length === 4) {
8232        return util.headerNameToString(header) === "host";
8233      }
8234      if (removeContent && util.headerNameToString(header).startsWith("content-")) {
8235        return true;
8236      }
8237      if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) {
8238        const name = util.headerNameToString(header);
8239        return name === "authorization" || name === "cookie" || name === "proxy-authorization";
8240      }
8241      return false;
8242    }
8243    __name(shouldRemoveHeader, "shouldRemoveHeader");
8244    function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
8245      const ret = [];
8246      if (Array.isArray(headers)) {
8247        for (let i = 0; i < headers.length; i += 2) {
8248          if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) {
8249            ret.push(headers[i], headers[i + 1]);
8250          }
8251        }
8252      } else if (headers && typeof headers === "object") {
8253        for (const key of Object.keys(headers)) {
8254          if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
8255            ret.push(key, headers[key]);
8256          }
8257        }
8258      } else {
8259        assert(headers == null, "headers must be an object or an array");
8260      }
8261      return ret;
8262    }
8263    __name(cleanRequestHeaders, "cleanRequestHeaders");
8264    module2.exports = RedirectHandler;
8265  }
8266});
8267
8268// lib/interceptor/redirectInterceptor.js
8269var require_redirectInterceptor = __commonJS({
8270  "lib/interceptor/redirectInterceptor.js"(exports2, module2) {
8271    "use strict";
8272    var RedirectHandler = require_RedirectHandler();
8273    function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) {
8274      return (dispatch) => {
8275        return /* @__PURE__ */ __name(function Intercept(opts, handler) {
8276          const { maxRedirections = defaultMaxRedirections } = opts;
8277          if (!maxRedirections) {
8278            return dispatch(opts, handler);
8279          }
8280          const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler);
8281          opts = { ...opts, maxRedirections: 0 };
8282          return dispatch(opts, redirectHandler);
8283        }, "Intercept");
8284      };
8285    }
8286    __name(createRedirectInterceptor, "createRedirectInterceptor");
8287    module2.exports = createRedirectInterceptor;
8288  }
8289});
8290
8291// lib/llhttp/llhttp-wasm.js
8292var require_llhttp_wasm = __commonJS({
8293  "lib/llhttp/llhttp-wasm.js"(exports2, module2) {
8294    module2.exports = "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";
8295  }
8296});
8297
8298// lib/llhttp/llhttp_simd-wasm.js
8299var require_llhttp_simd_wasm = __commonJS({
8300  "lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) {
8301    module2.exports = "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";
8302  }
8303});
8304
8305// lib/client.js
8306var require_client = __commonJS({
8307  "lib/client.js"(exports2, module2) {
8308    "use strict";
8309    var assert = require("assert");
8310    var net = require("net");
8311    var http = require("http");
8312    var { pipeline } = require("stream");
8313    var util = require_util();
8314    var timers = require_timers();
8315    var Request = require_request2();
8316    var DispatcherBase = require_dispatcher_base();
8317    var {
8318      RequestContentLengthMismatchError,
8319      ResponseContentLengthMismatchError,
8320      InvalidArgumentError,
8321      RequestAbortedError,
8322      HeadersTimeoutError,
8323      HeadersOverflowError,
8324      SocketError,
8325      InformationalError,
8326      BodyTimeoutError,
8327      HTTPParserError,
8328      ResponseExceededMaxSizeError,
8329      ClientDestroyedError
8330    } = require_errors();
8331    var buildConnector = require_connect();
8332    var {
8333      kUrl,
8334      kReset,
8335      kServerName,
8336      kClient,
8337      kBusy,
8338      kParser,
8339      kConnect,
8340      kBlocking,
8341      kResuming,
8342      kRunning,
8343      kPending,
8344      kSize,
8345      kWriting,
8346      kQueue,
8347      kConnected,
8348      kConnecting,
8349      kNeedDrain,
8350      kNoRef,
8351      kKeepAliveDefaultTimeout,
8352      kHostHeader,
8353      kPendingIdx,
8354      kRunningIdx,
8355      kError,
8356      kPipelining,
8357      kSocket,
8358      kKeepAliveTimeoutValue,
8359      kMaxHeadersSize,
8360      kKeepAliveMaxTimeout,
8361      kKeepAliveTimeoutThreshold,
8362      kHeadersTimeout,
8363      kBodyTimeout,
8364      kStrictContentLength,
8365      kConnector,
8366      kMaxRedirections,
8367      kMaxRequests,
8368      kCounter,
8369      kClose,
8370      kDestroy,
8371      kDispatch,
8372      kInterceptors,
8373      kLocalAddress,
8374      kMaxResponseSize,
8375      kHTTPConnVersion,
8376      // HTTP2
8377      kHost,
8378      kHTTP2Session,
8379      kHTTP2SessionState,
8380      kHTTP2BuildRequest,
8381      kHTTP2CopyHeaders,
8382      kHTTP1BuildRequest
8383    } = require_symbols();
8384    var http2;
8385    try {
8386      http2 = require("http2");
8387    } catch {
8388      http2 = { constants: {} };
8389    }
8390    var {
8391      constants: {
8392        HTTP2_HEADER_AUTHORITY,
8393        HTTP2_HEADER_METHOD,
8394        HTTP2_HEADER_PATH,
8395        HTTP2_HEADER_SCHEME,
8396        HTTP2_HEADER_CONTENT_LENGTH,
8397        HTTP2_HEADER_EXPECT,
8398        HTTP2_HEADER_STATUS
8399      }
8400    } = http2;
8401    var h2ExperimentalWarned = false;
8402    var FastBuffer = Buffer[Symbol.species];
8403    var kClosedResolve = Symbol("kClosedResolve");
8404    var channels = {};
8405    try {
8406      const diagnosticsChannel = require("diagnostics_channel");
8407      channels.sendHeaders = diagnosticsChannel.channel("undici:client:sendHeaders");
8408      channels.beforeConnect = diagnosticsChannel.channel("undici:client:beforeConnect");
8409      channels.connectError = diagnosticsChannel.channel("undici:client:connectError");
8410      channels.connected = diagnosticsChannel.channel("undici:client:connected");
8411    } catch {
8412      channels.sendHeaders = { hasSubscribers: false };
8413      channels.beforeConnect = { hasSubscribers: false };
8414      channels.connectError = { hasSubscribers: false };
8415      channels.connected = { hasSubscribers: false };
8416    }
8417    var Client = class extends DispatcherBase {
8418      static {
8419        __name(this, "Client");
8420      }
8421      /**
8422       *
8423       * @param {string|URL} url
8424       * @param {import('../types/client').Client.Options} options
8425       */
8426      constructor(url, {
8427        interceptors,
8428        maxHeaderSize,
8429        headersTimeout,
8430        socketTimeout,
8431        requestTimeout,
8432        connectTimeout,
8433        bodyTimeout,
8434        idleTimeout,
8435        keepAlive,
8436        keepAliveTimeout,
8437        maxKeepAliveTimeout,
8438        keepAliveMaxTimeout,
8439        keepAliveTimeoutThreshold,
8440        socketPath,
8441        pipelining,
8442        tls,
8443        strictContentLength,
8444        maxCachedSessions,
8445        maxRedirections,
8446        connect: connect2,
8447        maxRequestsPerClient,
8448        localAddress,
8449        maxResponseSize,
8450        autoSelectFamily,
8451        autoSelectFamilyAttemptTimeout,
8452        // h2
8453        allowH2,
8454        maxConcurrentStreams
8455      } = {}) {
8456        super();
8457        if (keepAlive !== void 0) {
8458          throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead");
8459        }
8460        if (socketTimeout !== void 0) {
8461          throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead");
8462        }
8463        if (requestTimeout !== void 0) {
8464          throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead");
8465        }
8466        if (idleTimeout !== void 0) {
8467          throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead");
8468        }
8469        if (maxKeepAliveTimeout !== void 0) {
8470          throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead");
8471        }
8472        if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) {
8473          throw new InvalidArgumentError("invalid maxHeaderSize");
8474        }
8475        if (socketPath != null && typeof socketPath !== "string") {
8476          throw new InvalidArgumentError("invalid socketPath");
8477        }
8478        if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) {
8479          throw new InvalidArgumentError("invalid connectTimeout");
8480        }
8481        if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) {
8482          throw new InvalidArgumentError("invalid keepAliveTimeout");
8483        }
8484        if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) {
8485          throw new InvalidArgumentError("invalid keepAliveMaxTimeout");
8486        }
8487        if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) {
8488          throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold");
8489        }
8490        if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) {
8491          throw new InvalidArgumentError("headersTimeout must be a positive integer or zero");
8492        }
8493        if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) {
8494          throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero");
8495        }
8496        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
8497          throw new InvalidArgumentError("connect must be a function or an object");
8498        }
8499        if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
8500          throw new InvalidArgumentError("maxRedirections must be a positive number");
8501        }
8502        if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
8503          throw new InvalidArgumentError("maxRequestsPerClient must be a positive number");
8504        }
8505        if (localAddress != null && (typeof localAddress !== "string" || net.isIP(localAddress) === 0)) {
8506          throw new InvalidArgumentError("localAddress must be valid string IP address");
8507        }
8508        if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) {
8509          throw new InvalidArgumentError("maxResponseSize must be a positive number");
8510        }
8511        if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) {
8512          throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number");
8513        }
8514        if (allowH2 != null && typeof allowH2 !== "boolean") {
8515          throw new InvalidArgumentError("allowH2 must be a valid boolean value");
8516        }
8517        if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) {
8518          throw new InvalidArgumentError("maxConcurrentStreams must be a possitive integer, greater than 0");
8519        }
8520        if (typeof connect2 !== "function") {
8521          connect2 = buildConnector({
8522            ...tls,
8523            maxCachedSessions,
8524            allowH2,
8525            socketPath,
8526            timeout: connectTimeout,
8527            ...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
8528            ...connect2
8529          });
8530        }
8531        this[kInterceptors] = interceptors && interceptors.Client && Array.isArray(interceptors.Client) ? interceptors.Client : [createRedirectInterceptor({ maxRedirections })];
8532        this[kUrl] = util.parseOrigin(url);
8533        this[kConnector] = connect2;
8534        this[kSocket] = null;
8535        this[kPipelining] = pipelining != null ? pipelining : 1;
8536        this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize;
8537        this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout;
8538        this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout;
8539        this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold;
8540        this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout];
8541        this[kServerName] = null;
8542        this[kLocalAddress] = localAddress != null ? localAddress : null;
8543        this[kResuming] = 0;
8544        this[kNeedDrain] = 0;
8545        this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r
8546`;
8547        this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5;
8548        this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5;
8549        this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength;
8550        this[kMaxRedirections] = maxRedirections;
8551        this[kMaxRequests] = maxRequestsPerClient;
8552        this[kClosedResolve] = null;
8553        this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1;
8554        this[kHTTPConnVersion] = "h1";
8555        this[kHTTP2Session] = null;
8556        this[kHTTP2SessionState] = !allowH2 ? null : {
8557          // streams: null, // Fixed queue of streams - For future support of `push`
8558          openStreams: 0,
8559          // Keep track of them to decide wether or not unref the session
8560          maxConcurrentStreams: maxConcurrentStreams != null ? maxConcurrentStreams : 100
8561          // Max peerConcurrentStreams for a Node h2 server
8562        };
8563        this[kHost] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}`;
8564        this[kQueue] = [];
8565        this[kRunningIdx] = 0;
8566        this[kPendingIdx] = 0;
8567      }
8568      get pipelining() {
8569        return this[kPipelining];
8570      }
8571      set pipelining(value) {
8572        this[kPipelining] = value;
8573        resume(this, true);
8574      }
8575      get [kPending]() {
8576        return this[kQueue].length - this[kPendingIdx];
8577      }
8578      get [kRunning]() {
8579        return this[kPendingIdx] - this[kRunningIdx];
8580      }
8581      get [kSize]() {
8582        return this[kQueue].length - this[kRunningIdx];
8583      }
8584      get [kConnected]() {
8585        return !!this[kSocket] && !this[kConnecting] && !this[kSocket].destroyed;
8586      }
8587      get [kBusy]() {
8588        const socket = this[kSocket];
8589        return socket && (socket[kReset] || socket[kWriting] || socket[kBlocking]) || this[kSize] >= (this[kPipelining] || 1) || this[kPending] > 0;
8590      }
8591      /* istanbul ignore: only used for test */
8592      [kConnect](cb) {
8593        connect(this);
8594        this.once("connect", cb);
8595      }
8596      [kDispatch](opts, handler) {
8597        const origin = opts.origin || this[kUrl].origin;
8598        const request = this[kHTTPConnVersion] === "h2" ? Request[kHTTP2BuildRequest](origin, opts, handler) : Request[kHTTP1BuildRequest](origin, opts, handler);
8599        this[kQueue].push(request);
8600        if (this[kResuming]) {
8601        } else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) {
8602          this[kResuming] = 1;
8603          process.nextTick(resume, this);
8604        } else {
8605          resume(this, true);
8606        }
8607        if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) {
8608          this[kNeedDrain] = 2;
8609        }
8610        return this[kNeedDrain] < 2;
8611      }
8612      async [kClose]() {
8613        return new Promise((resolve) => {
8614          if (!this[kSize]) {
8615            resolve(null);
8616          } else {
8617            this[kClosedResolve] = resolve;
8618          }
8619        });
8620      }
8621      async [kDestroy](err) {
8622        return new Promise((resolve) => {
8623          const requests = this[kQueue].splice(this[kPendingIdx]);
8624          for (let i = 0; i < requests.length; i++) {
8625            const request = requests[i];
8626            errorRequest(this, request, err);
8627          }
8628          const callback = /* @__PURE__ */ __name(() => {
8629            if (this[kClosedResolve]) {
8630              this[kClosedResolve]();
8631              this[kClosedResolve] = null;
8632            }
8633            resolve();
8634          }, "callback");
8635          if (this[kHTTP2Session] != null) {
8636            util.destroy(this[kHTTP2Session], err);
8637            this[kHTTP2Session] = null;
8638            this[kHTTP2SessionState] = null;
8639          }
8640          if (!this[kSocket]) {
8641            queueMicrotask(callback);
8642          } else {
8643            util.destroy(this[kSocket].on("close", callback), err);
8644          }
8645          resume(this);
8646        });
8647      }
8648    };
8649    function onHttp2SessionError(err) {
8650      assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
8651      this[kSocket][kError] = err;
8652      onError(this[kClient], err);
8653    }
8654    __name(onHttp2SessionError, "onHttp2SessionError");
8655    function onHttp2FrameError(type, code, id) {
8656      const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
8657      if (id === 0) {
8658        this[kSocket][kError] = err;
8659        onError(this[kClient], err);
8660      }
8661    }
8662    __name(onHttp2FrameError, "onHttp2FrameError");
8663    function onHttp2SessionEnd() {
8664      util.destroy(this, new SocketError("other side closed"));
8665      util.destroy(this[kSocket], new SocketError("other side closed"));
8666    }
8667    __name(onHttp2SessionEnd, "onHttp2SessionEnd");
8668    function onHTTP2GoAway(code) {
8669      const client = this[kClient];
8670      const err = new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${code}`);
8671      client[kSocket] = null;
8672      client[kHTTP2Session] = null;
8673      if (client.destroyed) {
8674        assert(this[kPending] === 0);
8675        const requests = client[kQueue].splice(client[kRunningIdx]);
8676        for (let i = 0; i < requests.length; i++) {
8677          const request = requests[i];
8678          errorRequest(this, request, err);
8679        }
8680      } else if (client[kRunning] > 0) {
8681        const request = client[kQueue][client[kRunningIdx]];
8682        client[kQueue][client[kRunningIdx]++] = null;
8683        errorRequest(client, request, err);
8684      }
8685      client[kPendingIdx] = client[kRunningIdx];
8686      assert(client[kRunning] === 0);
8687      client.emit(
8688        "disconnect",
8689        client[kUrl],
8690        [client],
8691        err
8692      );
8693      resume(client);
8694    }
8695    __name(onHTTP2GoAway, "onHTTP2GoAway");
8696    var constants = require_constants3();
8697    var createRedirectInterceptor = require_redirectInterceptor();
8698    var EMPTY_BUF = Buffer.alloc(0);
8699    async function lazyllhttp() {
8700      const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0;
8701      let mod;
8702      try {
8703        mod = await WebAssembly.compile(Buffer.from(require_llhttp_simd_wasm(), "base64"));
8704      } catch (e) {
8705        mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || require_llhttp_wasm(), "base64"));
8706      }
8707      return await WebAssembly.instantiate(mod, {
8708        env: {
8709          /* eslint-disable camelcase */
8710          wasm_on_url: (p, at, len) => {
8711            return 0;
8712          },
8713          wasm_on_status: (p, at, len) => {
8714            assert.strictEqual(currentParser.ptr, p);
8715            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
8716            return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
8717          },
8718          wasm_on_message_begin: (p) => {
8719            assert.strictEqual(currentParser.ptr, p);
8720            return currentParser.onMessageBegin() || 0;
8721          },
8722          wasm_on_header_field: (p, at, len) => {
8723            assert.strictEqual(currentParser.ptr, p);
8724            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
8725            return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
8726          },
8727          wasm_on_header_value: (p, at, len) => {
8728            assert.strictEqual(currentParser.ptr, p);
8729            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
8730            return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
8731          },
8732          wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
8733            assert.strictEqual(currentParser.ptr, p);
8734            return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0;
8735          },
8736          wasm_on_body: (p, at, len) => {
8737            assert.strictEqual(currentParser.ptr, p);
8738            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
8739            return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
8740          },
8741          wasm_on_message_complete: (p) => {
8742            assert.strictEqual(currentParser.ptr, p);
8743            return currentParser.onMessageComplete() || 0;
8744          }
8745          /* eslint-enable camelcase */
8746        }
8747      });
8748    }
8749    __name(lazyllhttp, "lazyllhttp");
8750    var llhttpInstance = null;
8751    var llhttpPromise = lazyllhttp();
8752    llhttpPromise.catch();
8753    var currentParser = null;
8754    var currentBufferRef = null;
8755    var currentBufferSize = 0;
8756    var currentBufferPtr = null;
8757    var TIMEOUT_HEADERS = 1;
8758    var TIMEOUT_BODY = 2;
8759    var TIMEOUT_IDLE = 3;
8760    var Parser = class {
8761      static {
8762        __name(this, "Parser");
8763      }
8764      constructor(client, socket, { exports: exports3 }) {
8765        assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0);
8766        this.llhttp = exports3;
8767        this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE);
8768        this.client = client;
8769        this.socket = socket;
8770        this.timeout = null;
8771        this.timeoutValue = null;
8772        this.timeoutType = null;
8773        this.statusCode = null;
8774        this.statusText = "";
8775        this.upgrade = false;
8776        this.headers = [];
8777        this.headersSize = 0;
8778        this.headersMaxSize = client[kMaxHeadersSize];
8779        this.shouldKeepAlive = false;
8780        this.paused = false;
8781        this.resume = this.resume.bind(this);
8782        this.bytesRead = 0;
8783        this.keepAlive = "";
8784        this.contentLength = "";
8785        this.connection = "";
8786        this.maxResponseSize = client[kMaxResponseSize];
8787      }
8788      setTimeout(value, type) {
8789        this.timeoutType = type;
8790        if (value !== this.timeoutValue) {
8791          timers.clearTimeout(this.timeout);
8792          if (value) {
8793            this.timeout = timers.setTimeout(onParserTimeout, value, this);
8794            if (this.timeout.unref) {
8795              this.timeout.unref();
8796            }
8797          } else {
8798            this.timeout = null;
8799          }
8800          this.timeoutValue = value;
8801        } else if (this.timeout) {
8802          if (this.timeout.refresh) {
8803            this.timeout.refresh();
8804          }
8805        }
8806      }
8807      resume() {
8808        if (this.socket.destroyed || !this.paused) {
8809          return;
8810        }
8811        assert(this.ptr != null);
8812        assert(currentParser == null);
8813        this.llhttp.llhttp_resume(this.ptr);
8814        assert(this.timeoutType === TIMEOUT_BODY);
8815        if (this.timeout) {
8816          if (this.timeout.refresh) {
8817            this.timeout.refresh();
8818          }
8819        }
8820        this.paused = false;
8821        this.execute(this.socket.read() || EMPTY_BUF);
8822        this.readMore();
8823      }
8824      readMore() {
8825        while (!this.paused && this.ptr) {
8826          const chunk = this.socket.read();
8827          if (chunk === null) {
8828            break;
8829          }
8830          this.execute(chunk);
8831        }
8832      }
8833      execute(data) {
8834        assert(this.ptr != null);
8835        assert(currentParser == null);
8836        assert(!this.paused);
8837        const { socket, llhttp } = this;
8838        if (data.length > currentBufferSize) {
8839          if (currentBufferPtr) {
8840            llhttp.free(currentBufferPtr);
8841          }
8842          currentBufferSize = Math.ceil(data.length / 4096) * 4096;
8843          currentBufferPtr = llhttp.malloc(currentBufferSize);
8844        }
8845        new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data);
8846        try {
8847          let ret;
8848          try {
8849            currentBufferRef = data;
8850            currentParser = this;
8851            ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length);
8852          } catch (err) {
8853            throw err;
8854          } finally {
8855            currentParser = null;
8856            currentBufferRef = null;
8857          }
8858          const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr;
8859          if (ret === constants.ERROR.PAUSED_UPGRADE) {
8860            this.onUpgrade(data.slice(offset));
8861          } else if (ret === constants.ERROR.PAUSED) {
8862            this.paused = true;
8863            socket.unshift(data.slice(offset));
8864          } else if (ret !== constants.ERROR.OK) {
8865            const ptr = llhttp.llhttp_get_error_reason(this.ptr);
8866            let message = "";
8867            if (ptr) {
8868              const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0);
8869              message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")";
8870            }
8871            throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset));
8872          }
8873        } catch (err) {
8874          util.destroy(socket, err);
8875        }
8876      }
8877      destroy() {
8878        assert(this.ptr != null);
8879        assert(currentParser == null);
8880        this.llhttp.llhttp_free(this.ptr);
8881        this.ptr = null;
8882        timers.clearTimeout(this.timeout);
8883        this.timeout = null;
8884        this.timeoutValue = null;
8885        this.timeoutType = null;
8886        this.paused = false;
8887      }
8888      onStatus(buf) {
8889        this.statusText = buf.toString();
8890      }
8891      onMessageBegin() {
8892        const { socket, client } = this;
8893        if (socket.destroyed) {
8894          return -1;
8895        }
8896        const request = client[kQueue][client[kRunningIdx]];
8897        if (!request) {
8898          return -1;
8899        }
8900      }
8901      onHeaderField(buf) {
8902        const len = this.headers.length;
8903        if ((len & 1) === 0) {
8904          this.headers.push(buf);
8905        } else {
8906          this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
8907        }
8908        this.trackHeader(buf.length);
8909      }
8910      onHeaderValue(buf) {
8911        let len = this.headers.length;
8912        if ((len & 1) === 1) {
8913          this.headers.push(buf);
8914          len += 1;
8915        } else {
8916          this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
8917        }
8918        const key = this.headers[len - 2];
8919        if (key.length === 10 && key.toString().toLowerCase() === "keep-alive") {
8920          this.keepAlive += buf.toString();
8921        } else if (key.length === 10 && key.toString().toLowerCase() === "connection") {
8922          this.connection += buf.toString();
8923        } else if (key.length === 14 && key.toString().toLowerCase() === "content-length") {
8924          this.contentLength += buf.toString();
8925        }
8926        this.trackHeader(buf.length);
8927      }
8928      trackHeader(len) {
8929        this.headersSize += len;
8930        if (this.headersSize >= this.headersMaxSize) {
8931          util.destroy(this.socket, new HeadersOverflowError());
8932        }
8933      }
8934      onUpgrade(head) {
8935        const { upgrade, client, socket, headers, statusCode } = this;
8936        assert(upgrade);
8937        const request = client[kQueue][client[kRunningIdx]];
8938        assert(request);
8939        assert(!socket.destroyed);
8940        assert(socket === client[kSocket]);
8941        assert(!this.paused);
8942        assert(request.upgrade || request.method === "CONNECT");
8943        this.statusCode = null;
8944        this.statusText = "";
8945        this.shouldKeepAlive = null;
8946        assert(this.headers.length % 2 === 0);
8947        this.headers = [];
8948        this.headersSize = 0;
8949        socket.unshift(head);
8950        socket[kParser].destroy();
8951        socket[kParser] = null;
8952        socket[kClient] = null;
8953        socket[kError] = null;
8954        socket.removeListener("error", onSocketError).removeListener("readable", onSocketReadable).removeListener("end", onSocketEnd).removeListener("close", onSocketClose);
8955        client[kSocket] = null;
8956        client[kQueue][client[kRunningIdx]++] = null;
8957        client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade"));
8958        try {
8959          request.onUpgrade(statusCode, headers, socket);
8960        } catch (err) {
8961          util.destroy(socket, err);
8962        }
8963        resume(client);
8964      }
8965      onHeadersComplete(statusCode, upgrade, shouldKeepAlive) {
8966        const { client, socket, headers, statusText } = this;
8967        if (socket.destroyed) {
8968          return -1;
8969        }
8970        const request = client[kQueue][client[kRunningIdx]];
8971        if (!request) {
8972          return -1;
8973        }
8974        assert(!this.upgrade);
8975        assert(this.statusCode < 200);
8976        if (statusCode === 100) {
8977          util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
8978          return -1;
8979        }
8980        if (upgrade && !request.upgrade) {
8981          util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket)));
8982          return -1;
8983        }
8984        assert.strictEqual(this.timeoutType, TIMEOUT_HEADERS);
8985        this.statusCode = statusCode;
8986        this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD.
8987        request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive";
8988        if (this.statusCode >= 200) {
8989          const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout];
8990          this.setTimeout(bodyTimeout, TIMEOUT_BODY);
8991        } else if (this.timeout) {
8992          if (this.timeout.refresh) {
8993            this.timeout.refresh();
8994          }
8995        }
8996        if (request.method === "CONNECT") {
8997          assert(client[kRunning] === 1);
8998          this.upgrade = true;
8999          return 2;
9000        }
9001        if (upgrade) {
9002          assert(client[kRunning] === 1);
9003          this.upgrade = true;
9004          return 2;
9005        }
9006        assert(this.headers.length % 2 === 0);
9007        this.headers = [];
9008        this.headersSize = 0;
9009        if (this.shouldKeepAlive && client[kPipelining]) {
9010          const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null;
9011          if (keepAliveTimeout != null) {
9012            const timeout = Math.min(
9013              keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
9014              client[kKeepAliveMaxTimeout]
9015            );
9016            if (timeout <= 0) {
9017              socket[kReset] = true;
9018            } else {
9019              client[kKeepAliveTimeoutValue] = timeout;
9020            }
9021          } else {
9022            client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout];
9023          }
9024        } else {
9025          socket[kReset] = true;
9026        }
9027        const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false;
9028        if (request.aborted) {
9029          return -1;
9030        }
9031        if (request.method === "HEAD") {
9032          return 1;
9033        }
9034        if (statusCode < 200) {
9035          return 1;
9036        }
9037        if (socket[kBlocking]) {
9038          socket[kBlocking] = false;
9039          resume(client);
9040        }
9041        return pause ? constants.ERROR.PAUSED : 0;
9042      }
9043      onBody(buf) {
9044        const { client, socket, statusCode, maxResponseSize } = this;
9045        if (socket.destroyed) {
9046          return -1;
9047        }
9048        const request = client[kQueue][client[kRunningIdx]];
9049        assert(request);
9050        assert.strictEqual(this.timeoutType, TIMEOUT_BODY);
9051        if (this.timeout) {
9052          if (this.timeout.refresh) {
9053            this.timeout.refresh();
9054          }
9055        }
9056        assert(statusCode >= 200);
9057        if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
9058          util.destroy(socket, new ResponseExceededMaxSizeError());
9059          return -1;
9060        }
9061        this.bytesRead += buf.length;
9062        if (request.onData(buf) === false) {
9063          return constants.ERROR.PAUSED;
9064        }
9065      }
9066      onMessageComplete() {
9067        const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this;
9068        if (socket.destroyed && (!statusCode || shouldKeepAlive)) {
9069          return -1;
9070        }
9071        if (upgrade) {
9072          return;
9073        }
9074        const request = client[kQueue][client[kRunningIdx]];
9075        assert(request);
9076        assert(statusCode >= 100);
9077        this.statusCode = null;
9078        this.statusText = "";
9079        this.bytesRead = 0;
9080        this.contentLength = "";
9081        this.keepAlive = "";
9082        this.connection = "";
9083        assert(this.headers.length % 2 === 0);
9084        this.headers = [];
9085        this.headersSize = 0;
9086        if (statusCode < 200) {
9087          return;
9088        }
9089        if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
9090          util.destroy(socket, new ResponseContentLengthMismatchError());
9091          return -1;
9092        }
9093        request.onComplete(headers);
9094        client[kQueue][client[kRunningIdx]++] = null;
9095        if (socket[kWriting]) {
9096          assert.strictEqual(client[kRunning], 0);
9097          util.destroy(socket, new InformationalError("reset"));
9098          return constants.ERROR.PAUSED;
9099        } else if (!shouldKeepAlive) {
9100          util.destroy(socket, new InformationalError("reset"));
9101          return constants.ERROR.PAUSED;
9102        } else if (socket[kReset] && client[kRunning] === 0) {
9103          util.destroy(socket, new InformationalError("reset"));
9104          return constants.ERROR.PAUSED;
9105        } else if (client[kPipelining] === 1) {
9106          setImmediate(resume, client);
9107        } else {
9108          resume(client);
9109        }
9110      }
9111    };
9112    function onParserTimeout(parser) {
9113      const { socket, timeoutType, client } = parser;
9114      if (timeoutType === TIMEOUT_HEADERS) {
9115        if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
9116          assert(!parser.paused, "cannot be paused while waiting for headers");
9117          util.destroy(socket, new HeadersTimeoutError());
9118        }
9119      } else if (timeoutType === TIMEOUT_BODY) {
9120        if (!parser.paused) {
9121          util.destroy(socket, new BodyTimeoutError());
9122        }
9123      } else if (timeoutType === TIMEOUT_IDLE) {
9124        assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]);
9125        util.destroy(socket, new InformationalError("socket idle timeout"));
9126      }
9127    }
9128    __name(onParserTimeout, "onParserTimeout");
9129    function onSocketReadable() {
9130      const { [kParser]: parser } = this;
9131      if (parser) {
9132        parser.readMore();
9133      }
9134    }
9135    __name(onSocketReadable, "onSocketReadable");
9136    function onSocketError(err) {
9137      const { [kClient]: client, [kParser]: parser } = this;
9138      assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
9139      if (client[kHTTPConnVersion] !== "h2") {
9140        if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) {
9141          parser.onMessageComplete();
9142          return;
9143        }
9144      }
9145      this[kError] = err;
9146      onError(this[kClient], err);
9147    }
9148    __name(onSocketError, "onSocketError");
9149    function onError(client, err) {
9150      if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") {
9151        assert(client[kPendingIdx] === client[kRunningIdx]);
9152        const requests = client[kQueue].splice(client[kRunningIdx]);
9153        for (let i = 0; i < requests.length; i++) {
9154          const request = requests[i];
9155          errorRequest(client, request, err);
9156        }
9157        assert(client[kSize] === 0);
9158      }
9159    }
9160    __name(onError, "onError");
9161    function onSocketEnd() {
9162      const { [kParser]: parser, [kClient]: client } = this;
9163      if (client[kHTTPConnVersion] !== "h2") {
9164        if (parser.statusCode && !parser.shouldKeepAlive) {
9165          parser.onMessageComplete();
9166          return;
9167        }
9168      }
9169      util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
9170    }
9171    __name(onSocketEnd, "onSocketEnd");
9172    function onSocketClose() {
9173      const { [kClient]: client, [kParser]: parser } = this;
9174      if (client[kHTTPConnVersion] === "h1" && parser) {
9175        if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
9176          parser.onMessageComplete();
9177        }
9178        this[kParser].destroy();
9179        this[kParser] = null;
9180      }
9181      const err = this[kError] || new SocketError("closed", util.getSocketInfo(this));
9182      client[kSocket] = null;
9183      if (client.destroyed) {
9184        assert(client[kPending] === 0);
9185        const requests = client[kQueue].splice(client[kRunningIdx]);
9186        for (let i = 0; i < requests.length; i++) {
9187          const request = requests[i];
9188          errorRequest(client, request, err);
9189        }
9190      } else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") {
9191        const request = client[kQueue][client[kRunningIdx]];
9192        client[kQueue][client[kRunningIdx]++] = null;
9193        errorRequest(client, request, err);
9194      }
9195      client[kPendingIdx] = client[kRunningIdx];
9196      assert(client[kRunning] === 0);
9197      client.emit("disconnect", client[kUrl], [client], err);
9198      resume(client);
9199    }
9200    __name(onSocketClose, "onSocketClose");
9201    async function connect(client) {
9202      assert(!client[kConnecting]);
9203      assert(!client[kSocket]);
9204      let { host, hostname, protocol, port } = client[kUrl];
9205      if (hostname[0] === "[") {
9206        const idx = hostname.indexOf("]");
9207        assert(idx !== -1);
9208        const ip = hostname.substring(1, idx);
9209        assert(net.isIP(ip));
9210        hostname = ip;
9211      }
9212      client[kConnecting] = true;
9213      if (channels.beforeConnect.hasSubscribers) {
9214        channels.beforeConnect.publish({
9215          connectParams: {
9216            host,
9217            hostname,
9218            protocol,
9219            port,
9220            servername: client[kServerName],
9221            localAddress: client[kLocalAddress]
9222          },
9223          connector: client[kConnector]
9224        });
9225      }
9226      try {
9227        const socket = await new Promise((resolve, reject) => {
9228          client[kConnector]({
9229            host,
9230            hostname,
9231            protocol,
9232            port,
9233            servername: client[kServerName],
9234            localAddress: client[kLocalAddress]
9235          }, (err, socket2) => {
9236            if (err) {
9237              reject(err);
9238            } else {
9239              resolve(socket2);
9240            }
9241          });
9242        });
9243        if (client.destroyed) {
9244          util.destroy(socket.on("error", () => {
9245          }), new ClientDestroyedError());
9246          return;
9247        }
9248        client[kConnecting] = false;
9249        assert(socket);
9250        const isH2 = socket.alpnProtocol === "h2";
9251        if (isH2) {
9252          if (!h2ExperimentalWarned) {
9253            h2ExperimentalWarned = true;
9254            process.emitWarning("H2 support is experimental, expect them to change at any time.", {
9255              code: "UNDICI-H2"
9256            });
9257          }
9258          const session = http2.connect(client[kUrl], {
9259            createConnection: () => socket,
9260            peerMaxConcurrentStreams: client[kHTTP2SessionState].maxConcurrentStreams
9261          });
9262          client[kHTTPConnVersion] = "h2";
9263          session[kClient] = client;
9264          session[kSocket] = socket;
9265          session.on("error", onHttp2SessionError);
9266          session.on("frameError", onHttp2FrameError);
9267          session.on("end", onHttp2SessionEnd);
9268          session.on("goaway", onHTTP2GoAway);
9269          session.on("close", onSocketClose);
9270          session.unref();
9271          client[kHTTP2Session] = session;
9272          socket[kHTTP2Session] = session;
9273        } else {
9274          if (!llhttpInstance) {
9275            llhttpInstance = await llhttpPromise;
9276            llhttpPromise = null;
9277          }
9278          socket[kNoRef] = false;
9279          socket[kWriting] = false;
9280          socket[kReset] = false;
9281          socket[kBlocking] = false;
9282          socket[kParser] = new Parser(client, socket, llhttpInstance);
9283        }
9284        socket[kCounter] = 0;
9285        socket[kMaxRequests] = client[kMaxRequests];
9286        socket[kClient] = client;
9287        socket[kError] = null;
9288        socket.on("error", onSocketError).on("readable", onSocketReadable).on("end", onSocketEnd).on("close", onSocketClose);
9289        client[kSocket] = socket;
9290        if (channels.connected.hasSubscribers) {
9291          channels.connected.publish({
9292            connectParams: {
9293              host,
9294              hostname,
9295              protocol,
9296              port,
9297              servername: client[kServerName],
9298              localAddress: client[kLocalAddress]
9299            },
9300            connector: client[kConnector],
9301            socket
9302          });
9303        }
9304        client.emit("connect", client[kUrl], [client]);
9305      } catch (err) {
9306        if (client.destroyed) {
9307          return;
9308        }
9309        client[kConnecting] = false;
9310        if (channels.connectError.hasSubscribers) {
9311          channels.connectError.publish({
9312            connectParams: {
9313              host,
9314              hostname,
9315              protocol,
9316              port,
9317              servername: client[kServerName],
9318              localAddress: client[kLocalAddress]
9319            },
9320            connector: client[kConnector],
9321            error: err
9322          });
9323        }
9324        if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
9325          assert(client[kRunning] === 0);
9326          while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
9327            const request = client[kQueue][client[kPendingIdx]++];
9328            errorRequest(client, request, err);
9329          }
9330        } else {
9331          onError(client, err);
9332        }
9333        client.emit("connectionError", client[kUrl], [client], err);
9334      }
9335      resume(client);
9336    }
9337    __name(connect, "connect");
9338    function emitDrain(client) {
9339      client[kNeedDrain] = 0;
9340      client.emit("drain", client[kUrl], [client]);
9341    }
9342    __name(emitDrain, "emitDrain");
9343    function resume(client, sync) {
9344      if (client[kResuming] === 2) {
9345        return;
9346      }
9347      client[kResuming] = 2;
9348      _resume(client, sync);
9349      client[kResuming] = 0;
9350      if (client[kRunningIdx] > 256) {
9351        client[kQueue].splice(0, client[kRunningIdx]);
9352        client[kPendingIdx] -= client[kRunningIdx];
9353        client[kRunningIdx] = 0;
9354      }
9355    }
9356    __name(resume, "resume");
9357    function _resume(client, sync) {
9358      while (true) {
9359        if (client.destroyed) {
9360          assert(client[kPending] === 0);
9361          return;
9362        }
9363        if (client[kClosedResolve] && !client[kSize]) {
9364          client[kClosedResolve]();
9365          client[kClosedResolve] = null;
9366          return;
9367        }
9368        const socket = client[kSocket];
9369        if (socket && !socket.destroyed && socket.alpnProtocol !== "h2") {
9370          if (client[kSize] === 0) {
9371            if (!socket[kNoRef] && socket.unref) {
9372              socket.unref();
9373              socket[kNoRef] = true;
9374            }
9375          } else if (socket[kNoRef] && socket.ref) {
9376            socket.ref();
9377            socket[kNoRef] = false;
9378          }
9379          if (client[kSize] === 0) {
9380            if (socket[kParser].timeoutType !== TIMEOUT_IDLE) {
9381              socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE);
9382            }
9383          } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
9384            if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
9385              const request2 = client[kQueue][client[kRunningIdx]];
9386              const headersTimeout = request2.headersTimeout != null ? request2.headersTimeout : client[kHeadersTimeout];
9387              socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS);
9388            }
9389          }
9390        }
9391        if (client[kBusy]) {
9392          client[kNeedDrain] = 2;
9393        } else if (client[kNeedDrain] === 2) {
9394          if (sync) {
9395            client[kNeedDrain] = 1;
9396            process.nextTick(emitDrain, client);
9397          } else {
9398            emitDrain(client);
9399          }
9400          continue;
9401        }
9402        if (client[kPending] === 0) {
9403          return;
9404        }
9405        if (client[kRunning] >= (client[kPipelining] || 1)) {
9406          return;
9407        }
9408        const request = client[kQueue][client[kPendingIdx]];
9409        if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) {
9410          if (client[kRunning] > 0) {
9411            return;
9412          }
9413          client[kServerName] = request.servername;
9414          if (socket && socket.servername !== request.servername) {
9415            util.destroy(socket, new InformationalError("servername changed"));
9416            return;
9417          }
9418        }
9419        if (client[kConnecting]) {
9420          return;
9421        }
9422        if (!socket && !client[kHTTP2Session]) {
9423          connect(client);
9424          return;
9425        }
9426        if (socket.destroyed || socket[kWriting] || socket[kReset] || socket[kBlocking]) {
9427          return;
9428        }
9429        if (client[kRunning] > 0 && !request.idempotent) {
9430          return;
9431        }
9432        if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT")) {
9433          return;
9434        }
9435        if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 && (util.isStream(request.body) || util.isAsyncIterable(request.body))) {
9436          return;
9437        }
9438        if (!request.aborted && write(client, request)) {
9439          client[kPendingIdx]++;
9440        } else {
9441          client[kQueue].splice(client[kPendingIdx], 1);
9442        }
9443      }
9444    }
9445    __name(_resume, "_resume");
9446    function shouldSendContentLength(method) {
9447      return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
9448    }
9449    __name(shouldSendContentLength, "shouldSendContentLength");
9450    function write(client, request) {
9451      if (client[kHTTPConnVersion] === "h2") {
9452        writeH2(client, client[kHTTP2Session], request);
9453        return;
9454      }
9455      const { body, method, path, host, upgrade, headers, blocking, reset } = request;
9456      const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
9457      if (body && typeof body.read === "function") {
9458        body.read(0);
9459      }
9460      const bodyLength = util.bodyLength(body);
9461      let contentLength = bodyLength;
9462      if (contentLength === null) {
9463        contentLength = request.contentLength;
9464      }
9465      if (contentLength === 0 && !expectsPayload) {
9466        contentLength = null;
9467      }
9468      if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) {
9469        if (client[kStrictContentLength]) {
9470          errorRequest(client, request, new RequestContentLengthMismatchError());
9471          return false;
9472        }
9473        process.emitWarning(new RequestContentLengthMismatchError());
9474      }
9475      const socket = client[kSocket];
9476      try {
9477        request.onConnect((err) => {
9478          if (request.aborted || request.completed) {
9479            return;
9480          }
9481          errorRequest(client, request, err || new RequestAbortedError());
9482          util.destroy(socket, new InformationalError("aborted"));
9483        });
9484      } catch (err) {
9485        errorRequest(client, request, err);
9486      }
9487      if (request.aborted) {
9488        return false;
9489      }
9490      if (method === "HEAD") {
9491        socket[kReset] = true;
9492      }
9493      if (upgrade || method === "CONNECT") {
9494        socket[kReset] = true;
9495      }
9496      if (reset != null) {
9497        socket[kReset] = reset;
9498      }
9499      if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) {
9500        socket[kReset] = true;
9501      }
9502      if (blocking) {
9503        socket[kBlocking] = true;
9504      }
9505      let header = `${method} ${path} HTTP/1.1\r
9506`;
9507      if (typeof host === "string") {
9508        header += `host: ${host}\r
9509`;
9510      } else {
9511        header += client[kHostHeader];
9512      }
9513      if (upgrade) {
9514        header += `connection: upgrade\r
9515upgrade: ${upgrade}\r
9516`;
9517      } else if (client[kPipelining] && !socket[kReset]) {
9518        header += "connection: keep-alive\r\n";
9519      } else {
9520        header += "connection: close\r\n";
9521      }
9522      if (headers) {
9523        header += headers;
9524      }
9525      if (channels.sendHeaders.hasSubscribers) {
9526        channels.sendHeaders.publish({ request, headers: header, socket });
9527      }
9528      if (!body || bodyLength === 0) {
9529        if (contentLength === 0) {
9530          socket.write(`${header}content-length: 0\r
9531\r
9532`, "latin1");
9533        } else {
9534          assert(contentLength === null, "no body must not have content length");
9535          socket.write(`${header}\r
9536`, "latin1");
9537        }
9538        request.onRequestSent();
9539      } else if (util.isBuffer(body)) {
9540        assert(contentLength === body.byteLength, "buffer body must have content length");
9541        socket.cork();
9542        socket.write(`${header}content-length: ${contentLength}\r
9543\r
9544`, "latin1");
9545        socket.write(body);
9546        socket.uncork();
9547        request.onBodySent(body);
9548        request.onRequestSent();
9549        if (!expectsPayload) {
9550          socket[kReset] = true;
9551        }
9552      } else if (util.isBlobLike(body)) {
9553        if (typeof body.stream === "function") {
9554          writeIterable({ body: body.stream(), client, request, socket, contentLength, header, expectsPayload });
9555        } else {
9556          writeBlob({ body, client, request, socket, contentLength, header, expectsPayload });
9557        }
9558      } else if (util.isStream(body)) {
9559        writeStream({ body, client, request, socket, contentLength, header, expectsPayload });
9560      } else if (util.isIterable(body)) {
9561        writeIterable({ body, client, request, socket, contentLength, header, expectsPayload });
9562      } else {
9563        assert(false);
9564      }
9565      return true;
9566    }
9567    __name(write, "write");
9568    function writeH2(client, session, request) {
9569      const { body, method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
9570      let headers;
9571      if (typeof reqHeaders === "string")
9572        headers = Request[kHTTP2CopyHeaders](reqHeaders.trim());
9573      else
9574        headers = reqHeaders;
9575      if (upgrade) {
9576        errorRequest(client, request, new Error("Upgrade not supported for H2"));
9577        return false;
9578      }
9579      try {
9580        request.onConnect((err) => {
9581          if (request.aborted || request.completed) {
9582            return;
9583          }
9584          errorRequest(client, request, err || new RequestAbortedError());
9585        });
9586      } catch (err) {
9587        errorRequest(client, request, err);
9588      }
9589      if (request.aborted) {
9590        return false;
9591      }
9592      let stream;
9593      const h2State = client[kHTTP2SessionState];
9594      headers[HTTP2_HEADER_AUTHORITY] = host || client[kHost];
9595      headers[HTTP2_HEADER_METHOD] = method;
9596      if (method === "CONNECT") {
9597        session.ref();
9598        stream = session.request(headers, { endStream: false, signal });
9599        if (stream.id && !stream.pending) {
9600          request.onUpgrade(null, null, stream);
9601          ++h2State.openStreams;
9602        } else {
9603          stream.once("ready", () => {
9604            request.onUpgrade(null, null, stream);
9605            ++h2State.openStreams;
9606          });
9607        }
9608        stream.once("close", () => {
9609          h2State.openStreams -= 1;
9610          if (h2State.openStreams === 0)
9611            session.unref();
9612        });
9613        return true;
9614      }
9615      headers[HTTP2_HEADER_PATH] = path;
9616      headers[HTTP2_HEADER_SCHEME] = "https";
9617      const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
9618      if (body && typeof body.read === "function") {
9619        body.read(0);
9620      }
9621      let contentLength = util.bodyLength(body);
9622      if (contentLength == null) {
9623        contentLength = request.contentLength;
9624      }
9625      if (contentLength === 0 || !expectsPayload) {
9626        contentLength = null;
9627      }
9628      if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) {
9629        if (client[kStrictContentLength]) {
9630          errorRequest(client, request, new RequestContentLengthMismatchError());
9631          return false;
9632        }
9633        process.emitWarning(new RequestContentLengthMismatchError());
9634      }
9635      if (contentLength != null) {
9636        assert(body, "no body must not have content length");
9637        headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`;
9638      }
9639      session.ref();
9640      const shouldEndStream = method === "GET" || method === "HEAD";
9641      if (expectContinue) {
9642        headers[HTTP2_HEADER_EXPECT] = "100-continue";
9643        stream = session.request(headers, { endStream: shouldEndStream, signal });
9644        stream.once("continue", writeBodyH2);
9645      } else {
9646        stream = session.request(headers, {
9647          endStream: shouldEndStream,
9648          signal
9649        });
9650        writeBodyH2();
9651      }
9652      ++h2State.openStreams;
9653      stream.once("response", (headers2) => {
9654        const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
9655        if (request.onHeaders(Number(statusCode), realHeaders, stream.resume.bind(stream), "") === false) {
9656          stream.pause();
9657        }
9658      });
9659      stream.once("end", () => {
9660        request.onComplete([]);
9661      });
9662      stream.on("data", (chunk) => {
9663        if (request.onData(chunk) === false) {
9664          stream.pause();
9665        }
9666      });
9667      stream.once("close", () => {
9668        h2State.openStreams -= 1;
9669        if (h2State.openStreams === 0) {
9670          session.unref();
9671        }
9672      });
9673      stream.once("error", function(err) {
9674        if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
9675          h2State.streams -= 1;
9676          util.destroy(stream, err);
9677        }
9678      });
9679      stream.once("frameError", (type, code) => {
9680        const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
9681        errorRequest(client, request, err);
9682        if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
9683          h2State.streams -= 1;
9684          util.destroy(stream, err);
9685        }
9686      });
9687      return true;
9688      function writeBodyH2() {
9689        if (!body) {
9690          request.onRequestSent();
9691        } else if (util.isBuffer(body)) {
9692          assert(contentLength === body.byteLength, "buffer body must have content length");
9693          stream.cork();
9694          stream.write(body);
9695          stream.uncork();
9696          stream.end();
9697          request.onBodySent(body);
9698          request.onRequestSent();
9699        } else if (util.isBlobLike(body)) {
9700          if (typeof body.stream === "function") {
9701            writeIterable({
9702              client,
9703              request,
9704              contentLength,
9705              h2stream: stream,
9706              expectsPayload,
9707              body: body.stream(),
9708              socket: client[kSocket],
9709              header: ""
9710            });
9711          } else {
9712            writeBlob({
9713              body,
9714              client,
9715              request,
9716              contentLength,
9717              expectsPayload,
9718              h2stream: stream,
9719              header: "",
9720              socket: client[kSocket]
9721            });
9722          }
9723        } else if (util.isStream(body)) {
9724          writeStream({
9725            body,
9726            client,
9727            request,
9728            contentLength,
9729            expectsPayload,
9730            socket: client[kSocket],
9731            h2stream: stream,
9732            header: ""
9733          });
9734        } else if (util.isIterable(body)) {
9735          writeIterable({
9736            body,
9737            client,
9738            request,
9739            contentLength,
9740            expectsPayload,
9741            header: "",
9742            h2stream: stream,
9743            socket: client[kSocket]
9744          });
9745        } else {
9746          assert(false);
9747        }
9748      }
9749      __name(writeBodyH2, "writeBodyH2");
9750    }
9751    __name(writeH2, "writeH2");
9752    function writeStream({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
9753      assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
9754      if (client[kHTTPConnVersion] === "h2") {
9755        let onPipeData = function(chunk) {
9756          request.onBodySent(chunk);
9757        };
9758        __name(onPipeData, "onPipeData");
9759        const pipe = pipeline(
9760          body,
9761          h2stream,
9762          (err) => {
9763            if (err) {
9764              util.destroy(body, err);
9765              util.destroy(h2stream, err);
9766            } else {
9767              request.onRequestSent();
9768            }
9769          }
9770        );
9771        pipe.on("data", onPipeData);
9772        pipe.once("end", () => {
9773          pipe.removeListener("data", onPipeData);
9774          util.destroy(pipe);
9775        });
9776        return;
9777      }
9778      let finished = false;
9779      const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header });
9780      const onData = /* @__PURE__ */ __name(function(chunk) {
9781        if (finished) {
9782          return;
9783        }
9784        try {
9785          if (!writer.write(chunk) && this.pause) {
9786            this.pause();
9787          }
9788        } catch (err) {
9789          util.destroy(this, err);
9790        }
9791      }, "onData");
9792      const onDrain = /* @__PURE__ */ __name(function() {
9793        if (finished) {
9794          return;
9795        }
9796        if (body.resume) {
9797          body.resume();
9798        }
9799      }, "onDrain");
9800      const onAbort = /* @__PURE__ */ __name(function() {
9801        if (finished) {
9802          return;
9803        }
9804        const err = new RequestAbortedError();
9805        queueMicrotask(() => onFinished(err));
9806      }, "onAbort");
9807      const onFinished = /* @__PURE__ */ __name(function(err) {
9808        if (finished) {
9809          return;
9810        }
9811        finished = true;
9812        assert(socket.destroyed || socket[kWriting] && client[kRunning] <= 1);
9813        socket.off("drain", onDrain).off("error", onFinished);
9814        body.removeListener("data", onData).removeListener("end", onFinished).removeListener("error", onFinished).removeListener("close", onAbort);
9815        if (!err) {
9816          try {
9817            writer.end();
9818          } catch (er) {
9819            err = er;
9820          }
9821        }
9822        writer.destroy(err);
9823        if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) {
9824          util.destroy(body, err);
9825        } else {
9826          util.destroy(body);
9827        }
9828      }, "onFinished");
9829      body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onAbort);
9830      if (body.resume) {
9831        body.resume();
9832      }
9833      socket.on("drain", onDrain).on("error", onFinished);
9834    }
9835    __name(writeStream, "writeStream");
9836    async function writeBlob({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
9837      assert(contentLength === body.size, "blob body must have content length");
9838      const isH2 = client[kHTTPConnVersion] === "h2";
9839      try {
9840        if (contentLength != null && contentLength !== body.size) {
9841          throw new RequestContentLengthMismatchError();
9842        }
9843        const buffer = Buffer.from(await body.arrayBuffer());
9844        if (isH2) {
9845          h2stream.cork();
9846          h2stream.write(buffer);
9847          h2stream.uncork();
9848        } else {
9849          socket.cork();
9850          socket.write(`${header}content-length: ${contentLength}\r
9851\r
9852`, "latin1");
9853          socket.write(buffer);
9854          socket.uncork();
9855        }
9856        request.onBodySent(buffer);
9857        request.onRequestSent();
9858        if (!expectsPayload) {
9859          socket[kReset] = true;
9860        }
9861        resume(client);
9862      } catch (err) {
9863        util.destroy(isH2 ? h2stream : socket, err);
9864      }
9865    }
9866    __name(writeBlob, "writeBlob");
9867    async function writeIterable({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
9868      assert(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
9869      let callback = null;
9870      function onDrain() {
9871        if (callback) {
9872          const cb = callback;
9873          callback = null;
9874          cb();
9875        }
9876      }
9877      __name(onDrain, "onDrain");
9878      const waitForDrain = /* @__PURE__ */ __name(() => new Promise((resolve, reject) => {
9879        assert(callback === null);
9880        if (socket[kError]) {
9881          reject(socket[kError]);
9882        } else {
9883          callback = resolve;
9884        }
9885      }), "waitForDrain");
9886      if (client[kHTTPConnVersion] === "h2") {
9887        h2stream.on("close", onDrain).on("drain", onDrain);
9888        try {
9889          for await (const chunk of body) {
9890            if (socket[kError]) {
9891              throw socket[kError];
9892            }
9893            const res = h2stream.write(chunk);
9894            request.onBodySent(chunk);
9895            if (!res) {
9896              await waitForDrain();
9897            }
9898          }
9899        } catch (err) {
9900          h2stream.destroy(err);
9901        } finally {
9902          request.onRequestSent();
9903          h2stream.end();
9904          h2stream.off("close", onDrain).off("drain", onDrain);
9905        }
9906        return;
9907      }
9908      socket.on("close", onDrain).on("drain", onDrain);
9909      const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header });
9910      try {
9911        for await (const chunk of body) {
9912          if (socket[kError]) {
9913            throw socket[kError];
9914          }
9915          if (!writer.write(chunk)) {
9916            await waitForDrain();
9917          }
9918        }
9919        writer.end();
9920      } catch (err) {
9921        writer.destroy(err);
9922      } finally {
9923        socket.off("close", onDrain).off("drain", onDrain);
9924      }
9925    }
9926    __name(writeIterable, "writeIterable");
9927    var AsyncWriter = class {
9928      static {
9929        __name(this, "AsyncWriter");
9930      }
9931      constructor({ socket, request, contentLength, client, expectsPayload, header }) {
9932        this.socket = socket;
9933        this.request = request;
9934        this.contentLength = contentLength;
9935        this.client = client;
9936        this.bytesWritten = 0;
9937        this.expectsPayload = expectsPayload;
9938        this.header = header;
9939        socket[kWriting] = true;
9940      }
9941      write(chunk) {
9942        const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this;
9943        if (socket[kError]) {
9944          throw socket[kError];
9945        }
9946        if (socket.destroyed) {
9947          return false;
9948        }
9949        const len = Buffer.byteLength(chunk);
9950        if (!len) {
9951          return true;
9952        }
9953        if (contentLength !== null && bytesWritten + len > contentLength) {
9954          if (client[kStrictContentLength]) {
9955            throw new RequestContentLengthMismatchError();
9956          }
9957          process.emitWarning(new RequestContentLengthMismatchError());
9958        }
9959        socket.cork();
9960        if (bytesWritten === 0) {
9961          if (!expectsPayload) {
9962            socket[kReset] = true;
9963          }
9964          if (contentLength === null) {
9965            socket.write(`${header}transfer-encoding: chunked\r
9966`, "latin1");
9967          } else {
9968            socket.write(`${header}content-length: ${contentLength}\r
9969\r
9970`, "latin1");
9971          }
9972        }
9973        if (contentLength === null) {
9974          socket.write(`\r
9975${len.toString(16)}\r
9976`, "latin1");
9977        }
9978        this.bytesWritten += len;
9979        const ret = socket.write(chunk);
9980        socket.uncork();
9981        request.onBodySent(chunk);
9982        if (!ret) {
9983          if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
9984            if (socket[kParser].timeout.refresh) {
9985              socket[kParser].timeout.refresh();
9986            }
9987          }
9988        }
9989        return ret;
9990      }
9991      end() {
9992        const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this;
9993        request.onRequestSent();
9994        socket[kWriting] = false;
9995        if (socket[kError]) {
9996          throw socket[kError];
9997        }
9998        if (socket.destroyed) {
9999          return;
10000        }
10001        if (bytesWritten === 0) {
10002          if (expectsPayload) {
10003            socket.write(`${header}content-length: 0\r
10004\r
10005`, "latin1");
10006          } else {
10007            socket.write(`${header}\r
10008`, "latin1");
10009          }
10010        } else if (contentLength === null) {
10011          socket.write("\r\n0\r\n\r\n", "latin1");
10012        }
10013        if (contentLength !== null && bytesWritten !== contentLength) {
10014          if (client[kStrictContentLength]) {
10015            throw new RequestContentLengthMismatchError();
10016          } else {
10017            process.emitWarning(new RequestContentLengthMismatchError());
10018          }
10019        }
10020        if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
10021          if (socket[kParser].timeout.refresh) {
10022            socket[kParser].timeout.refresh();
10023          }
10024        }
10025        resume(client);
10026      }
10027      destroy(err) {
10028        const { socket, client } = this;
10029        socket[kWriting] = false;
10030        if (err) {
10031          assert(client[kRunning] <= 1, "pipeline should only contain this request");
10032          util.destroy(socket, err);
10033        }
10034      }
10035    };
10036    function errorRequest(client, request, err) {
10037      try {
10038        request.onError(err);
10039        assert(request.aborted);
10040      } catch (err2) {
10041        client.emit("error", err2);
10042      }
10043    }
10044    __name(errorRequest, "errorRequest");
10045    module2.exports = Client;
10046  }
10047});
10048
10049// lib/pool.js
10050var require_pool = __commonJS({
10051  "lib/pool.js"(exports2, module2) {
10052    "use strict";
10053    var {
10054      PoolBase,
10055      kClients,
10056      kNeedDrain,
10057      kAddClient,
10058      kGetDispatcher
10059    } = require_pool_base();
10060    var Client = require_client();
10061    var {
10062      InvalidArgumentError
10063    } = require_errors();
10064    var util = require_util();
10065    var { kUrl, kInterceptors } = require_symbols();
10066    var buildConnector = require_connect();
10067    var kOptions = Symbol("options");
10068    var kConnections = Symbol("connections");
10069    var kFactory = Symbol("factory");
10070    function defaultFactory(origin, opts) {
10071      return new Client(origin, opts);
10072    }
10073    __name(defaultFactory, "defaultFactory");
10074    var Pool = class extends PoolBase {
10075      static {
10076        __name(this, "Pool");
10077      }
10078      constructor(origin, {
10079        connections,
10080        factory = defaultFactory,
10081        connect,
10082        connectTimeout,
10083        tls,
10084        maxCachedSessions,
10085        socketPath,
10086        autoSelectFamily,
10087        autoSelectFamilyAttemptTimeout,
10088        allowH2,
10089        ...options
10090      } = {}) {
10091        super();
10092        if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
10093          throw new InvalidArgumentError("invalid connections");
10094        }
10095        if (typeof factory !== "function") {
10096          throw new InvalidArgumentError("factory must be a function.");
10097        }
10098        if (connect != null && typeof connect !== "function" && typeof connect !== "object") {
10099          throw new InvalidArgumentError("connect must be a function or an object");
10100        }
10101        if (typeof connect !== "function") {
10102          connect = buildConnector({
10103            ...tls,
10104            maxCachedSessions,
10105            allowH2,
10106            socketPath,
10107            timeout: connectTimeout,
10108            ...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
10109            ...connect
10110          });
10111        }
10112        this[kInterceptors] = options.interceptors && options.interceptors.Pool && Array.isArray(options.interceptors.Pool) ? options.interceptors.Pool : [];
10113        this[kConnections] = connections || null;
10114        this[kUrl] = util.parseOrigin(origin);
10115        this[kOptions] = { ...util.deepClone(options), connect, allowH2 };
10116        this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
10117        this[kFactory] = factory;
10118      }
10119      [kGetDispatcher]() {
10120        let dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain]);
10121        if (dispatcher) {
10122          return dispatcher;
10123        }
10124        if (!this[kConnections] || this[kClients].length < this[kConnections]) {
10125          dispatcher = this[kFactory](this[kUrl], this[kOptions]);
10126          this[kAddClient](dispatcher);
10127        }
10128        return dispatcher;
10129      }
10130    };
10131    module2.exports = Pool;
10132  }
10133});
10134
10135// lib/agent.js
10136var require_agent = __commonJS({
10137  "lib/agent.js"(exports2, module2) {
10138    "use strict";
10139    var { InvalidArgumentError } = require_errors();
10140    var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols();
10141    var DispatcherBase = require_dispatcher_base();
10142    var Pool = require_pool();
10143    var Client = require_client();
10144    var util = require_util();
10145    var createRedirectInterceptor = require_redirectInterceptor();
10146    var { WeakRef: WeakRef2, FinalizationRegistry } = require_dispatcher_weakref()();
10147    var kOnConnect = Symbol("onConnect");
10148    var kOnDisconnect = Symbol("onDisconnect");
10149    var kOnConnectionError = Symbol("onConnectionError");
10150    var kMaxRedirections = Symbol("maxRedirections");
10151    var kOnDrain = Symbol("onDrain");
10152    var kFactory = Symbol("factory");
10153    var kFinalizer = Symbol("finalizer");
10154    var kOptions = Symbol("options");
10155    function defaultFactory(origin, opts) {
10156      return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
10157    }
10158    __name(defaultFactory, "defaultFactory");
10159    var Agent = class extends DispatcherBase {
10160      static {
10161        __name(this, "Agent");
10162      }
10163      constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) {
10164        super();
10165        if (typeof factory !== "function") {
10166          throw new InvalidArgumentError("factory must be a function.");
10167        }
10168        if (connect != null && typeof connect !== "function" && typeof connect !== "object") {
10169          throw new InvalidArgumentError("connect must be a function or an object");
10170        }
10171        if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
10172          throw new InvalidArgumentError("maxRedirections must be a positive number");
10173        }
10174        if (connect && typeof connect !== "function") {
10175          connect = { ...connect };
10176        }
10177        this[kInterceptors] = options.interceptors && options.interceptors.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })];
10178        this[kOptions] = { ...util.deepClone(options), connect };
10179        this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
10180        this[kMaxRedirections] = maxRedirections;
10181        this[kFactory] = factory;
10182        this[kClients] = /* @__PURE__ */ new Map();
10183        this[kFinalizer] = new FinalizationRegistry(
10184          /* istanbul ignore next: gc is undeterministic */
10185          (key) => {
10186            const ref = this[kClients].get(key);
10187            if (ref !== void 0 && ref.deref() === void 0) {
10188              this[kClients].delete(key);
10189            }
10190          }
10191        );
10192        const agent = this;
10193        this[kOnDrain] = (origin, targets) => {
10194          agent.emit("drain", origin, [agent, ...targets]);
10195        };
10196        this[kOnConnect] = (origin, targets) => {
10197          agent.emit("connect", origin, [agent, ...targets]);
10198        };
10199        this[kOnDisconnect] = (origin, targets, err) => {
10200          agent.emit("disconnect", origin, [agent, ...targets], err);
10201        };
10202        this[kOnConnectionError] = (origin, targets, err) => {
10203          agent.emit("connectionError", origin, [agent, ...targets], err);
10204        };
10205      }
10206      get [kRunning]() {
10207        let ret = 0;
10208        for (const ref of this[kClients].values()) {
10209          const client = ref.deref();
10210          if (client) {
10211            ret += client[kRunning];
10212          }
10213        }
10214        return ret;
10215      }
10216      [kDispatch](opts, handler) {
10217        let key;
10218        if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) {
10219          key = String(opts.origin);
10220        } else {
10221          throw new InvalidArgumentError("opts.origin must be a non-empty string or URL.");
10222        }
10223        const ref = this[kClients].get(key);
10224        let dispatcher = ref ? ref.deref() : null;
10225        if (!dispatcher) {
10226          dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
10227          this[kClients].set(key, new WeakRef2(dispatcher));
10228          this[kFinalizer].register(dispatcher, key);
10229        }
10230        return dispatcher.dispatch(opts, handler);
10231      }
10232      async [kClose]() {
10233        const closePromises = [];
10234        for (const ref of this[kClients].values()) {
10235          const client = ref.deref();
10236          if (client) {
10237            closePromises.push(client.close());
10238          }
10239        }
10240        await Promise.all(closePromises);
10241      }
10242      async [kDestroy](err) {
10243        const destroyPromises = [];
10244        for (const ref of this[kClients].values()) {
10245          const client = ref.deref();
10246          if (client) {
10247            destroyPromises.push(client.destroy(err));
10248          }
10249        }
10250        await Promise.all(destroyPromises);
10251      }
10252    };
10253    module2.exports = Agent;
10254  }
10255});
10256
10257// lib/global.js
10258var require_global2 = __commonJS({
10259  "lib/global.js"(exports2, module2) {
10260    "use strict";
10261    var globalDispatcher = Symbol.for("undici.globalDispatcher.1");
10262    var { InvalidArgumentError } = require_errors();
10263    var Agent = require_agent();
10264    if (getGlobalDispatcher() === void 0) {
10265      setGlobalDispatcher(new Agent());
10266    }
10267    function setGlobalDispatcher(agent) {
10268      if (!agent || typeof agent.dispatch !== "function") {
10269        throw new InvalidArgumentError("Argument agent must implement Agent");
10270      }
10271      Object.defineProperty(globalThis, globalDispatcher, {
10272        value: agent,
10273        writable: true,
10274        enumerable: false,
10275        configurable: false
10276      });
10277    }
10278    __name(setGlobalDispatcher, "setGlobalDispatcher");
10279    function getGlobalDispatcher() {
10280      return globalThis[globalDispatcher];
10281    }
10282    __name(getGlobalDispatcher, "getGlobalDispatcher");
10283    module2.exports = {
10284      setGlobalDispatcher,
10285      getGlobalDispatcher
10286    };
10287  }
10288});
10289
10290// lib/fetch/index.js
10291var require_fetch = __commonJS({
10292  "lib/fetch/index.js"(exports2, module2) {
10293    "use strict";
10294    var {
10295      Response,
10296      makeNetworkError,
10297      makeAppropriateNetworkError,
10298      filterResponse,
10299      makeResponse
10300    } = require_response();
10301    var { Headers } = require_headers();
10302    var { Request, makeRequest } = require_request();
10303    var zlib = require("zlib");
10304    var {
10305      bytesMatch,
10306      makePolicyContainer,
10307      clonePolicyContainer,
10308      requestBadPort,
10309      TAOCheck,
10310      appendRequestOriginHeader,
10311      responseLocationURL,
10312      requestCurrentURL,
10313      setRequestReferrerPolicyOnRedirect,
10314      tryUpgradeRequestToAPotentiallyTrustworthyURL,
10315      createOpaqueTimingInfo,
10316      appendFetchMetadata,
10317      corsCheck,
10318      crossOriginResourcePolicyCheck,
10319      determineRequestsReferrer,
10320      coarsenedSharedCurrentTime,
10321      createDeferredPromise,
10322      isBlobLike,
10323      sameOrigin,
10324      isCancelled,
10325      isAborted,
10326      isErrorLike,
10327      fullyReadBody,
10328      readableStreamClose,
10329      isomorphicEncode,
10330      urlIsLocal,
10331      urlIsHttpHttpsScheme,
10332      urlHasHttpsScheme
10333    } = require_util2();
10334    var { kState, kHeaders, kGuard, kRealm } = require_symbols2();
10335    var assert = require("assert");
10336    var { safelyExtractBody } = require_body();
10337    var {
10338      redirectStatusSet,
10339      nullBodyStatus,
10340      safeMethodsSet,
10341      requestBodyHeader,
10342      subresourceSet,
10343      DOMException
10344    } = require_constants2();
10345    var { kHeadersList } = require_symbols();
10346    var EE = require("events");
10347    var { Readable, pipeline } = require("stream");
10348    var { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = require_util();
10349    var { dataURLProcessor, serializeAMimeType } = require_dataURL();
10350    var { TransformStream } = require("stream/web");
10351    var { getGlobalDispatcher } = require_global2();
10352    var { webidl } = require_webidl();
10353    var { STATUS_CODES } = require("http");
10354    var GET_OR_HEAD = ["GET", "HEAD"];
10355    var resolveObjectURL;
10356    var ReadableStream = globalThis.ReadableStream;
10357    var Fetch = class extends EE {
10358      static {
10359        __name(this, "Fetch");
10360      }
10361      constructor(dispatcher) {
10362        super();
10363        this.dispatcher = dispatcher;
10364        this.connection = null;
10365        this.dump = false;
10366        this.state = "ongoing";
10367        this.setMaxListeners(21);
10368      }
10369      terminate(reason) {
10370        if (this.state !== "ongoing") {
10371          return;
10372        }
10373        this.state = "terminated";
10374        this.connection?.destroy(reason);
10375        this.emit("terminated", reason);
10376      }
10377      // https://fetch.spec.whatwg.org/#fetch-controller-abort
10378      abort(error) {
10379        if (this.state !== "ongoing") {
10380          return;
10381        }
10382        this.state = "aborted";
10383        if (!error) {
10384          error = new DOMException("The operation was aborted.", "AbortError");
10385        }
10386        this.serializedAbortReason = error;
10387        this.connection?.destroy(error);
10388        this.emit("terminated", error);
10389      }
10390    };
10391    function fetch2(input, init = {}) {
10392      webidl.argumentLengthCheck(arguments, 1, { header: "globalThis.fetch" });
10393      const p = createDeferredPromise();
10394      let requestObject;
10395      try {
10396        requestObject = new Request(input, init);
10397      } catch (e) {
10398        p.reject(e);
10399        return p.promise;
10400      }
10401      const request = requestObject[kState];
10402      if (requestObject.signal.aborted) {
10403        abortFetch(p, request, null, requestObject.signal.reason);
10404        return p.promise;
10405      }
10406      const globalObject = request.client.globalObject;
10407      if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") {
10408        request.serviceWorkers = "none";
10409      }
10410      let responseObject = null;
10411      const relevantRealm = null;
10412      let locallyAborted = false;
10413      let controller = null;
10414      addAbortListener(
10415        requestObject.signal,
10416        () => {
10417          locallyAborted = true;
10418          assert(controller != null);
10419          controller.abort(requestObject.signal.reason);
10420          abortFetch(p, request, responseObject, requestObject.signal.reason);
10421        }
10422      );
10423      const handleFetchDone = /* @__PURE__ */ __name((response) => finalizeAndReportTiming(response, "fetch"), "handleFetchDone");
10424      const processResponse = /* @__PURE__ */ __name((response) => {
10425        if (locallyAborted) {
10426          return Promise.resolve();
10427        }
10428        if (response.aborted) {
10429          abortFetch(p, request, responseObject, controller.serializedAbortReason);
10430          return Promise.resolve();
10431        }
10432        if (response.type === "error") {
10433          p.reject(
10434            Object.assign(new TypeError("fetch failed"), { cause: response.error })
10435          );
10436          return Promise.resolve();
10437        }
10438        responseObject = new Response();
10439        responseObject[kState] = response;
10440        responseObject[kRealm] = relevantRealm;
10441        responseObject[kHeaders][kHeadersList] = response.headersList;
10442        responseObject[kHeaders][kGuard] = "immutable";
10443        responseObject[kHeaders][kRealm] = relevantRealm;
10444        p.resolve(responseObject);
10445      }, "processResponse");
10446      controller = fetching({
10447        request,
10448        processResponseEndOfBody: handleFetchDone,
10449        processResponse,
10450        dispatcher: init.dispatcher ?? getGlobalDispatcher()
10451        // undici
10452      });
10453      return p.promise;
10454    }
10455    __name(fetch2, "fetch");
10456    function finalizeAndReportTiming(response, initiatorType = "other") {
10457      if (response.type === "error" && response.aborted) {
10458        return;
10459      }
10460      if (!response.urlList?.length) {
10461        return;
10462      }
10463      const originalURL = response.urlList[0];
10464      let timingInfo = response.timingInfo;
10465      let cacheState = response.cacheState;
10466      if (!urlIsHttpHttpsScheme(originalURL)) {
10467        return;
10468      }
10469      if (timingInfo === null) {
10470        return;
10471      }
10472      if (!response.timingAllowPassed) {
10473        timingInfo = createOpaqueTimingInfo({
10474          startTime: timingInfo.startTime
10475        });
10476        cacheState = "";
10477      }
10478      timingInfo.endTime = coarsenedSharedCurrentTime();
10479      response.timingInfo = timingInfo;
10480      markResourceTiming(
10481        timingInfo,
10482        originalURL,
10483        initiatorType,
10484        globalThis,
10485        cacheState
10486      );
10487    }
10488    __name(finalizeAndReportTiming, "finalizeAndReportTiming");
10489    function markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState) {
10490      if (nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 2) {
10491        performance.markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis2, cacheState);
10492      }
10493    }
10494    __name(markResourceTiming, "markResourceTiming");
10495    function abortFetch(p, request, responseObject, error) {
10496      if (!error) {
10497        error = new DOMException("The operation was aborted.", "AbortError");
10498      }
10499      p.reject(error);
10500      if (request.body != null && isReadable(request.body?.stream)) {
10501        request.body.stream.cancel(error).catch((err) => {
10502          if (err.code === "ERR_INVALID_STATE") {
10503            return;
10504          }
10505          throw err;
10506        });
10507      }
10508      if (responseObject == null) {
10509        return;
10510      }
10511      const response = responseObject[kState];
10512      if (response.body != null && isReadable(response.body?.stream)) {
10513        response.body.stream.cancel(error).catch((err) => {
10514          if (err.code === "ERR_INVALID_STATE") {
10515            return;
10516          }
10517          throw err;
10518        });
10519      }
10520    }
10521    __name(abortFetch, "abortFetch");
10522    function fetching({
10523      request,
10524      processRequestBodyChunkLength,
10525      processRequestEndOfBody,
10526      processResponse,
10527      processResponseEndOfBody,
10528      processResponseConsumeBody,
10529      useParallelQueue = false,
10530      dispatcher
10531      // undici
10532    }) {
10533      let taskDestination = null;
10534      let crossOriginIsolatedCapability = false;
10535      if (request.client != null) {
10536        taskDestination = request.client.globalObject;
10537        crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability;
10538      }
10539      const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability);
10540      const timingInfo = createOpaqueTimingInfo({
10541        startTime: currenTime
10542      });
10543      const fetchParams = {
10544        controller: new Fetch(dispatcher),
10545        request,
10546        timingInfo,
10547        processRequestBodyChunkLength,
10548        processRequestEndOfBody,
10549        processResponse,
10550        processResponseConsumeBody,
10551        processResponseEndOfBody,
10552        taskDestination,
10553        crossOriginIsolatedCapability
10554      };
10555      assert(!request.body || request.body.stream);
10556      if (request.window === "client") {
10557        request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window";
10558      }
10559      if (request.origin === "client") {
10560        request.origin = request.client?.origin;
10561      }
10562      if (request.policyContainer === "client") {
10563        if (request.client != null) {
10564          request.policyContainer = clonePolicyContainer(
10565            request.client.policyContainer
10566          );
10567        } else {
10568          request.policyContainer = makePolicyContainer();
10569        }
10570      }
10571      if (!request.headersList.contains("accept")) {
10572        const value = "*/*";
10573        request.headersList.append("accept", value);
10574      }
10575      if (!request.headersList.contains("accept-language")) {
10576        request.headersList.append("accept-language", "*");
10577      }
10578      if (request.priority === null) {
10579      }
10580      if (subresourceSet.has(request.destination)) {
10581      }
10582      mainFetch(fetchParams).catch((err) => {
10583        fetchParams.controller.terminate(err);
10584      });
10585      return fetchParams.controller;
10586    }
10587    __name(fetching, "fetching");
10588    async function mainFetch(fetchParams, recursive = false) {
10589      const request = fetchParams.request;
10590      let response = null;
10591      if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) {
10592        response = makeNetworkError("local URLs only");
10593      }
10594      tryUpgradeRequestToAPotentiallyTrustworthyURL(request);
10595      if (requestBadPort(request) === "blocked") {
10596        response = makeNetworkError("bad port");
10597      }
10598      if (request.referrerPolicy === "") {
10599        request.referrerPolicy = request.policyContainer.referrerPolicy;
10600      }
10601      if (request.referrer !== "no-referrer") {
10602        request.referrer = determineRequestsReferrer(request);
10603      }
10604      if (response === null) {
10605        response = await (async () => {
10606          const currentURL = requestCurrentURL(request);
10607          if (
10608            // - request’s current URL’s origin is same origin with request’s origin,
10609            //   and request’s response tainting is "basic"
10610            sameOrigin(currentURL, request.url) && request.responseTainting === "basic" || // request’s current URL’s scheme is "data"
10611            currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket"
10612            (request.mode === "navigate" || request.mode === "websocket")
10613          ) {
10614            request.responseTainting = "basic";
10615            return await schemeFetch(fetchParams);
10616          }
10617          if (request.mode === "same-origin") {
10618            return makeNetworkError('request mode cannot be "same-origin"');
10619          }
10620          if (request.mode === "no-cors") {
10621            if (request.redirect !== "follow") {
10622              return makeNetworkError(
10623                'redirect mode cannot be "follow" for "no-cors" request'
10624              );
10625            }
10626            request.responseTainting = "opaque";
10627            return await schemeFetch(fetchParams);
10628          }
10629          if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) {
10630            return makeNetworkError("URL scheme must be a HTTP(S) scheme");
10631          }
10632          request.responseTainting = "cors";
10633          return await httpFetch(fetchParams);
10634        })();
10635      }
10636      if (recursive) {
10637        return response;
10638      }
10639      if (response.status !== 0 && !response.internalResponse) {
10640        if (request.responseTainting === "cors") {
10641        }
10642        if (request.responseTainting === "basic") {
10643          response = filterResponse(response, "basic");
10644        } else if (request.responseTainting === "cors") {
10645          response = filterResponse(response, "cors");
10646        } else if (request.responseTainting === "opaque") {
10647          response = filterResponse(response, "opaque");
10648        } else {
10649          assert(false);
10650        }
10651      }
10652      let internalResponse = response.status === 0 ? response : response.internalResponse;
10653      if (internalResponse.urlList.length === 0) {
10654        internalResponse.urlList.push(...request.urlList);
10655      }
10656      if (!request.timingAllowFailed) {
10657        response.timingAllowPassed = true;
10658      }
10659      if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request.headers.contains("range")) {
10660        response = internalResponse = makeNetworkError();
10661      }
10662      if (response.status !== 0 && (request.method === "HEAD" || request.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) {
10663        internalResponse.body = null;
10664        fetchParams.controller.dump = true;
10665      }
10666      if (request.integrity) {
10667        const processBodyError = /* @__PURE__ */ __name((reason) => fetchFinale(fetchParams, makeNetworkError(reason)), "processBodyError");
10668        if (request.responseTainting === "opaque" || response.body == null) {
10669          processBodyError(response.error);
10670          return;
10671        }
10672        const processBody = /* @__PURE__ */ __name((bytes) => {
10673          if (!bytesMatch(bytes, request.integrity)) {
10674            processBodyError("integrity mismatch");
10675            return;
10676          }
10677          response.body = safelyExtractBody(bytes)[0];
10678          fetchFinale(fetchParams, response);
10679        }, "processBody");
10680        await fullyReadBody(response.body, processBody, processBodyError);
10681      } else {
10682        fetchFinale(fetchParams, response);
10683      }
10684    }
10685    __name(mainFetch, "mainFetch");
10686    function schemeFetch(fetchParams) {
10687      if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
10688        return Promise.resolve(makeAppropriateNetworkError(fetchParams));
10689      }
10690      const { request } = fetchParams;
10691      const { protocol: scheme } = requestCurrentURL(request);
10692      switch (scheme) {
10693        case "about:": {
10694          return Promise.resolve(makeNetworkError("about scheme is not supported"));
10695        }
10696        case "blob:": {
10697          if (!resolveObjectURL) {
10698            resolveObjectURL = require("buffer").resolveObjectURL;
10699          }
10700          const blobURLEntry = requestCurrentURL(request);
10701          if (blobURLEntry.search.length !== 0) {
10702            return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource."));
10703          }
10704          const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString());
10705          if (request.method !== "GET" || !isBlobLike(blobURLEntryObject)) {
10706            return Promise.resolve(makeNetworkError("invalid method"));
10707          }
10708          const bodyWithType = safelyExtractBody(blobURLEntryObject);
10709          const body = bodyWithType[0];
10710          const length = isomorphicEncode(`${body.length}`);
10711          const type = bodyWithType[1] ?? "";
10712          const response = makeResponse({
10713            statusText: "OK",
10714            headersList: [
10715              ["content-length", { name: "Content-Length", value: length }],
10716              ["content-type", { name: "Content-Type", value: type }]
10717            ]
10718          });
10719          response.body = body;
10720          return Promise.resolve(response);
10721        }
10722        case "data:": {
10723          const currentURL = requestCurrentURL(request);
10724          const dataURLStruct = dataURLProcessor(currentURL);
10725          if (dataURLStruct === "failure") {
10726            return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
10727          }
10728          const mimeType = serializeAMimeType(dataURLStruct.mimeType);
10729          return Promise.resolve(makeResponse({
10730            statusText: "OK",
10731            headersList: [
10732              ["content-type", { name: "Content-Type", value: mimeType }]
10733            ],
10734            body: safelyExtractBody(dataURLStruct.body)[0]
10735          }));
10736        }
10737        case "file:": {
10738          return Promise.resolve(makeNetworkError("not implemented... yet..."));
10739        }
10740        case "http:":
10741        case "https:": {
10742          return httpFetch(fetchParams).catch((err) => makeNetworkError(err));
10743        }
10744        default: {
10745          return Promise.resolve(makeNetworkError("unknown scheme"));
10746        }
10747      }
10748    }
10749    __name(schemeFetch, "schemeFetch");
10750    function finalizeResponse(fetchParams, response) {
10751      fetchParams.request.done = true;
10752      if (fetchParams.processResponseDone != null) {
10753        queueMicrotask(() => fetchParams.processResponseDone(response));
10754      }
10755    }
10756    __name(finalizeResponse, "finalizeResponse");
10757    function fetchFinale(fetchParams, response) {
10758      if (response.type === "error") {
10759        response.urlList = [fetchParams.request.urlList[0]];
10760        response.timingInfo = createOpaqueTimingInfo({
10761          startTime: fetchParams.timingInfo.startTime
10762        });
10763      }
10764      const processResponseEndOfBody = /* @__PURE__ */ __name(() => {
10765        fetchParams.request.done = true;
10766        if (fetchParams.processResponseEndOfBody != null) {
10767          queueMicrotask(() => fetchParams.processResponseEndOfBody(response));
10768        }
10769      }, "processResponseEndOfBody");
10770      if (fetchParams.processResponse != null) {
10771        queueMicrotask(() => fetchParams.processResponse(response));
10772      }
10773      if (response.body == null) {
10774        processResponseEndOfBody();
10775      } else {
10776        const identityTransformAlgorithm = /* @__PURE__ */ __name((chunk, controller) => {
10777          controller.enqueue(chunk);
10778        }, "identityTransformAlgorithm");
10779        const transformStream = new TransformStream({
10780          start() {
10781          },
10782          transform: identityTransformAlgorithm,
10783          flush: processResponseEndOfBody
10784        }, {
10785          size() {
10786            return 1;
10787          }
10788        }, {
10789          size() {
10790            return 1;
10791          }
10792        });
10793        response.body = { stream: response.body.stream.pipeThrough(transformStream) };
10794      }
10795      if (fetchParams.processResponseConsumeBody != null) {
10796        const processBody = /* @__PURE__ */ __name((nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes), "processBody");
10797        const processBodyError = /* @__PURE__ */ __name((failure) => fetchParams.processResponseConsumeBody(response, failure), "processBodyError");
10798        if (response.body == null) {
10799          queueMicrotask(() => processBody(null));
10800        } else {
10801          return fullyReadBody(response.body, processBody, processBodyError);
10802        }
10803        return Promise.resolve();
10804      }
10805    }
10806    __name(fetchFinale, "fetchFinale");
10807    async function httpFetch(fetchParams) {
10808      const request = fetchParams.request;
10809      let response = null;
10810      let actualResponse = null;
10811      const timingInfo = fetchParams.timingInfo;
10812      if (request.serviceWorkers === "all") {
10813      }
10814      if (response === null) {
10815        if (request.redirect === "follow") {
10816          request.serviceWorkers = "none";
10817        }
10818        actualResponse = response = await httpNetworkOrCacheFetch(fetchParams);
10819        if (request.responseTainting === "cors" && corsCheck(request, response) === "failure") {
10820          return makeNetworkError("cors failure");
10821        }
10822        if (TAOCheck(request, response) === "failure") {
10823          request.timingAllowFailed = true;
10824        }
10825      }
10826      if ((request.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck(
10827        request.origin,
10828        request.client,
10829        request.destination,
10830        actualResponse
10831      ) === "blocked") {
10832        return makeNetworkError("blocked");
10833      }
10834      if (redirectStatusSet.has(actualResponse.status)) {
10835        if (request.redirect !== "manual") {
10836          fetchParams.controller.connection.destroy();
10837        }
10838        if (request.redirect === "error") {
10839          response = makeNetworkError("unexpected redirect");
10840        } else if (request.redirect === "manual") {
10841          response = actualResponse;
10842        } else if (request.redirect === "follow") {
10843          response = await httpRedirectFetch(fetchParams, response);
10844        } else {
10845          assert(false);
10846        }
10847      }
10848      response.timingInfo = timingInfo;
10849      return response;
10850    }
10851    __name(httpFetch, "httpFetch");
10852    function httpRedirectFetch(fetchParams, response) {
10853      const request = fetchParams.request;
10854      const actualResponse = response.internalResponse ? response.internalResponse : response;
10855      let locationURL;
10856      try {
10857        locationURL = responseLocationURL(
10858          actualResponse,
10859          requestCurrentURL(request).hash
10860        );
10861        if (locationURL == null) {
10862          return response;
10863        }
10864      } catch (err) {
10865        return Promise.resolve(makeNetworkError(err));
10866      }
10867      if (!urlIsHttpHttpsScheme(locationURL)) {
10868        return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme"));
10869      }
10870      if (request.redirectCount === 20) {
10871        return Promise.resolve(makeNetworkError("redirect count exceeded"));
10872      }
10873      request.redirectCount += 1;
10874      if (request.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request, locationURL)) {
10875        return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"'));
10876      }
10877      if (request.responseTainting === "cors" && (locationURL.username || locationURL.password)) {
10878        return Promise.resolve(makeNetworkError(
10879          'URL cannot contain credentials for request mode "cors"'
10880        ));
10881      }
10882      if (actualResponse.status !== 303 && request.body != null && request.body.source == null) {
10883        return Promise.resolve(makeNetworkError());
10884      }
10885      if ([301, 302].includes(actualResponse.status) && request.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request.method)) {
10886        request.method = "GET";
10887        request.body = null;
10888        for (const headerName of requestBodyHeader) {
10889          request.headersList.delete(headerName);
10890        }
10891      }
10892      if (!sameOrigin(requestCurrentURL(request), locationURL)) {
10893        request.headersList.delete("authorization");
10894        request.headersList.delete("proxy-authorization", true);
10895        request.headersList.delete("cookie");
10896        request.headersList.delete("host");
10897      }
10898      if (request.body != null) {
10899        assert(request.body.source != null);
10900        request.body = safelyExtractBody(request.body.source)[0];
10901      }
10902      const timingInfo = fetchParams.timingInfo;
10903      timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
10904      if (timingInfo.redirectStartTime === 0) {
10905        timingInfo.redirectStartTime = timingInfo.startTime;
10906      }
10907      request.urlList.push(locationURL);
10908      setRequestReferrerPolicyOnRedirect(request, actualResponse);
10909      return mainFetch(fetchParams, true);
10910    }
10911    __name(httpRedirectFetch, "httpRedirectFetch");
10912    async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) {
10913      const request = fetchParams.request;
10914      let httpFetchParams = null;
10915      let httpRequest = null;
10916      let response = null;
10917      const httpCache = null;
10918      const revalidatingFlag = false;
10919      if (request.window === "no-window" && request.redirect === "error") {
10920        httpFetchParams = fetchParams;
10921        httpRequest = request;
10922      } else {
10923        httpRequest = makeRequest(request);
10924        httpFetchParams = { ...fetchParams };
10925        httpFetchParams.request = httpRequest;
10926      }
10927      const includeCredentials = request.credentials === "include" || request.credentials === "same-origin" && request.responseTainting === "basic";
10928      const contentLength = httpRequest.body ? httpRequest.body.length : null;
10929      let contentLengthHeaderValue = null;
10930      if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) {
10931        contentLengthHeaderValue = "0";
10932      }
10933      if (contentLength != null) {
10934        contentLengthHeaderValue = isomorphicEncode(`${contentLength}`);
10935      }
10936      if (contentLengthHeaderValue != null) {
10937        httpRequest.headersList.append("content-length", contentLengthHeaderValue);
10938      }
10939      if (contentLength != null && httpRequest.keepalive) {
10940      }
10941      if (httpRequest.referrer instanceof URL) {
10942        httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href));
10943      }
10944      appendRequestOriginHeader(httpRequest);
10945      appendFetchMetadata(httpRequest);
10946      if (!httpRequest.headersList.contains("user-agent")) {
10947        httpRequest.headersList.append("user-agent", false ? "undici" : "node");
10948      }
10949      if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since") || httpRequest.headersList.contains("if-none-match") || httpRequest.headersList.contains("if-unmodified-since") || httpRequest.headersList.contains("if-match") || httpRequest.headersList.contains("if-range"))) {
10950        httpRequest.cache = "no-store";
10951      }
10952      if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control")) {
10953        httpRequest.headersList.append("cache-control", "max-age=0");
10954      }
10955      if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") {
10956        if (!httpRequest.headersList.contains("pragma")) {
10957          httpRequest.headersList.append("pragma", "no-cache");
10958        }
10959        if (!httpRequest.headersList.contains("cache-control")) {
10960          httpRequest.headersList.append("cache-control", "no-cache");
10961        }
10962      }
10963      if (httpRequest.headersList.contains("range")) {
10964        httpRequest.headersList.append("accept-encoding", "identity");
10965      }
10966      if (!httpRequest.headersList.contains("accept-encoding")) {
10967        if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) {
10968          httpRequest.headersList.append("accept-encoding", "br, gzip, deflate");
10969        } else {
10970          httpRequest.headersList.append("accept-encoding", "gzip, deflate");
10971        }
10972      }
10973      httpRequest.headersList.delete("host");
10974      if (includeCredentials) {
10975      }
10976      if (httpCache == null) {
10977        httpRequest.cache = "no-store";
10978      }
10979      if (httpRequest.mode !== "no-store" && httpRequest.mode !== "reload") {
10980      }
10981      if (response == null) {
10982        if (httpRequest.mode === "only-if-cached") {
10983          return makeNetworkError("only if cached");
10984        }
10985        const forwardResponse = await httpNetworkFetch(
10986          httpFetchParams,
10987          includeCredentials,
10988          isNewConnectionFetch
10989        );
10990        if (!safeMethodsSet.has(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399) {
10991        }
10992        if (revalidatingFlag && forwardResponse.status === 304) {
10993        }
10994        if (response == null) {
10995          response = forwardResponse;
10996        }
10997      }
10998      response.urlList = [...httpRequest.urlList];
10999      if (httpRequest.headersList.contains("range")) {
11000        response.rangeRequested = true;
11001      }
11002      response.requestIncludesCredentials = includeCredentials;
11003      if (response.status === 407) {
11004        if (request.window === "no-window") {
11005          return makeNetworkError();
11006        }
11007        if (isCancelled(fetchParams)) {
11008          return makeAppropriateNetworkError(fetchParams);
11009        }
11010        return makeNetworkError("proxy authentication required");
11011      }
11012      if (
11013        // response’s status is 421
11014        response.status === 421 && // isNewConnectionFetch is false
11015        !isNewConnectionFetch && // request’s body is null, or request’s body is non-null and request’s body’s source is non-null
11016        (request.body == null || request.body.source != null)
11017      ) {
11018        if (isCancelled(fetchParams)) {
11019          return makeAppropriateNetworkError(fetchParams);
11020        }
11021        fetchParams.controller.connection.destroy();
11022        response = await httpNetworkOrCacheFetch(
11023          fetchParams,
11024          isAuthenticationFetch,
11025          true
11026        );
11027      }
11028      if (isAuthenticationFetch) {
11029      }
11030      return response;
11031    }
11032    __name(httpNetworkOrCacheFetch, "httpNetworkOrCacheFetch");
11033    async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) {
11034      assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed);
11035      fetchParams.controller.connection = {
11036        abort: null,
11037        destroyed: false,
11038        destroy(err) {
11039          if (!this.destroyed) {
11040            this.destroyed = true;
11041            this.abort?.(err ?? new DOMException("The operation was aborted.", "AbortError"));
11042          }
11043        }
11044      };
11045      const request = fetchParams.request;
11046      let response = null;
11047      const timingInfo = fetchParams.timingInfo;
11048      const httpCache = null;
11049      if (httpCache == null) {
11050        request.cache = "no-store";
11051      }
11052      const newConnection = forceNewConnection ? "yes" : "no";
11053      if (request.mode === "websocket") {
11054      } else {
11055      }
11056      let requestBody = null;
11057      if (request.body == null && fetchParams.processRequestEndOfBody) {
11058        queueMicrotask(() => fetchParams.processRequestEndOfBody());
11059      } else if (request.body != null) {
11060        const processBodyChunk = /* @__PURE__ */ __name(async function* (bytes) {
11061          if (isCancelled(fetchParams)) {
11062            return;
11063          }
11064          yield bytes;
11065          fetchParams.processRequestBodyChunkLength?.(bytes.byteLength);
11066        }, "processBodyChunk");
11067        const processEndOfBody = /* @__PURE__ */ __name(() => {
11068          if (isCancelled(fetchParams)) {
11069            return;
11070          }
11071          if (fetchParams.processRequestEndOfBody) {
11072            fetchParams.processRequestEndOfBody();
11073          }
11074        }, "processEndOfBody");
11075        const processBodyError = /* @__PURE__ */ __name((e) => {
11076          if (isCancelled(fetchParams)) {
11077            return;
11078          }
11079          if (e.name === "AbortError") {
11080            fetchParams.controller.abort();
11081          } else {
11082            fetchParams.controller.terminate(e);
11083          }
11084        }, "processBodyError");
11085        requestBody = async function* () {
11086          try {
11087            for await (const bytes of request.body.stream) {
11088              yield* processBodyChunk(bytes);
11089            }
11090            processEndOfBody();
11091          } catch (err) {
11092            processBodyError(err);
11093          }
11094        }();
11095      }
11096      try {
11097        const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody });
11098        if (socket) {
11099          response = makeResponse({ status, statusText, headersList, socket });
11100        } else {
11101          const iterator = body[Symbol.asyncIterator]();
11102          fetchParams.controller.next = () => iterator.next();
11103          response = makeResponse({ status, statusText, headersList });
11104        }
11105      } catch (err) {
11106        if (err.name === "AbortError") {
11107          fetchParams.controller.connection.destroy();
11108          return makeAppropriateNetworkError(fetchParams, err);
11109        }
11110        return makeNetworkError(err);
11111      }
11112      const pullAlgorithm = /* @__PURE__ */ __name(() => {
11113        fetchParams.controller.resume();
11114      }, "pullAlgorithm");
11115      const cancelAlgorithm = /* @__PURE__ */ __name((reason) => {
11116        fetchParams.controller.abort(reason);
11117      }, "cancelAlgorithm");
11118      if (!ReadableStream) {
11119        ReadableStream = require("stream/web").ReadableStream;
11120      }
11121      const stream = new ReadableStream(
11122        {
11123          async start(controller) {
11124            fetchParams.controller.controller = controller;
11125          },
11126          async pull(controller) {
11127            await pullAlgorithm(controller);
11128          },
11129          async cancel(reason) {
11130            await cancelAlgorithm(reason);
11131          }
11132        },
11133        {
11134          highWaterMark: 0,
11135          size() {
11136            return 1;
11137          }
11138        }
11139      );
11140      response.body = { stream };
11141      fetchParams.controller.on("terminated", onAborted);
11142      fetchParams.controller.resume = async () => {
11143        while (true) {
11144          let bytes;
11145          let isFailure;
11146          try {
11147            const { done, value } = await fetchParams.controller.next();
11148            if (isAborted(fetchParams)) {
11149              break;
11150            }
11151            bytes = done ? void 0 : value;
11152          } catch (err) {
11153            if (fetchParams.controller.ended && !timingInfo.encodedBodySize) {
11154              bytes = void 0;
11155            } else {
11156              bytes = err;
11157              isFailure = true;
11158            }
11159          }
11160          if (bytes === void 0) {
11161            readableStreamClose(fetchParams.controller.controller);
11162            finalizeResponse(fetchParams, response);
11163            return;
11164          }
11165          timingInfo.decodedBodySize += bytes?.byteLength ?? 0;
11166          if (isFailure) {
11167            fetchParams.controller.terminate(bytes);
11168            return;
11169          }
11170          fetchParams.controller.controller.enqueue(new Uint8Array(bytes));
11171          if (isErrored(stream)) {
11172            fetchParams.controller.terminate();
11173            return;
11174          }
11175          if (!fetchParams.controller.controller.desiredSize) {
11176            return;
11177          }
11178        }
11179      };
11180      function onAborted(reason) {
11181        if (isAborted(fetchParams)) {
11182          response.aborted = true;
11183          if (isReadable(stream)) {
11184            fetchParams.controller.controller.error(
11185              fetchParams.controller.serializedAbortReason
11186            );
11187          }
11188        } else {
11189          if (isReadable(stream)) {
11190            fetchParams.controller.controller.error(new TypeError("terminated", {
11191              cause: isErrorLike(reason) ? reason : void 0
11192            }));
11193          }
11194        }
11195        fetchParams.controller.connection.destroy();
11196      }
11197      __name(onAborted, "onAborted");
11198      return response;
11199      async function dispatch({ body }) {
11200        const url = requestCurrentURL(request);
11201        const agent = fetchParams.controller.dispatcher;
11202        return new Promise((resolve, reject) => agent.dispatch(
11203          {
11204            path: url.pathname + url.search,
11205            origin: url.origin,
11206            method: request.method,
11207            body: fetchParams.controller.dispatcher.isMockActive ? request.body && (request.body.source || request.body.stream) : body,
11208            headers: request.headersList.entries,
11209            maxRedirections: 0,
11210            upgrade: request.mode === "websocket" ? "websocket" : void 0
11211          },
11212          {
11213            body: null,
11214            abort: null,
11215            onConnect(abort) {
11216              const { connection } = fetchParams.controller;
11217              if (connection.destroyed) {
11218                abort(new DOMException("The operation was aborted.", "AbortError"));
11219              } else {
11220                fetchParams.controller.on("terminated", abort);
11221                this.abort = connection.abort = abort;
11222              }
11223            },
11224            onHeaders(status, headersList, resume, statusText) {
11225              if (status < 200) {
11226                return;
11227              }
11228              let codings = [];
11229              let location = "";
11230              const headers = new Headers();
11231              if (Array.isArray(headersList)) {
11232                for (let n = 0; n < headersList.length; n += 2) {
11233                  const key = headersList[n + 0].toString("latin1");
11234                  const val = headersList[n + 1].toString("latin1");
11235                  if (key.toLowerCase() === "content-encoding") {
11236                    codings = val.toLowerCase().split(",").map((x) => x.trim());
11237                  } else if (key.toLowerCase() === "location") {
11238                    location = val;
11239                  }
11240                  headers[kHeadersList].append(key, val);
11241                }
11242              } else {
11243                const keys = Object.keys(headersList);
11244                for (const key of keys) {
11245                  const val = headersList[key];
11246                  if (key.toLowerCase() === "content-encoding") {
11247                    codings = val.toLowerCase().split(",").map((x) => x.trim()).reverse();
11248                  } else if (key.toLowerCase() === "location") {
11249                    location = val;
11250                  }
11251                  headers[kHeadersList].append(key, val);
11252                }
11253              }
11254              this.body = new Readable({ read: resume });
11255              const decoders = [];
11256              const willFollow = request.redirect === "follow" && location && redirectStatusSet.has(status);
11257              if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) {
11258                for (const coding of codings) {
11259                  if (coding === "x-gzip" || coding === "gzip") {
11260                    decoders.push(zlib.createGunzip({
11261                      // Be less strict when decoding compressed responses, since sometimes
11262                      // servers send slightly invalid responses that are still accepted
11263                      // by common browsers.
11264                      // Always using Z_SYNC_FLUSH is what cURL does.
11265                      flush: zlib.constants.Z_SYNC_FLUSH,
11266                      finishFlush: zlib.constants.Z_SYNC_FLUSH
11267                    }));
11268                  } else if (coding === "deflate") {
11269                    decoders.push(zlib.createInflate());
11270                  } else if (coding === "br") {
11271                    decoders.push(zlib.createBrotliDecompress());
11272                  } else {
11273                    decoders.length = 0;
11274                    break;
11275                  }
11276                }
11277              }
11278              resolve({
11279                status,
11280                statusText,
11281                headersList: headers[kHeadersList],
11282                body: decoders.length ? pipeline(this.body, ...decoders, () => {
11283                }) : this.body.on("error", () => {
11284                })
11285              });
11286              return true;
11287            },
11288            onData(chunk) {
11289              if (fetchParams.controller.dump) {
11290                return;
11291              }
11292              const bytes = chunk;
11293              timingInfo.encodedBodySize += bytes.byteLength;
11294              return this.body.push(bytes);
11295            },
11296            onComplete() {
11297              if (this.abort) {
11298                fetchParams.controller.off("terminated", this.abort);
11299              }
11300              fetchParams.controller.ended = true;
11301              this.body.push(null);
11302            },
11303            onError(error) {
11304              if (this.abort) {
11305                fetchParams.controller.off("terminated", this.abort);
11306              }
11307              this.body?.destroy(error);
11308              fetchParams.controller.terminate(error);
11309              reject(error);
11310            },
11311            onUpgrade(status, headersList, socket) {
11312              if (status !== 101) {
11313                return;
11314              }
11315              const headers = new Headers();
11316              for (let n = 0; n < headersList.length; n += 2) {
11317                const key = headersList[n + 0].toString("latin1");
11318                const val = headersList[n + 1].toString("latin1");
11319                headers[kHeadersList].append(key, val);
11320              }
11321              resolve({
11322                status,
11323                statusText: STATUS_CODES[status],
11324                headersList: headers[kHeadersList],
11325                socket
11326              });
11327              return true;
11328            }
11329          }
11330        ));
11331      }
11332      __name(dispatch, "dispatch");
11333    }
11334    __name(httpNetworkFetch, "httpNetworkFetch");
11335    module2.exports = {
11336      fetch: fetch2,
11337      Fetch,
11338      fetching,
11339      finalizeAndReportTiming
11340    };
11341  }
11342});
11343
11344// lib/websocket/constants.js
11345var require_constants4 = __commonJS({
11346  "lib/websocket/constants.js"(exports2, module2) {
11347    "use strict";
11348    var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
11349    var staticPropertyDescriptors = {
11350      enumerable: true,
11351      writable: false,
11352      configurable: false
11353    };
11354    var states = {
11355      CONNECTING: 0,
11356      OPEN: 1,
11357      CLOSING: 2,
11358      CLOSED: 3
11359    };
11360    var opcodes = {
11361      CONTINUATION: 0,
11362      TEXT: 1,
11363      BINARY: 2,
11364      CLOSE: 8,
11365      PING: 9,
11366      PONG: 10
11367    };
11368    var maxUnsigned16Bit = 2 ** 16 - 1;
11369    var parserStates = {
11370      INFO: 0,
11371      PAYLOADLENGTH_16: 2,
11372      PAYLOADLENGTH_64: 3,
11373      READ_DATA: 4
11374    };
11375    var emptyBuffer = Buffer.allocUnsafe(0);
11376    module2.exports = {
11377      uid,
11378      staticPropertyDescriptors,
11379      states,
11380      opcodes,
11381      maxUnsigned16Bit,
11382      parserStates,
11383      emptyBuffer
11384    };
11385  }
11386});
11387
11388// lib/websocket/symbols.js
11389var require_symbols3 = __commonJS({
11390  "lib/websocket/symbols.js"(exports2, module2) {
11391    "use strict";
11392    module2.exports = {
11393      kWebSocketURL: Symbol("url"),
11394      kReadyState: Symbol("ready state"),
11395      kController: Symbol("controller"),
11396      kResponse: Symbol("response"),
11397      kBinaryType: Symbol("binary type"),
11398      kSentClose: Symbol("sent close"),
11399      kReceivedClose: Symbol("received close"),
11400      kByteParser: Symbol("byte parser")
11401    };
11402  }
11403});
11404
11405// lib/websocket/events.js
11406var require_events = __commonJS({
11407  "lib/websocket/events.js"(exports2, module2) {
11408    "use strict";
11409    var { webidl } = require_webidl();
11410    var { kEnumerableProperty } = require_util();
11411    var { MessagePort } = require("worker_threads");
11412    var MessageEvent = class _MessageEvent extends Event {
11413      static {
11414        __name(this, "MessageEvent");
11415      }
11416      #eventInit;
11417      constructor(type, eventInitDict = {}) {
11418        webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent constructor" });
11419        type = webidl.converters.DOMString(type);
11420        eventInitDict = webidl.converters.MessageEventInit(eventInitDict);
11421        super(type, eventInitDict);
11422        this.#eventInit = eventInitDict;
11423      }
11424      get data() {
11425        webidl.brandCheck(this, _MessageEvent);
11426        return this.#eventInit.data;
11427      }
11428      get origin() {
11429        webidl.brandCheck(this, _MessageEvent);
11430        return this.#eventInit.origin;
11431      }
11432      get lastEventId() {
11433        webidl.brandCheck(this, _MessageEvent);
11434        return this.#eventInit.lastEventId;
11435      }
11436      get source() {
11437        webidl.brandCheck(this, _MessageEvent);
11438        return this.#eventInit.source;
11439      }
11440      get ports() {
11441        webidl.brandCheck(this, _MessageEvent);
11442        if (!Object.isFrozen(this.#eventInit.ports)) {
11443          Object.freeze(this.#eventInit.ports);
11444        }
11445        return this.#eventInit.ports;
11446      }
11447      initMessageEvent(type, bubbles = false, cancelable = false, data = null, origin = "", lastEventId = "", source = null, ports = []) {
11448        webidl.brandCheck(this, _MessageEvent);
11449        webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent.initMessageEvent" });
11450        return new _MessageEvent(type, {
11451          bubbles,
11452          cancelable,
11453          data,
11454          origin,
11455          lastEventId,
11456          source,
11457          ports
11458        });
11459      }
11460    };
11461    var CloseEvent = class _CloseEvent extends Event {
11462      static {
11463        __name(this, "CloseEvent");
11464      }
11465      #eventInit;
11466      constructor(type, eventInitDict = {}) {
11467        webidl.argumentLengthCheck(arguments, 1, { header: "CloseEvent constructor" });
11468        type = webidl.converters.DOMString(type);
11469        eventInitDict = webidl.converters.CloseEventInit(eventInitDict);
11470        super(type, eventInitDict);
11471        this.#eventInit = eventInitDict;
11472      }
11473      get wasClean() {
11474        webidl.brandCheck(this, _CloseEvent);
11475        return this.#eventInit.wasClean;
11476      }
11477      get code() {
11478        webidl.brandCheck(this, _CloseEvent);
11479        return this.#eventInit.code;
11480      }
11481      get reason() {
11482        webidl.brandCheck(this, _CloseEvent);
11483        return this.#eventInit.reason;
11484      }
11485    };
11486    var ErrorEvent = class _ErrorEvent extends Event {
11487      static {
11488        __name(this, "ErrorEvent");
11489      }
11490      #eventInit;
11491      constructor(type, eventInitDict) {
11492        webidl.argumentLengthCheck(arguments, 1, { header: "ErrorEvent constructor" });
11493        super(type, eventInitDict);
11494        type = webidl.converters.DOMString(type);
11495        eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {});
11496        this.#eventInit = eventInitDict;
11497      }
11498      get message() {
11499        webidl.brandCheck(this, _ErrorEvent);
11500        return this.#eventInit.message;
11501      }
11502      get filename() {
11503        webidl.brandCheck(this, _ErrorEvent);
11504        return this.#eventInit.filename;
11505      }
11506      get lineno() {
11507        webidl.brandCheck(this, _ErrorEvent);
11508        return this.#eventInit.lineno;
11509      }
11510      get colno() {
11511        webidl.brandCheck(this, _ErrorEvent);
11512        return this.#eventInit.colno;
11513      }
11514      get error() {
11515        webidl.brandCheck(this, _ErrorEvent);
11516        return this.#eventInit.error;
11517      }
11518    };
11519    Object.defineProperties(MessageEvent.prototype, {
11520      [Symbol.toStringTag]: {
11521        value: "MessageEvent",
11522        configurable: true
11523      },
11524      data: kEnumerableProperty,
11525      origin: kEnumerableProperty,
11526      lastEventId: kEnumerableProperty,
11527      source: kEnumerableProperty,
11528      ports: kEnumerableProperty,
11529      initMessageEvent: kEnumerableProperty
11530    });
11531    Object.defineProperties(CloseEvent.prototype, {
11532      [Symbol.toStringTag]: {
11533        value: "CloseEvent",
11534        configurable: true
11535      },
11536      reason: kEnumerableProperty,
11537      code: kEnumerableProperty,
11538      wasClean: kEnumerableProperty
11539    });
11540    Object.defineProperties(ErrorEvent.prototype, {
11541      [Symbol.toStringTag]: {
11542        value: "ErrorEvent",
11543        configurable: true
11544      },
11545      message: kEnumerableProperty,
11546      filename: kEnumerableProperty,
11547      lineno: kEnumerableProperty,
11548      colno: kEnumerableProperty,
11549      error: kEnumerableProperty
11550    });
11551    webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort);
11552    webidl.converters["sequence<MessagePort>"] = webidl.sequenceConverter(
11553      webidl.converters.MessagePort
11554    );
11555    var eventInit = [
11556      {
11557        key: "bubbles",
11558        converter: webidl.converters.boolean,
11559        defaultValue: false
11560      },
11561      {
11562        key: "cancelable",
11563        converter: webidl.converters.boolean,
11564        defaultValue: false
11565      },
11566      {
11567        key: "composed",
11568        converter: webidl.converters.boolean,
11569        defaultValue: false
11570      }
11571    ];
11572    webidl.converters.MessageEventInit = webidl.dictionaryConverter([
11573      ...eventInit,
11574      {
11575        key: "data",
11576        converter: webidl.converters.any,
11577        defaultValue: null
11578      },
11579      {
11580        key: "origin",
11581        converter: webidl.converters.USVString,
11582        defaultValue: ""
11583      },
11584      {
11585        key: "lastEventId",
11586        converter: webidl.converters.DOMString,
11587        defaultValue: ""
11588      },
11589      {
11590        key: "source",
11591        // Node doesn't implement WindowProxy or ServiceWorker, so the only
11592        // valid value for source is a MessagePort.
11593        converter: webidl.nullableConverter(webidl.converters.MessagePort),
11594        defaultValue: null
11595      },
11596      {
11597        key: "ports",
11598        converter: webidl.converters["sequence<MessagePort>"],
11599        get defaultValue() {
11600          return [];
11601        }
11602      }
11603    ]);
11604    webidl.converters.CloseEventInit = webidl.dictionaryConverter([
11605      ...eventInit,
11606      {
11607        key: "wasClean",
11608        converter: webidl.converters.boolean,
11609        defaultValue: false
11610      },
11611      {
11612        key: "code",
11613        converter: webidl.converters["unsigned short"],
11614        defaultValue: 0
11615      },
11616      {
11617        key: "reason",
11618        converter: webidl.converters.USVString,
11619        defaultValue: ""
11620      }
11621    ]);
11622    webidl.converters.ErrorEventInit = webidl.dictionaryConverter([
11623      ...eventInit,
11624      {
11625        key: "message",
11626        converter: webidl.converters.DOMString,
11627        defaultValue: ""
11628      },
11629      {
11630        key: "filename",
11631        converter: webidl.converters.USVString,
11632        defaultValue: ""
11633      },
11634      {
11635        key: "lineno",
11636        converter: webidl.converters["unsigned long"],
11637        defaultValue: 0
11638      },
11639      {
11640        key: "colno",
11641        converter: webidl.converters["unsigned long"],
11642        defaultValue: 0
11643      },
11644      {
11645        key: "error",
11646        converter: webidl.converters.any
11647      }
11648    ]);
11649    module2.exports = {
11650      MessageEvent,
11651      CloseEvent,
11652      ErrorEvent
11653    };
11654  }
11655});
11656
11657// lib/websocket/util.js
11658var require_util3 = __commonJS({
11659  "lib/websocket/util.js"(exports2, module2) {
11660    "use strict";
11661    var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols3();
11662    var { states, opcodes } = require_constants4();
11663    var { MessageEvent, ErrorEvent } = require_events();
11664    function isEstablished(ws) {
11665      return ws[kReadyState] === states.OPEN;
11666    }
11667    __name(isEstablished, "isEstablished");
11668    function isClosing(ws) {
11669      return ws[kReadyState] === states.CLOSING;
11670    }
11671    __name(isClosing, "isClosing");
11672    function isClosed(ws) {
11673      return ws[kReadyState] === states.CLOSED;
11674    }
11675    __name(isClosed, "isClosed");
11676    function fireEvent(e, target, eventConstructor = Event, eventInitDict) {
11677      const event = new eventConstructor(e, eventInitDict);
11678      target.dispatchEvent(event);
11679    }
11680    __name(fireEvent, "fireEvent");
11681    function websocketMessageReceived(ws, type, data) {
11682      if (ws[kReadyState] !== states.OPEN) {
11683        return;
11684      }
11685      let dataForEvent;
11686      if (type === opcodes.TEXT) {
11687        try {
11688          dataForEvent = new TextDecoder("utf-8", { fatal: true }).decode(data);
11689        } catch {
11690          failWebsocketConnection(ws, "Received invalid UTF-8 in text frame.");
11691          return;
11692        }
11693      } else if (type === opcodes.BINARY) {
11694        if (ws[kBinaryType] === "blob") {
11695          dataForEvent = new Blob([data]);
11696        } else {
11697          dataForEvent = new Uint8Array(data).buffer;
11698        }
11699      }
11700      fireEvent("message", ws, MessageEvent, {
11701        origin: ws[kWebSocketURL].origin,
11702        data: dataForEvent
11703      });
11704    }
11705    __name(websocketMessageReceived, "websocketMessageReceived");
11706    function isValidSubprotocol(protocol) {
11707      if (protocol.length === 0) {
11708        return false;
11709      }
11710      for (const char of protocol) {
11711        const code = char.charCodeAt(0);
11712        if (code < 33 || code > 126 || char === "(" || char === ")" || char === "<" || char === ">" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}" || code === 32 || // SP
11713        code === 9) {
11714          return false;
11715        }
11716      }
11717      return true;
11718    }
11719    __name(isValidSubprotocol, "isValidSubprotocol");
11720    function isValidStatusCode(code) {
11721      if (code >= 1e3 && code < 1015) {
11722        return code !== 1004 && // reserved
11723        code !== 1005 && // "MUST NOT be set as a status code"
11724        code !== 1006;
11725      }
11726      return code >= 3e3 && code <= 4999;
11727    }
11728    __name(isValidStatusCode, "isValidStatusCode");
11729    function failWebsocketConnection(ws, reason) {
11730      const { [kController]: controller, [kResponse]: response } = ws;
11731      controller.abort();
11732      if (response?.socket && !response.socket.destroyed) {
11733        response.socket.destroy();
11734      }
11735      if (reason) {
11736        fireEvent("error", ws, ErrorEvent, {
11737          error: new Error(reason)
11738        });
11739      }
11740    }
11741    __name(failWebsocketConnection, "failWebsocketConnection");
11742    module2.exports = {
11743      isEstablished,
11744      isClosing,
11745      isClosed,
11746      fireEvent,
11747      isValidSubprotocol,
11748      isValidStatusCode,
11749      failWebsocketConnection,
11750      websocketMessageReceived
11751    };
11752  }
11753});
11754
11755// lib/websocket/connection.js
11756var require_connection = __commonJS({
11757  "lib/websocket/connection.js"(exports2, module2) {
11758    "use strict";
11759    var diagnosticsChannel = require("diagnostics_channel");
11760    var { uid, states } = require_constants4();
11761    var {
11762      kReadyState,
11763      kSentClose,
11764      kByteParser,
11765      kReceivedClose
11766    } = require_symbols3();
11767    var { fireEvent, failWebsocketConnection } = require_util3();
11768    var { CloseEvent } = require_events();
11769    var { makeRequest } = require_request();
11770    var { fetching } = require_fetch();
11771    var { Headers } = require_headers();
11772    var { getGlobalDispatcher } = require_global2();
11773    var { kHeadersList } = require_symbols();
11774    var channels = {};
11775    channels.open = diagnosticsChannel.channel("undici:websocket:open");
11776    channels.close = diagnosticsChannel.channel("undici:websocket:close");
11777    channels.socketError = diagnosticsChannel.channel("undici:websocket:socket_error");
11778    var crypto;
11779    try {
11780      crypto = require("crypto");
11781    } catch {
11782    }
11783    function establishWebSocketConnection(url, protocols, ws, onEstablish, options) {
11784      const requestURL = url;
11785      requestURL.protocol = url.protocol === "ws:" ? "http:" : "https:";
11786      const request = makeRequest({
11787        urlList: [requestURL],
11788        serviceWorkers: "none",
11789        referrer: "no-referrer",
11790        mode: "websocket",
11791        credentials: "include",
11792        cache: "no-store",
11793        redirect: "error"
11794      });
11795      if (options.headers) {
11796        const headersList = new Headers(options.headers)[kHeadersList];
11797        request.headersList = headersList;
11798      }
11799      const keyValue = crypto.randomBytes(16).toString("base64");
11800      request.headersList.append("sec-websocket-key", keyValue);
11801      request.headersList.append("sec-websocket-version", "13");
11802      for (const protocol of protocols) {
11803        request.headersList.append("sec-websocket-protocol", protocol);
11804      }
11805      const permessageDeflate = "";
11806      const controller = fetching({
11807        request,
11808        useParallelQueue: true,
11809        dispatcher: options.dispatcher ?? getGlobalDispatcher(),
11810        processResponse(response) {
11811          if (response.type === "error" || response.status !== 101) {
11812            failWebsocketConnection(ws, "Received network error or non-101 status code.");
11813            return;
11814          }
11815          if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) {
11816            failWebsocketConnection(ws, "Server did not respond with sent protocols.");
11817            return;
11818          }
11819          if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") {
11820            failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".');
11821            return;
11822          }
11823          if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") {
11824            failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".');
11825            return;
11826          }
11827          const secWSAccept = response.headersList.get("Sec-WebSocket-Accept");
11828          const digest = crypto.createHash("sha1").update(keyValue + uid).digest("base64");
11829          if (secWSAccept !== digest) {
11830            failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header.");
11831            return;
11832          }
11833          const secExtension = response.headersList.get("Sec-WebSocket-Extensions");
11834          if (secExtension !== null && secExtension !== permessageDeflate) {
11835            failWebsocketConnection(ws, "Received different permessage-deflate than the one set.");
11836            return;
11837          }
11838          const secProtocol = response.headersList.get("Sec-WebSocket-Protocol");
11839          if (secProtocol !== null && secProtocol !== request.headersList.get("Sec-WebSocket-Protocol")) {
11840            failWebsocketConnection(ws, "Protocol was not set in the opening handshake.");
11841            return;
11842          }
11843          response.socket.on("data", onSocketData);
11844          response.socket.on("close", onSocketClose);
11845          response.socket.on("error", onSocketError);
11846          if (channels.open.hasSubscribers) {
11847            channels.open.publish({
11848              address: response.socket.address(),
11849              protocol: secProtocol,
11850              extensions: secExtension
11851            });
11852          }
11853          onEstablish(response);
11854        }
11855      });
11856      return controller;
11857    }
11858    __name(establishWebSocketConnection, "establishWebSocketConnection");
11859    function onSocketData(chunk) {
11860      if (!this.ws[kByteParser].write(chunk)) {
11861        this.pause();
11862      }
11863    }
11864    __name(onSocketData, "onSocketData");
11865    function onSocketClose() {
11866      const { ws } = this;
11867      const wasClean = ws[kSentClose] && ws[kReceivedClose];
11868      let code = 1005;
11869      let reason = "";
11870      const result = ws[kByteParser].closingInfo;
11871      if (result) {
11872        code = result.code ?? 1005;
11873        reason = result.reason;
11874      } else if (!ws[kSentClose]) {
11875        code = 1006;
11876      }
11877      ws[kReadyState] = states.CLOSED;
11878      fireEvent("close", ws, CloseEvent, {
11879        wasClean,
11880        code,
11881        reason
11882      });
11883      if (channels.close.hasSubscribers) {
11884        channels.close.publish({
11885          websocket: ws,
11886          code,
11887          reason
11888        });
11889      }
11890    }
11891    __name(onSocketClose, "onSocketClose");
11892    function onSocketError(error) {
11893      const { ws } = this;
11894      ws[kReadyState] = states.CLOSING;
11895      if (channels.socketError.hasSubscribers) {
11896        channels.socketError.publish(error);
11897      }
11898      this.destroy();
11899    }
11900    __name(onSocketError, "onSocketError");
11901    module2.exports = {
11902      establishWebSocketConnection
11903    };
11904  }
11905});
11906
11907// lib/websocket/frame.js
11908var require_frame = __commonJS({
11909  "lib/websocket/frame.js"(exports2, module2) {
11910    "use strict";
11911    var { maxUnsigned16Bit } = require_constants4();
11912    var crypto;
11913    try {
11914      crypto = require("crypto");
11915    } catch {
11916    }
11917    var WebsocketFrameSend = class {
11918      static {
11919        __name(this, "WebsocketFrameSend");
11920      }
11921      /**
11922       * @param {Buffer|undefined} data
11923       */
11924      constructor(data) {
11925        this.frameData = data;
11926        this.maskKey = crypto.randomBytes(4);
11927      }
11928      createFrame(opcode) {
11929        const bodyLength = this.frameData?.byteLength ?? 0;
11930        let payloadLength = bodyLength;
11931        let offset = 6;
11932        if (bodyLength > maxUnsigned16Bit) {
11933          offset += 8;
11934          payloadLength = 127;
11935        } else if (bodyLength > 125) {
11936          offset += 2;
11937          payloadLength = 126;
11938        }
11939        const buffer = Buffer.allocUnsafe(bodyLength + offset);
11940        buffer[0] = buffer[1] = 0;
11941        buffer[0] |= 128;
11942        buffer[0] = (buffer[0] & 240) + opcode;
11943        buffer[offset - 4] = this.maskKey[0];
11944        buffer[offset - 3] = this.maskKey[1];
11945        buffer[offset - 2] = this.maskKey[2];
11946        buffer[offset - 1] = this.maskKey[3];
11947        buffer[1] = payloadLength;
11948        if (payloadLength === 126) {
11949          buffer.writeUInt16BE(bodyLength, 2);
11950        } else if (payloadLength === 127) {
11951          buffer[2] = buffer[3] = 0;
11952          buffer.writeUIntBE(bodyLength, 4, 6);
11953        }
11954        buffer[1] |= 128;
11955        for (let i = 0; i < bodyLength; i++) {
11956          buffer[offset + i] = this.frameData[i] ^ this.maskKey[i % 4];
11957        }
11958        return buffer;
11959      }
11960    };
11961    module2.exports = {
11962      WebsocketFrameSend
11963    };
11964  }
11965});
11966
11967// lib/websocket/receiver.js
11968var require_receiver = __commonJS({
11969  "lib/websocket/receiver.js"(exports2, module2) {
11970    "use strict";
11971    var { Writable } = require("stream");
11972    var diagnosticsChannel = require("diagnostics_channel");
11973    var { parserStates, opcodes, states, emptyBuffer } = require_constants4();
11974    var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols3();
11975    var { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require_util3();
11976    var { WebsocketFrameSend } = require_frame();
11977    var channels = {};
11978    channels.ping = diagnosticsChannel.channel("undici:websocket:ping");
11979    channels.pong = diagnosticsChannel.channel("undici:websocket:pong");
11980    var ByteParser = class extends Writable {
11981      static {
11982        __name(this, "ByteParser");
11983      }
11984      #buffers = [];
11985      #byteOffset = 0;
11986      #state = parserStates.INFO;
11987      #info = {};
11988      #fragments = [];
11989      constructor(ws) {
11990        super();
11991        this.ws = ws;
11992      }
11993      /**
11994       * @param {Buffer} chunk
11995       * @param {() => void} callback
11996       */
11997      _write(chunk, _, callback) {
11998        this.#buffers.push(chunk);
11999        this.#byteOffset += chunk.length;
12000        this.run(callback);
12001      }
12002      /**
12003       * Runs whenever a new chunk is received.
12004       * Callback is called whenever there are no more chunks buffering,
12005       * or not enough bytes are buffered to parse.
12006       */
12007      run(callback) {
12008        while (true) {
12009          if (this.#state === parserStates.INFO) {
12010            if (this.#byteOffset < 2) {
12011              return callback();
12012            }
12013            const buffer = this.consume(2);
12014            this.#info.fin = (buffer[0] & 128) !== 0;
12015            this.#info.opcode = buffer[0] & 15;
12016            this.#info.originalOpcode ??= this.#info.opcode;
12017            this.#info.fragmented = !this.#info.fin && this.#info.opcode !== opcodes.CONTINUATION;
12018            if (this.#info.fragmented && this.#info.opcode !== opcodes.BINARY && this.#info.opcode !== opcodes.TEXT) {
12019              failWebsocketConnection(this.ws, "Invalid frame type was fragmented.");
12020              return;
12021            }
12022            const payloadLength = buffer[1] & 127;
12023            if (payloadLength <= 125) {
12024              this.#info.payloadLength = payloadLength;
12025              this.#state = parserStates.READ_DATA;
12026            } else if (payloadLength === 126) {
12027              this.#state = parserStates.PAYLOADLENGTH_16;
12028            } else if (payloadLength === 127) {
12029              this.#state = parserStates.PAYLOADLENGTH_64;
12030            }
12031            if (this.#info.fragmented && payloadLength > 125) {
12032              failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes.");
12033              return;
12034            } else if ((this.#info.opcode === opcodes.PING || this.#info.opcode === opcodes.PONG || this.#info.opcode === opcodes.CLOSE) && payloadLength > 125) {
12035              failWebsocketConnection(this.ws, "Payload length for control frame exceeded 125 bytes.");
12036              return;
12037            } else if (this.#info.opcode === opcodes.CLOSE) {
12038              if (payloadLength === 1) {
12039                failWebsocketConnection(this.ws, "Received close frame with a 1-byte body.");
12040                return;
12041              }
12042              const body = this.consume(payloadLength);
12043              this.#info.closeInfo = this.parseCloseBody(false, body);
12044              if (!this.ws[kSentClose]) {
12045                const body2 = Buffer.allocUnsafe(2);
12046                body2.writeUInt16BE(this.#info.closeInfo.code, 0);
12047                const closeFrame = new WebsocketFrameSend(body2);
12048                this.ws[kResponse].socket.write(
12049                  closeFrame.createFrame(opcodes.CLOSE),
12050                  (err) => {
12051                    if (!err) {
12052                      this.ws[kSentClose] = true;
12053                    }
12054                  }
12055                );
12056              }
12057              this.ws[kReadyState] = states.CLOSING;
12058              this.ws[kReceivedClose] = true;
12059              this.end();
12060              return;
12061            } else if (this.#info.opcode === opcodes.PING) {
12062              const body = this.consume(payloadLength);
12063              if (!this.ws[kReceivedClose]) {
12064                const frame = new WebsocketFrameSend(body);
12065                this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG));
12066                if (channels.ping.hasSubscribers) {
12067                  channels.ping.publish({
12068                    payload: body
12069                  });
12070                }
12071              }
12072              this.#state = parserStates.INFO;
12073              if (this.#byteOffset > 0) {
12074                continue;
12075              } else {
12076                callback();
12077                return;
12078              }
12079            } else if (this.#info.opcode === opcodes.PONG) {
12080              const body = this.consume(payloadLength);
12081              if (channels.pong.hasSubscribers) {
12082                channels.pong.publish({
12083                  payload: body
12084                });
12085              }
12086              if (this.#byteOffset > 0) {
12087                continue;
12088              } else {
12089                callback();
12090                return;
12091              }
12092            }
12093          } else if (this.#state === parserStates.PAYLOADLENGTH_16) {
12094            if (this.#byteOffset < 2) {
12095              return callback();
12096            }
12097            const buffer = this.consume(2);
12098            this.#info.payloadLength = buffer.readUInt16BE(0);
12099            this.#state = parserStates.READ_DATA;
12100          } else if (this.#state === parserStates.PAYLOADLENGTH_64) {
12101            if (this.#byteOffset < 8) {
12102              return callback();
12103            }
12104            const buffer = this.consume(8);
12105            const upper = buffer.readUInt32BE(0);
12106            if (upper > 2 ** 31 - 1) {
12107              failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes.");
12108              return;
12109            }
12110            const lower = buffer.readUInt32BE(4);
12111            this.#info.payloadLength = (upper << 8) + lower;
12112            this.#state = parserStates.READ_DATA;
12113          } else if (this.#state === parserStates.READ_DATA) {
12114            if (this.#byteOffset < this.#info.payloadLength) {
12115              return callback();
12116            } else if (this.#byteOffset >= this.#info.payloadLength) {
12117              const body = this.consume(this.#info.payloadLength);
12118              this.#fragments.push(body);
12119              if (!this.#info.fragmented || this.#info.fin && this.#info.opcode === opcodes.CONTINUATION) {
12120                const fullMessage = Buffer.concat(this.#fragments);
12121                websocketMessageReceived(this.ws, this.#info.originalOpcode, fullMessage);
12122                this.#info = {};
12123                this.#fragments.length = 0;
12124              }
12125              this.#state = parserStates.INFO;
12126            }
12127          }
12128          if (this.#byteOffset > 0) {
12129            continue;
12130          } else {
12131            callback();
12132            break;
12133          }
12134        }
12135      }
12136      /**
12137       * Take n bytes from the buffered Buffers
12138       * @param {number} n
12139       * @returns {Buffer|null}
12140       */
12141      consume(n) {
12142        if (n > this.#byteOffset) {
12143          return null;
12144        } else if (n === 0) {
12145          return emptyBuffer;
12146        }
12147        if (this.#buffers[0].length === n) {
12148          this.#byteOffset -= this.#buffers[0].length;
12149          return this.#buffers.shift();
12150        }
12151        const buffer = Buffer.allocUnsafe(n);
12152        let offset = 0;
12153        while (offset !== n) {
12154          const next = this.#buffers[0];
12155          const { length } = next;
12156          if (length + offset === n) {
12157            buffer.set(this.#buffers.shift(), offset);
12158            break;
12159          } else if (length + offset > n) {
12160            buffer.set(next.subarray(0, n - offset), offset);
12161            this.#buffers[0] = next.subarray(n - offset);
12162            break;
12163          } else {
12164            buffer.set(this.#buffers.shift(), offset);
12165            offset += next.length;
12166          }
12167        }
12168        this.#byteOffset -= n;
12169        return buffer;
12170      }
12171      parseCloseBody(onlyCode, data) {
12172        let code;
12173        if (data.length >= 2) {
12174          code = data.readUInt16BE(0);
12175        }
12176        if (onlyCode) {
12177          if (!isValidStatusCode(code)) {
12178            return null;
12179          }
12180          return { code };
12181        }
12182        let reason = data.subarray(2);
12183        if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) {
12184          reason = reason.subarray(3);
12185        }
12186        if (code !== void 0 && !isValidStatusCode(code)) {
12187          return null;
12188        }
12189        try {
12190          reason = new TextDecoder("utf-8", { fatal: true }).decode(reason);
12191        } catch {
12192          return null;
12193        }
12194        return { code, reason };
12195      }
12196      get closingInfo() {
12197        return this.#info.closeInfo;
12198      }
12199    };
12200    module2.exports = {
12201      ByteParser
12202    };
12203  }
12204});
12205
12206// lib/websocket/websocket.js
12207var require_websocket = __commonJS({
12208  "lib/websocket/websocket.js"(exports2, module2) {
12209    "use strict";
12210    var { webidl } = require_webidl();
12211    var { DOMException } = require_constants2();
12212    var { URLSerializer } = require_dataURL();
12213    var { getGlobalOrigin } = require_global();
12214    var { staticPropertyDescriptors, states, opcodes, emptyBuffer } = require_constants4();
12215    var {
12216      kWebSocketURL,
12217      kReadyState,
12218      kController,
12219      kBinaryType,
12220      kResponse,
12221      kSentClose,
12222      kByteParser
12223    } = require_symbols3();
12224    var { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = require_util3();
12225    var { establishWebSocketConnection } = require_connection();
12226    var { WebsocketFrameSend } = require_frame();
12227    var { ByteParser } = require_receiver();
12228    var { kEnumerableProperty, isBlobLike } = require_util();
12229    var { getGlobalDispatcher } = require_global2();
12230    var { types } = require("util");
12231    var experimentalWarned = false;
12232    var WebSocket = class _WebSocket extends EventTarget {
12233      static {
12234        __name(this, "WebSocket");
12235      }
12236      #events = {
12237        open: null,
12238        error: null,
12239        close: null,
12240        message: null
12241      };
12242      #bufferedAmount = 0;
12243      #protocol = "";
12244      #extensions = "";
12245      /**
12246       * @param {string} url
12247       * @param {string|string[]} protocols
12248       */
12249      constructor(url, protocols = []) {
12250        super();
12251        webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket constructor" });
12252        if (!experimentalWarned) {
12253          experimentalWarned = true;
12254          process.emitWarning("WebSockets are experimental, expect them to change at any time.", {
12255            code: "UNDICI-WS"
12256          });
12257        }
12258        const options = webidl.converters["DOMString or sequence<DOMString> or WebSocketInit"](protocols);
12259        url = webidl.converters.USVString(url);
12260        protocols = options.protocols;
12261        const baseURL = getGlobalOrigin();
12262        let urlRecord;
12263        try {
12264          urlRecord = new URL(url, baseURL);
12265        } catch (e) {
12266          throw new DOMException(e, "SyntaxError");
12267        }
12268        if (urlRecord.protocol === "http:") {
12269          urlRecord.protocol = "ws:";
12270        } else if (urlRecord.protocol === "https:") {
12271          urlRecord.protocol = "wss:";
12272        }
12273        if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") {
12274          throw new DOMException(
12275            `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
12276            "SyntaxError"
12277          );
12278        }
12279        if (urlRecord.hash || urlRecord.href.endsWith("#")) {
12280          throw new DOMException("Got fragment", "SyntaxError");
12281        }
12282        if (typeof protocols === "string") {
12283          protocols = [protocols];
12284        }
12285        if (protocols.length !== new Set(protocols.map((p) => p.toLowerCase())).size) {
12286          throw new DOMException("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
12287        }
12288        if (protocols.length > 0 && !protocols.every((p) => isValidSubprotocol(p))) {
12289          throw new DOMException("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
12290        }
12291        this[kWebSocketURL] = new URL(urlRecord.href);
12292        this[kController] = establishWebSocketConnection(
12293          urlRecord,
12294          protocols,
12295          this,
12296          (response) => this.#onConnectionEstablished(response),
12297          options
12298        );
12299        this[kReadyState] = _WebSocket.CONNECTING;
12300        this[kBinaryType] = "blob";
12301      }
12302      /**
12303       * @see https://websockets.spec.whatwg.org/#dom-websocket-close
12304       * @param {number|undefined} code
12305       * @param {string|undefined} reason
12306       */
12307      close(code = void 0, reason = void 0) {
12308        webidl.brandCheck(this, _WebSocket);
12309        if (code !== void 0) {
12310          code = webidl.converters["unsigned short"](code, { clamp: true });
12311        }
12312        if (reason !== void 0) {
12313          reason = webidl.converters.USVString(reason);
12314        }
12315        if (code !== void 0) {
12316          if (code !== 1e3 && (code < 3e3 || code > 4999)) {
12317            throw new DOMException("invalid code", "InvalidAccessError");
12318          }
12319        }
12320        let reasonByteLength = 0;
12321        if (reason !== void 0) {
12322          reasonByteLength = Buffer.byteLength(reason);
12323          if (reasonByteLength > 123) {
12324            throw new DOMException(
12325              `Reason must be less than 123 bytes; received ${reasonByteLength}`,
12326              "SyntaxError"
12327            );
12328          }
12329        }
12330        if (this[kReadyState] === _WebSocket.CLOSING || this[kReadyState] === _WebSocket.CLOSED) {
12331        } else if (!isEstablished(this)) {
12332          failWebsocketConnection(this, "Connection was closed before it was established.");
12333          this[kReadyState] = _WebSocket.CLOSING;
12334        } else if (!isClosing(this)) {
12335          const frame = new WebsocketFrameSend();
12336          if (code !== void 0 && reason === void 0) {
12337            frame.frameData = Buffer.allocUnsafe(2);
12338            frame.frameData.writeUInt16BE(code, 0);
12339          } else if (code !== void 0 && reason !== void 0) {
12340            frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength);
12341            frame.frameData.writeUInt16BE(code, 0);
12342            frame.frameData.write(reason, 2, "utf-8");
12343          } else {
12344            frame.frameData = emptyBuffer;
12345          }
12346          const socket = this[kResponse].socket;
12347          socket.write(frame.createFrame(opcodes.CLOSE), (err) => {
12348            if (!err) {
12349              this[kSentClose] = true;
12350            }
12351          });
12352          this[kReadyState] = states.CLOSING;
12353        } else {
12354          this[kReadyState] = _WebSocket.CLOSING;
12355        }
12356      }
12357      /**
12358       * @see https://websockets.spec.whatwg.org/#dom-websocket-send
12359       * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data
12360       */
12361      send(data) {
12362        webidl.brandCheck(this, _WebSocket);
12363        webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket.send" });
12364        data = webidl.converters.WebSocketSendData(data);
12365        if (this[kReadyState] === _WebSocket.CONNECTING) {
12366          throw new DOMException("Sent before connected.", "InvalidStateError");
12367        }
12368        if (!isEstablished(this) || isClosing(this)) {
12369          return;
12370        }
12371        const socket = this[kResponse].socket;
12372        if (typeof data === "string") {
12373          const value = Buffer.from(data);
12374          const frame = new WebsocketFrameSend(value);
12375          const buffer = frame.createFrame(opcodes.TEXT);
12376          this.#bufferedAmount += value.byteLength;
12377          socket.write(buffer, () => {
12378            this.#bufferedAmount -= value.byteLength;
12379          });
12380        } else if (types.isArrayBuffer(data)) {
12381          const value = Buffer.from(data);
12382          const frame = new WebsocketFrameSend(value);
12383          const buffer = frame.createFrame(opcodes.BINARY);
12384          this.#bufferedAmount += value.byteLength;
12385          socket.write(buffer, () => {
12386            this.#bufferedAmount -= value.byteLength;
12387          });
12388        } else if (ArrayBuffer.isView(data)) {
12389          const ab = Buffer.from(data, data.byteOffset, data.byteLength);
12390          const frame = new WebsocketFrameSend(ab);
12391          const buffer = frame.createFrame(opcodes.BINARY);
12392          this.#bufferedAmount += ab.byteLength;
12393          socket.write(buffer, () => {
12394            this.#bufferedAmount -= ab.byteLength;
12395          });
12396        } else if (isBlobLike(data)) {
12397          const frame = new WebsocketFrameSend();
12398          data.arrayBuffer().then((ab) => {
12399            const value = Buffer.from(ab);
12400            frame.frameData = value;
12401            const buffer = frame.createFrame(opcodes.BINARY);
12402            this.#bufferedAmount += value.byteLength;
12403            socket.write(buffer, () => {
12404              this.#bufferedAmount -= value.byteLength;
12405            });
12406          });
12407        }
12408      }
12409      get readyState() {
12410        webidl.brandCheck(this, _WebSocket);
12411        return this[kReadyState];
12412      }
12413      get bufferedAmount() {
12414        webidl.brandCheck(this, _WebSocket);
12415        return this.#bufferedAmount;
12416      }
12417      get url() {
12418        webidl.brandCheck(this, _WebSocket);
12419        return URLSerializer(this[kWebSocketURL]);
12420      }
12421      get extensions() {
12422        webidl.brandCheck(this, _WebSocket);
12423        return this.#extensions;
12424      }
12425      get protocol() {
12426        webidl.brandCheck(this, _WebSocket);
12427        return this.#protocol;
12428      }
12429      get onopen() {
12430        webidl.brandCheck(this, _WebSocket);
12431        return this.#events.open;
12432      }
12433      set onopen(fn) {
12434        webidl.brandCheck(this, _WebSocket);
12435        if (this.#events.open) {
12436          this.removeEventListener("open", this.#events.open);
12437        }
12438        if (typeof fn === "function") {
12439          this.#events.open = fn;
12440          this.addEventListener("open", fn);
12441        } else {
12442          this.#events.open = null;
12443        }
12444      }
12445      get onerror() {
12446        webidl.brandCheck(this, _WebSocket);
12447        return this.#events.error;
12448      }
12449      set onerror(fn) {
12450        webidl.brandCheck(this, _WebSocket);
12451        if (this.#events.error) {
12452          this.removeEventListener("error", this.#events.error);
12453        }
12454        if (typeof fn === "function") {
12455          this.#events.error = fn;
12456          this.addEventListener("error", fn);
12457        } else {
12458          this.#events.error = null;
12459        }
12460      }
12461      get onclose() {
12462        webidl.brandCheck(this, _WebSocket);
12463        return this.#events.close;
12464      }
12465      set onclose(fn) {
12466        webidl.brandCheck(this, _WebSocket);
12467        if (this.#events.close) {
12468          this.removeEventListener("close", this.#events.close);
12469        }
12470        if (typeof fn === "function") {
12471          this.#events.close = fn;
12472          this.addEventListener("close", fn);
12473        } else {
12474          this.#events.close = null;
12475        }
12476      }
12477      get onmessage() {
12478        webidl.brandCheck(this, _WebSocket);
12479        return this.#events.message;
12480      }
12481      set onmessage(fn) {
12482        webidl.brandCheck(this, _WebSocket);
12483        if (this.#events.message) {
12484          this.removeEventListener("message", this.#events.message);
12485        }
12486        if (typeof fn === "function") {
12487          this.#events.message = fn;
12488          this.addEventListener("message", fn);
12489        } else {
12490          this.#events.message = null;
12491        }
12492      }
12493      get binaryType() {
12494        webidl.brandCheck(this, _WebSocket);
12495        return this[kBinaryType];
12496      }
12497      set binaryType(type) {
12498        webidl.brandCheck(this, _WebSocket);
12499        if (type !== "blob" && type !== "arraybuffer") {
12500          this[kBinaryType] = "blob";
12501        } else {
12502          this[kBinaryType] = type;
12503        }
12504      }
12505      /**
12506       * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
12507       */
12508      #onConnectionEstablished(response) {
12509        this[kResponse] = response;
12510        const parser = new ByteParser(this);
12511        parser.on("drain", /* @__PURE__ */ __name(function onParserDrain() {
12512          this.ws[kResponse].socket.resume();
12513        }, "onParserDrain"));
12514        response.socket.ws = this;
12515        this[kByteParser] = parser;
12516        this[kReadyState] = states.OPEN;
12517        const extensions = response.headersList.get("sec-websocket-extensions");
12518        if (extensions !== null) {
12519          this.#extensions = extensions;
12520        }
12521        const protocol = response.headersList.get("sec-websocket-protocol");
12522        if (protocol !== null) {
12523          this.#protocol = protocol;
12524        }
12525        fireEvent("open", this);
12526      }
12527    };
12528    WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING;
12529    WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN;
12530    WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING;
12531    WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED;
12532    Object.defineProperties(WebSocket.prototype, {
12533      CONNECTING: staticPropertyDescriptors,
12534      OPEN: staticPropertyDescriptors,
12535      CLOSING: staticPropertyDescriptors,
12536      CLOSED: staticPropertyDescriptors,
12537      url: kEnumerableProperty,
12538      readyState: kEnumerableProperty,
12539      bufferedAmount: kEnumerableProperty,
12540      onopen: kEnumerableProperty,
12541      onerror: kEnumerableProperty,
12542      onclose: kEnumerableProperty,
12543      close: kEnumerableProperty,
12544      onmessage: kEnumerableProperty,
12545      binaryType: kEnumerableProperty,
12546      send: kEnumerableProperty,
12547      extensions: kEnumerableProperty,
12548      protocol: kEnumerableProperty,
12549      [Symbol.toStringTag]: {
12550        value: "WebSocket",
12551        writable: false,
12552        enumerable: false,
12553        configurable: true
12554      }
12555    });
12556    Object.defineProperties(WebSocket, {
12557      CONNECTING: staticPropertyDescriptors,
12558      OPEN: staticPropertyDescriptors,
12559      CLOSING: staticPropertyDescriptors,
12560      CLOSED: staticPropertyDescriptors
12561    });
12562    webidl.converters["sequence<DOMString>"] = webidl.sequenceConverter(
12563      webidl.converters.DOMString
12564    );
12565    webidl.converters["DOMString or sequence<DOMString>"] = function(V) {
12566      if (webidl.util.Type(V) === "Object" && Symbol.iterator in V) {
12567        return webidl.converters["sequence<DOMString>"](V);
12568      }
12569      return webidl.converters.DOMString(V);
12570    };
12571    webidl.converters.WebSocketInit = webidl.dictionaryConverter([
12572      {
12573        key: "protocols",
12574        converter: webidl.converters["DOMString or sequence<DOMString>"],
12575        get defaultValue() {
12576          return [];
12577        }
12578      },
12579      {
12580        key: "dispatcher",
12581        converter: (V) => V,
12582        get defaultValue() {
12583          return getGlobalDispatcher();
12584        }
12585      },
12586      {
12587        key: "headers",
12588        converter: webidl.nullableConverter(webidl.converters.HeadersInit)
12589      }
12590    ]);
12591    webidl.converters["DOMString or sequence<DOMString> or WebSocketInit"] = function(V) {
12592      if (webidl.util.Type(V) === "Object" && !(Symbol.iterator in V)) {
12593        return webidl.converters.WebSocketInit(V);
12594      }
12595      return { protocols: webidl.converters["DOMString or sequence<DOMString>"](V) };
12596    };
12597    webidl.converters.WebSocketSendData = function(V) {
12598      if (webidl.util.Type(V) === "Object") {
12599        if (isBlobLike(V)) {
12600          return webidl.converters.Blob(V, { strict: false });
12601        }
12602        if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) {
12603          return webidl.converters.BufferSource(V);
12604        }
12605      }
12606      return webidl.converters.USVString(V);
12607    };
12608    module2.exports = {
12609      WebSocket
12610    };
12611  }
12612});
12613
12614// index-fetch.js
12615var fetchImpl = require_fetch().fetch;
12616module.exports.fetch = /* @__PURE__ */ __name(function fetch(resource, init = void 0) {
12617  return fetchImpl(resource, init).catch((err) => {
12618    Error.captureStackTrace(err, this);
12619    throw err;
12620  });
12621}, "fetch");
12622module.exports.FormData = require_formdata().FormData;
12623module.exports.Headers = require_headers().Headers;
12624module.exports.Response = require_response().Response;
12625module.exports.Request = require_request().Request;
12626module.exports.WebSocket = require_websocket().WebSocket;
12627/*! Bundled license information:
12628
12629undici/lib/fetch/body.js:
12630  (*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)
12631
12632undici/lib/websocket/frame.js:
12633  (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
12634*/
12635