actions/setup-uv
2
0
Fork 0
mirror of https://github.com/astral-sh/setup-uv.git synced 2026-11-05 01:35:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore(deps): roll up Dependabot updates (#994)

Browse Source 
## Summary

Roll up the remaining net changes from the open Dependabot updates:

- release-drafter/release-drafter 7.7.0 (#990)
- github/codeql-action 4.37.4 (#987, #988, #989)
- zizmorcore/zizmor-action 0.6.1 (#986)
- @actions/cache 6.2.0 (#975)
- @biomejs/biome 2.5.4 (#974)
- undici 8.7.0 (#973)

The Jest 30.4.2 (#905) and @renovatebot/pep440 5.0.0 (#907) updates are
already present on main and require no additional changes.

This also updates the Biome schema, applies the formatter changes from
Biome 2.5.4, and regenerates the published bundles.

## Testing

- `npm run all`
- `actionlint`
- `git diff --check`

Refs: pi-session 019ff01b-f917-73c1-950e-2966956f263c
This commit is contained in:
Kevin Stillhammer
2026-08-11 11:27:16 +02:00
committed by GitHub
parent 18d451d679
commit 8473c7fea4
12 changed files with 1623 additions and 573 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dist/update-known-checksums/index.cjs
Generated Vendored
+715 -221
View File
@@ -20394,6 +20394,22 @@ var require_errors2 = __commonJS({
return true;
}
};
var kProxyConnectionError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_PRX_CONN");
var ProxyConnectionError = class extends UndiciError {
constructor(cause, message, options = {}) {
super(message, { cause, ...options });
this.name = "ProxyConnectionError";
this.message = message || "Proxy Connection failed";
this.code = "UND_ERR_PRX_CONN";
this.cause = cause;
}
static [Symbol.hasInstance](instance) {
return instance && instance[kProxyConnectionError] === true;
}
get [kProxyConnectionError]() {
return true;
}
};
var kMaxOriginsReachedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_MAX_ORIGINS_REACHED");
var MaxOriginsReachedError = class extends UndiciError {
constructor(message) {
@@ -20455,6 +20471,7 @@ var require_errors2 = __commonJS({
RequestRetryError,
ResponseError,
SecureProxyConnectionError,
ProxyConnectionError,
MaxOriginsReachedError,
Socks5ProxyError,
MessageSizeExceededError
@@ -21100,9 +21117,8 @@ var require_util9 = __commonJS({
return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData";
}
function addAbortListener(signal, listener) {
if (signal instanceof AbortSignal) {
const disposable = addAbortListenerNative(signal, listener);
return () => disposable[Symbol.dispose]();
if (!signal || "aborted" in signal) {
return addAbortListenerNative(signal, listener)[Symbol.dispose];
}
if (typeof signal.addEventListener === "function") {
signal.addEventListener("abort", listener, { once: true });
@@ -21406,7 +21422,8 @@ var require_util9 = __commonJS({
var rangeHeaderRegex = /^bytes (\d+)-(\d+)\/(\d+|\*)?$/;
function parseRangeHeader(range) {
if (range == null || range === "") return { start: 0, end: null, size: null };
const m = range ? range.match(rangeHeaderRegex) : null;
if (!range) return null;
const m = rangeHeaderRegex.exec(range);
return m ? {
start: parseInt(m[1]),
end: m[2] ? parseInt(m[2]) : null,
@@ -21480,7 +21497,18 @@ var require_util9 = __commonJS({
message += ` timeout: ${opts.timeout}ms)`;
destroy(socket, new ConnectTimeoutError(message));
}
var lastUrlString = null;
var lastProtocol = null;
function getProtocolFromUrlString(urlString) {
if (urlString === lastUrlString) {
return lastProtocol;
}
const protocol = getProtocolFromUrlStringSlow(urlString);
lastUrlString = urlString;
lastProtocol = protocol;
return protocol;
}
function getProtocolFromUrlStringSlow(urlString) {
if (urlString[0] === "h" && urlString[1] === "t" && urlString[2] === "t" && urlString[3] === "p") {
switch (urlString[4]) {
case ":":
@@ -21493,8 +21521,10 @@ var require_util9 = __commonJS({
}
return urlString.slice(0, urlString.indexOf(":") + 1);
}
var kEnumerableProperty = /* @__PURE__ */ Object.create(null);
kEnumerableProperty.enumerable = true;
var kEnumerableProperty = {
__proto__: null,
enumerable: true
};
var normalizedMethodRecordsBase = {
delete: "DELETE",
DELETE: "DELETE",
@@ -21507,7 +21537,9 @@ var require_util9 = __commonJS({
post: "POST",
POST: "POST",
put: "PUT",
PUT: "PUT"
PUT: "PUT",
query: "QUERY",
QUERY: "QUERY"
};
var normalizedMethodRecords = {
...normalizedMethodRecordsBase,
@@ -21998,7 +22030,7 @@ var require_request3 = __commonJS({
this.path = query ? serializePathWithQuery(path, query) : path;
this.origin = origin;
this.protocol = getProtocolFromUrlString(origin);
this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" || method === "QUERY" : idempotent;
this.blocking = blocking ?? this.method !== "HEAD";
this.reset = reset == null ? null : reset;
this.host = null;
@@ -22324,6 +22356,7 @@ var require_dispatcher_base2 = __commonJS({
*/
get webSocketOptions() {
return {
maxFragments: this[kWebSocketOptions].maxFragments ?? 131072,
maxPayloadSize: this[kWebSocketOptions].maxPayloadSize ?? 128 * 1024 * 1024
// 128 MB default
};
@@ -22448,7 +22481,7 @@ var require_connect2 = __commonJS({
var net = require("node:net");
var assert = require("node:assert");
var util = require_util9();
var { InvalidArgumentError } = require_errors2();
var { InvalidArgumentError, ConnectTimeoutError } = require_errors2();
var tls;
var SessionCache = class WeakSessionCache {
constructor(maxCachedSessions) {
@@ -22490,7 +22523,7 @@ var require_connect2 = __commonJS({
this._sessionRegistry.register(session, sessionKey);
}
};
function buildConnector({ allowH2, useH2c, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
function buildConnector({ allowH2, preferH2, useH2c, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero");
}
@@ -22516,7 +22549,7 @@ var require_connect2 = __commonJS({
servername,
session,
localAddress,
ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"],
ALPNProtocols: allowH2 ? preferH2 ? ["h2", "http/1.1"] : ["http/1.1", "h2"] : ["http/1.1"],
socket: httpSocket,
// upgrade socket connection
port,
@@ -22557,12 +22590,27 @@ var require_connect2 = __commonJS({
if (callback) {
const cb = callback;
callback = null;
cb(err);
cb(maybeNormalizeConnectError(err, this, { timeout, hostname, port }));
}
});
return socket;
};
}
function maybeNormalizeConnectError(err, socket, opts) {
if (err instanceof AggregateError && (err.code === "ETIMEDOUT" || err.errors.some((e) => e != null && e.code === "ETIMEDOUT"))) {
let message = "Connect Timeout Error";
if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(", ")},`;
} else {
message += ` (attempted address: ${opts.hostname}:${opts.port},`;
}
message += ` timeout: ${opts.timeout}ms)`;
const wrapped = new ConnectTimeoutError(message);
wrapped.cause = err;
return wrapped;
}
return err;
}
module2.exports = buildConnector;
}
});
@@ -23369,7 +23417,7 @@ var require_constants8 = __commonJS({
);
var safeMethods = (
/** @type {const} */
["GET", "HEAD", "OPTIONS", "TRACE"]
["GET", "HEAD", "OPTIONS", "TRACE", "QUERY"]
);
var safeMethodsSet = new Set(safeMethods);
var requestMode = (
@@ -25091,7 +25139,7 @@ var require_util10 = __commonJS({
if (rangeEndValue === null && rangeStartValue === null) {
return "failure";
}
if (rangeStartValue > rangeEndValue) {
if (rangeStartValue !== null && rangeEndValue !== null && rangeStartValue > rangeEndValue) {
return "failure";
}
return { rangeStartValue, rangeEndValue };
@@ -26081,6 +26129,29 @@ Content-Type: ${value.type || "application/octet-stream"}\r
return consumeBody(this, (bytes) => {
return new Uint8Array(bytes);
}, instance, getInternalState);
},
textStream() {
const this_ = getInternalState(this);
if (bodyUnusable(this_)) {
throw new TypeError("Body is unusable: Body has already been read");
}
if (this_.body == null) {
let controller;
const emptyStream = new ReadableStream({
start: (c) => {
controller = c;
},
pull: () => Promise.resolve(),
cancel: () => Promise.resolve()
}, {
size: () => 1
});
controller.close();
return emptyStream;
}
const stream = this_.body.stream;
const decoder = new TextDecoderStream("UTF-8");
return stream.pipeThrough(decoder);
}
};
return methods;
@@ -26195,6 +26266,9 @@ var require_client_h12 = __commonJS({
var EMPTY_BUF = Buffer.alloc(0);
var FastBuffer = Buffer[Symbol.species];
var removeAllListeners = util.removeAllListeners;
var kIdleSocketValidation = /* @__PURE__ */ Symbol("kIdleSocketValidation");
var kIdleSocketValidationTimeout = /* @__PURE__ */ Symbol("kIdleSocketValidationTimeout");
var kSocketUsed = /* @__PURE__ */ Symbol("kSocketUsed");
var extractBody;
function lazyllhttp() {
const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm2() : void 0;
@@ -26435,8 +26509,20 @@ var require_client_h12 = __commonJS({
finish() {
assert(currentParser === null);
assert(this.ptr != null);
assert(!this.paused);
const { llhttp } = this;
if (this.paused) {
let data;
do {
llhttp.llhttp_resume(this.ptr);
this.paused = false;
data = this.socket.read() || EMPTY_BUF;
this.execute(data);
} while (this.paused && data.length > 0);
if (this.paused) {
llhttp.llhttp_resume(this.ptr);
this.paused = false;
}
}
let ret;
try {
currentParser = this;
@@ -26493,6 +26579,10 @@ var require_client_h12 = __commonJS({
if (socket.destroyed) {
return -1;
}
if (client[kRunning] === 0) {
util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
return -1;
}
const request = client[kQueue][client[kRunningIdx]];
if (!request) {
return -1;
@@ -26600,6 +26690,10 @@ var require_client_h12 = __commonJS({
if (socket.destroyed) {
return -1;
}
if (client[kRunning] === 0) {
util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
return -1;
}
const request = client[kQueue][client[kRunningIdx]];
if (!request) {
return -1;
@@ -26733,6 +26827,7 @@ var require_client_h12 = __commonJS({
}
request.onResponseEnd(headers);
client[kQueue][client[kRunningIdx]++] = null;
socket[kSocketUsed] = client[kPending] === 0;
if (socket[kWriting]) {
assert(client[kRunning] === 0);
util.destroy(socket, new InformationalError("reset"));
@@ -26786,6 +26881,9 @@ var require_client_h12 = __commonJS({
socket[kWriting] = false;
socket[kReset] = false;
socket[kBlocking] = false;
socket[kIdleSocketValidation] = 0;
socket[kIdleSocketValidationTimeout] = null;
socket[kSocketUsed] = false;
socket[kParser] = new Parser(client, socket, llhttpInstance);
util.addListener(socket, "error", onHttpSocketError);
util.addListener(socket, "readable", onHttpSocketReadable);
@@ -26825,7 +26923,7 @@ var require_client_h12 = __commonJS({
* @returns {boolean}
*/
busy(request) {
if (socket[kWriting] || socket[kReset] || socket[kBlocking]) {
if (socket[kWriting] || socket[kReset] || socket[kBlocking] || socket[kIdleSocketValidation] === 1) {
return true;
}
if (request) {
@@ -26873,6 +26971,7 @@ var require_client_h12 = __commonJS({
}
function onHttpSocketClose() {
const parser = this[kParser];
clearIdleSocketValidation(this);
if (parser) {
if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
this[kError] = parser.finish() || this[kError];
@@ -26904,6 +27003,24 @@ var require_client_h12 = __commonJS({
function onSocketClose() {
this[kClosed] = true;
}
function clearIdleSocketValidation(socket) {
if (socket[kIdleSocketValidationTimeout]) {
clearTimeout(socket[kIdleSocketValidationTimeout]);
socket[kIdleSocketValidationTimeout] = null;
}
socket[kIdleSocketValidation] = 0;
}
function scheduleIdleSocketValidation(client, socket) {
socket[kIdleSocketValidation] = 1;
socket[kIdleSocketValidationTimeout] = setTimeout(() => {
socket[kIdleSocketValidationTimeout] = null;
socket[kIdleSocketValidation] = 2;
if (client[kSocket] === socket && !socket.destroyed) {
client[kResume]();
}
}, 0);
socket[kIdleSocketValidationTimeout].unref?.();
}
function resumeH1(client) {
const socket = client[kSocket];
if (socket && !socket.destroyed) {
@@ -26916,6 +27033,29 @@ var require_client_h12 = __commonJS({
socket.ref();
socket[kNoRef] = false;
}
if (client[kRunning] === 0 && client[kPending] > 0 && socket[kSocketUsed]) {
if (socket[kIdleSocketValidation] === 0) {
scheduleIdleSocketValidation(client, socket);
socket[kParser].readMore();
if (socket.destroyed) {
return;
}
return;
}
if (socket[kIdleSocketValidation] === 1) {
socket[kParser].readMore();
if (socket.destroyed) {
return;
}
return;
}
}
if (client[kRunning] === 0) {
socket[kParser].readMore();
if (socket.destroyed) {
return;
}
}
if (client[kSize] === 0) {
if (socket[kParser].timeoutType !== TIMEOUT_KEEP_ALIVE) {
socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_KEEP_ALIVE);
@@ -26968,6 +27108,7 @@ var require_client_h12 = __commonJS({
process.emitWarning(new RequestContentLengthMismatchError());
}
const socket = client[kSocket];
clearIdleSocketValidation(socket);
const abort = (err) => {
if (request.aborted || request.completed) {
return;
@@ -27359,7 +27500,9 @@ var require_client_h22 = __commonJS({
RequestAbortedError,
SocketError,
InformationalError,
InvalidArgumentError
InvalidArgumentError,
HeadersTimeoutError,
BodyTimeoutError
} = require_errors2();
var {
kUrl,
@@ -27384,6 +27527,8 @@ var require_client_h22 = __commonJS({
kSize,
kHTTPContext,
kClosed,
kKeepAliveDefaultTimeout,
kHeadersTimeout,
kBodyTimeout,
kEnableConnectProtocol,
kRemoteSettings,
@@ -27421,6 +27566,25 @@ var require_client_h22 = __commonJS({
function getGoAwayError(session, errorCode) {
return session[kError] || (errorCode === NGHTTP2_NO_ERROR ? new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${errorCode}`) : new SocketError(`HTTP/2: "GOAWAY" frame received with code ${errorCode}`, util.getSocketInfo(session[kSocket])));
}
function resetHttp2Session(session, err) {
const client = session[kClient];
const socket = session[kSocket];
if (client[kHTTP2Session] === session) {
client[kSocket] = null;
client[kHTTPContext] = null;
client[kHTTP2Session] = null;
}
if (socket != null && socket[kError] == null) {
socket[kError] = err;
}
if (!session.closed && !session.destroyed) {
try {
session.destroy(err);
} catch {
}
}
util.destroy(socket, err);
}
function getGoAwayPendingIdx(client, lastStreamID) {
const maxAcceptedStreamID = Number.isInteger(lastStreamID) ? lastStreamID : Number.MAX_SAFE_INTEGER;
for (let i = client[kRunningIdx]; i < client[kPendingIdx]; i++) {
@@ -27454,13 +27618,31 @@ var require_client_h22 = __commonJS({
detachRequestFromStream(request);
cleanup?.(stream);
}
function requeueUnsentRequest(client, request) {
client[kQueue].splice(client[kPendingIdx] + 1, 0, request);
}
function completeRequest(client, request, resetPendingIdx = false) {
const queue = client[kQueue];
const runningIdx = client[kRunningIdx];
if (runningIdx < client[kPendingIdx] && queue[runningIdx] === request) {
client[kRunningIdx] = runningIdx + 1;
return;
}
const index = queue.indexOf(request, runningIdx);
if (index === -1 || index >= client[kPendingIdx]) {
return;
}
queue.splice(index, 1);
client[kPendingIdx]--;
if (resetPendingIdx && client[kPendingIdx] < client[kRunningIdx]) {
client[kPendingIdx] = client[kRunningIdx];
}
}
function canRetryRequestAfterGoAway(request) {
const { body } = request;
return body == null || util.isBuffer(body) || util.isBlobLike(body);
}
function closeRequestStream(request, code = NGHTTP2_REFUSED_STREAM) {
const stream = request[kRequestStream];
clearRequestStream(request);
function closeStream(stream, code = NGHTTP2_REFUSED_STREAM) {
if (stream != null && !stream.destroyed && !stream.closed) {
try {
stream.close(code);
@@ -27468,6 +27650,11 @@ var require_client_h22 = __commonJS({
}
}
}
function detachRequestStreamForClose(request) {
const stream = request[kRequestStream];
clearRequestStream(request);
return stream;
}
function connectH2(client, socket) {
client[kSocket] = socket;
const http2InitialWindowSize = client[kHTTP2InitialWindowSize];
@@ -27486,6 +27673,12 @@ var require_client_h22 = __commonJS({
session[kClient] = client;
session[kSocket] = socket;
session[kHTTP2SessionState] = {
idleTimeout: null,
// Sockets start out ref'd. Session ref/unref proxies to the socket, so a
// single cached flag lets us skip redundant uv ref/unref calls, provided
// every ref/unref of the session or its socket goes through
// refH2Session/unrefH2Session.
refed: true,
ping: {
interval: client[kPingInterval] === 0 ? null : setInterval(onHttp2SendPing, client[kPingInterval], session).unref()
}
@@ -27502,7 +27695,7 @@ var require_client_h22 = __commonJS({
util.addListener(session, "goaway", onHttp2SessionGoAway);
util.addListener(session, "close", onHttp2SessionClose);
util.addListener(session, "remoteSettings", onHttp2RemoteSettings);
session.unref();
unrefH2Session(session);
client[kHTTP2Session] = session;
socket[kHTTP2Session] = session;
util.addListener(socket, "error", onHttp2SocketError);
@@ -27556,7 +27749,6 @@ var require_client_h22 = __commonJS({
}
if (request != null) {
if (client[kRunning] > 0) {
if (request.idempotent === false) return true;
if ((request.upgrade === "websocket" || request.method === "CONNECT") && session[kRemoteSettings] === false) return true;
if (util.bodyLength(request.body) !== 0 && (util.isStream(request.body) || util.isAsyncIterable(request.body) || util.isFormDataLike(request.body))) return true;
} else {
@@ -27567,18 +27759,69 @@ var require_client_h22 = __commonJS({
}
};
}
function refH2Session(session) {
const state = session[kHTTP2SessionState];
if (state.refed === false) {
state.refed = true;
session.ref();
}
}
function unrefH2Session(session) {
const state = session[kHTTP2SessionState];
if (state.refed === true) {
state.refed = false;
session.unref();
}
}
function resumeH2(client) {
const socket = client[kSocket];
const session = client[kHTTP2Session];
if (socket?.destroyed === false) {
if (client[kSize] === 0 || client[kMaxConcurrentStreams] === 0) {
socket.unref();
client[kHTTP2Session].unref();
unrefH2Session(session);
} else {
socket.ref();
client[kHTTP2Session].ref();
refH2Session(session);
}
if (client[kSize] === 0 && session[kOpenStreams] === 0) {
setHttp2IdleTimeout(session);
} else {
clearHttp2IdleTimeout(session);
}
}
}
function clearHttp2IdleTimeout(session) {
const state = session[kHTTP2SessionState];
if (state?.idleTimeout != null) {
clearTimeout(state.idleTimeout);
state.idleTimeout = null;
}
}
function setHttp2IdleTimeout(session) {
const client = session[kClient];
if (client[kHTTP2Session] !== session || session.closed || session.destroyed) {
return;
}
if (session[kOpenStreams] !== 0 || client[kSize] !== 0) {
clearHttp2IdleTimeout(session);
return;
}
const state = session[kHTTP2SessionState];
if (state.idleTimeout == null) {
state.idleTimeout = setTimeout(onHttp2SessionIdleTimeout, client[kKeepAliveDefaultTimeout], session).unref();
}
}
function onHttp2SessionIdleTimeout(session) {
const client = session[kClient];
const socket = session[kSocket];
const state = session[kHTTP2SessionState];
state.idleTimeout = null;
if (client[kHTTP2Session] !== session || session[kOpenStreams] !== 0 || client[kSize] !== 0 || session.closed || session.destroyed) {
return;
}
const err = new InformationalError("socket idle timeout");
socket[kError] = err;
util.destroy(socket, err);
}
function applyConnectionWindowSize(connectionWindowSize) {
try {
if (typeof this.setLocalWindowSize === "function") {
@@ -27622,10 +27865,16 @@ var require_client_h22 = __commonJS({
function onHttp2SessionError(err) {
assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
this[kSocket][kError] = err;
if (this[kReceivedGoAway]) {
return;
}
this[kClient][kOnError](err);
}
function onHttp2FrameError(type, code, id) {
if (id === 0) {
if (this[kReceivedGoAway]) {
return;
}
const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
this[kSocket][kError] = err;
this[kClient][kOnError](err);
@@ -27646,10 +27895,11 @@ var require_client_h22 = __commonJS({
const previousPendingIdx = client[kPendingIdx];
const pendingIdx = getGoAwayPendingIdx(client, lastStreamID);
const retriableRequests = [];
const streamsToClose = [];
for (let i = pendingIdx; i < previousPendingIdx; i++) {
const request = client[kQueue][i];
if (request != null) {
closeRequestStream(request);
streamsToClose.push(detachRequestStreamForClose(request));
if (canRetryRequestAfterGoAway(request)) {
retriableRequests.push(request);
} else {
@@ -27657,6 +27907,9 @@ var require_client_h22 = __commonJS({
}
}
}
for (let i = 0; i < streamsToClose.length; i++) {
closeStream(streamsToClose[i]);
}
if (pendingIdx !== previousPendingIdx) {
const remainingPendingRequests = client[kQueue].slice(previousPendingIdx);
client[kQueue].length = pendingIdx;
@@ -27667,6 +27920,7 @@ var require_client_h22 = __commonJS({
client[kHTTPContext] = null;
client[kHTTP2Session] = null;
}
clearHttp2IdleTimeout(this);
if (!this.closed && !this.destroyed) {
this.close();
}
@@ -27682,6 +27936,7 @@ var require_client_h22 = __commonJS({
client[kHTTPContext] = null;
client[kHTTP2Session] = null;
}
clearHttp2IdleTimeout(this);
if (state.ping.interval != null) {
clearInterval(state.ping.interval);
state.ping.interval = null;
@@ -27691,7 +27946,9 @@ var require_client_h22 = __commonJS({
const requests = client[kQueue].splice(client[kRunningIdx]);
for (let i = 0; i < requests.length; i++) {
const request = requests[i];
util.errorRequest(client, request, err);
if (request != null) {
util.errorRequest(client, request, err);
}
}
}
}
@@ -27718,6 +27975,9 @@ var require_client_h22 = __commonJS({
function onHttp2SocketError(err) {
assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
this[kError] = err;
if (this[kHTTP2Session]?.[kReceivedGoAway]) {
return;
}
this[kClient][kOnError](err);
}
function onHttp2SocketEnd() {
@@ -27733,7 +27993,8 @@ var require_client_h22 = __commonJS({
stream[kHTTP2Session] = null;
session[kOpenStreams] -= 1;
if (session[kOpenStreams] === 0) {
session.unref();
unrefH2Session(session);
setHttp2IdleTimeout(session);
}
}
function onUpgradeStreamClose() {
@@ -27744,8 +28005,14 @@ var require_client_h22 = __commonJS({
closeStreamSession(this);
}
function onRequestStreamClose() {
this.off("data", onData);
this.off("error", noop);
const state = this[kRequestStreamState];
if (state) {
releaseRequestStream(this);
if (state.pendingEnd && !state.request.aborted && !state.request.completed) {
state.request.onResponseEnd(state.trailers || {});
finalizeRequest(state);
}
}
closeStreamSession(this);
this[kRequestStreamState] = null;
}
@@ -27824,7 +28091,7 @@ var require_client_h22 = __commonJS({
}
function onUpgradeStreamTimeout() {
const state = this[kRequestStreamState];
failUpgradeStream(state, new InformationalError(`HTTP/2: "stream timeout after ${state.requestTimeout}"`));
failUpgradeStream(state, new InformationalError(`HTTP/2: "stream timeout after ${state.headersTimeout}"`));
}
function onUpgradeResponse(headers, _flags) {
const stream = this;
@@ -27839,10 +28106,10 @@ var require_client_h22 = __commonJS({
}
removeUpgradeStreamListeners(stream);
detachRequestFromStream(request);
state.finalizeRequest();
finalizeRequest(state);
}
function setupUpgradeStream(stream, state) {
const { request, requestTimeout, session } = state;
const { request, headersTimeout, session } = state;
stream[kHTTP2Stream] = true;
stream[kHTTP2Session] = session;
stream[kRequestStreamState] = state;
@@ -27853,33 +28120,67 @@ var require_client_h22 = __commonJS({
stream.once("end", onUpgradeStreamEnd);
stream.on("timeout", onUpgradeStreamTimeout);
stream.once("close", onUpgradeStreamClose);
clearHttp2IdleTimeout(session);
++session[kOpenStreams];
stream.setTimeout(requestTimeout);
stream.setTimeout(headersTimeout);
}
function finalizeRequest(state, resetPendingIdx = false) {
if (state.requestFinalized) {
return;
}
state.requestFinalized = true;
completeRequest(state.client, state.request, resetPendingIdx);
state.client[kResume]();
}
function openStream(client, request, session, abort, headers, options) {
try {
return session.request(headers, options);
} catch (err) {
if (err?.code === "ERR_HTTP2_INVALID_SESSION" || err?.code === "ERR_HTTP2_GOAWAY_SESSION") {
const wrappedErr2 = new SocketError(err.message, util.getSocketInfo(session[kSocket]));
wrappedErr2.cause = err;
session[kError] = wrappedErr2;
resetHttp2Session(session, wrappedErr2);
requeueUnsentRequest(client, request);
return null;
}
const wrappedErr = new InformationalError(err.message, { cause: err });
session[kError] = wrappedErr;
session[kSocket][kError] = wrappedErr;
session.destroy(wrappedErr);
util.destroy(session[kSocket], wrappedErr);
abort(wrappedErr);
return null;
}
}
function writeH2(client, request) {
const requestTimeout = request.bodyTimeout ?? client[kBodyTimeout];
const headersTimeout = request.headersTimeout ?? client[kHeadersTimeout];
const bodyTimeout = request.bodyTimeout ?? client[kBodyTimeout];
const session = client[kHTTP2Session];
const { method, path, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request;
let { body } = request;
if (upgrade != null && upgrade !== "websocket") {
util.errorRequest(client, request, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
return false;
}
const headers = buildRequestHeaders(reqHeaders);
let stream = null;
headers[HTTP2_HEADER_AUTHORITY] = host || client[kHostAuthority];
headers[HTTP2_HEADER_METHOD] = method;
let requestFinalized = false;
const finalizeRequest = (resetPendingIdx = false) => {
if (requestFinalized) {
return;
}
requestFinalized = true;
client[kQueue][client[kRunningIdx]++] = null;
if (resetPendingIdx) {
client[kPendingIdx] = client[kRunningIdx];
}
client[kResume]();
const state = {
abort: null,
body: request.body,
client,
contentLength: null,
expectsPayload: false,
request,
headersTimeout,
bodyTimeout,
requestFinalized: false,
responseReceived: false,
bodySent: false,
pendingEnd: false,
trailers: null,
session,
stream: null
};
const abort = (err, resetPendingIdx = false) => {
if (request.aborted || request.completed) {
@@ -27887,30 +28188,22 @@ var require_client_h22 = __commonJS({
}
err = err || new RequestAbortedError();
util.errorRequest(client, request, err);
if (stream != null) {
if (state.stream != null) {
clearRequestStream(request);
stream.close();
const stream2 = state.stream;
stream2.close();
setImmediate(() => {
if (!stream2.destroyed) {
util.destroy(stream2);
}
});
client[kOnError](err);
finalizeRequest(resetPendingIdx);
}
util.destroy(body, err);
};
const requestStream = (headers2, options) => {
try {
return session.request(headers2, options);
} catch (err) {
if (err?.code !== "ERR_HTTP2_INVALID_CONNECTION_HEADERS") {
throw err;
}
const wrappedErr = new InformationalError(err.message, { cause: err });
session[kError] = wrappedErr;
session[kSocket][kError] = wrappedErr;
session.destroy(wrappedErr);
util.destroy(session[kSocket], wrappedErr);
abort(wrappedErr);
return null;
finalizeRequest(state, resetPendingIdx);
}
util.destroy(state.body, err);
};
state.abort = abort;
let stream = null;
try {
request.onRequestStart(abort, null);
} catch (err) {
@@ -27920,20 +28213,11 @@ var require_client_h22 = __commonJS({
return false;
}
if (upgrade || method === "CONNECT") {
session.ref();
const upgradeState = {
abort,
finalizeRequest,
request,
requestTimeout,
responseReceived: false,
session,
stream: null
};
refH2Session(session);
if (upgrade === "websocket") {
if (session[kEnableConnectProtocol] === false) {
util.errorRequest(client, request, new InformationalError("HTTP/2: Extended CONNECT protocol not supported by server"));
session.unref();
unrefH2Session(session);
return false;
}
headers[HTTP2_HEADER_METHOD] = "CONNECT";
@@ -27944,25 +28228,26 @@ var require_client_h22 = __commonJS({
} else {
headers[HTTP2_HEADER_SCHEME] = protocol === "http:" ? "http" : "https";
}
stream = requestStream(headers, { endStream: false, signal });
stream = openStream(client, request, session, abort, headers, { endStream: false, signal });
if (stream == null) {
session.unref();
unrefH2Session(session);
return false;
}
setupUpgradeStream(stream, upgradeState);
setupUpgradeStream(stream, state);
return true;
}
stream = requestStream(headers, { endStream: false, signal });
stream = openStream(client, request, session, abort, headers, { endStream: false, signal });
if (stream == null) {
session.unref();
unrefH2Session(session);
return false;
}
setupUpgradeStream(stream, upgradeState);
setupUpgradeStream(stream, state);
return true;
}
headers[HTTP2_HEADER_PATH] = path;
headers[HTTP2_HEADER_SCHEME] = protocol === "http:" ? "http" : "https";
const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
let body = state.body;
if (body && typeof body.read === "function") {
body.read(0);
}
@@ -27991,7 +28276,7 @@ var require_client_h22 = __commonJS({
assert(body || contentLength === 0, "no body must not have content length");
headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`;
}
session.ref();
refH2Session(session);
if (channels.sendHeaders.hasSubscribers) {
let header = "";
for (const key in headers) {
@@ -28001,45 +28286,39 @@ var require_client_h22 = __commonJS({
channels.sendHeaders.publish({ request, headers: header, socket: session[kSocket] });
}
const shouldEndStream = body === null || contentLength === 0;
const state = {
abort,
body,
client,
contentLength,
expectsPayload,
finalizeRequest,
request,
requestTimeout,
responseReceived: false,
session,
stream: null
};
state.body = body;
state.contentLength = contentLength;
state.expectsPayload = expectsPayload;
if (expectContinue) {
headers[HTTP2_HEADER_EXPECT] = "100-continue";
}
stream = requestStream(headers, { endStream: shouldEndStream, signal });
stream = openStream(client, request, session, abort, headers, { endStream: shouldEndStream, signal });
if (stream == null) {
return false;
}
stream[kHTTP2Stream] = true;
stream[kRequestStreamState] = state;
state.stream = stream;
bindRequestToStream(request, stream, null);
clearHttp2IdleTimeout(session);
++session[kOpenStreams];
stream.setTimeout(requestTimeout);
if (headersTimeout) {
stream.setTimeout(headersTimeout);
}
stream[kHTTP2Session] = session;
stream.once("close", onRequestStreamClose);
stream.on("close", onRequestStreamClose);
bindRequestToStream(request, stream, releaseRequestStream);
if (expectContinue) {
stream.once("continue", writeBodyH2);
}
stream.once("response", onResponse);
stream.once("end", onEnd);
stream.once("error", onError);
stream.once("frameError", onFrameError);
stream.on("response", onResponse);
stream.on("end", onEnd);
stream.on("error", onError);
stream.on("frameError", onFrameError);
stream.on("aborted", onAborted);
stream.on("timeout", onTimeout);
stream.once("trailers", onTrailers);
if (headersTimeout || bodyTimeout) {
stream.on("timeout", onTimeout);
}
stream.on("trailers", onTrailers);
if (!expectContinue) {
writeBodyH2.call(stream);
}
@@ -28069,14 +28348,18 @@ var require_client_h22 = __commonJS({
if (request[kRequestStream] === stream) {
detachRequestFromStream(request);
}
removeRequestStreamListeners(stream);
if (!stream.destroyed && !stream.closed) {
removeRequestStreamListeners(stream);
stream.once("error", noop);
}
}
function onData(chunk) {
const stream = this;
const { request } = stream[kRequestStreamState];
const state = stream[kRequestStreamState];
if (state == null) {
return;
}
const { request } = state;
if (request.aborted || request.completed) {
return;
}
@@ -28087,13 +28370,23 @@ var require_client_h22 = __commonJS({
function onResponse(headers) {
const stream = this;
const state = stream[kRequestStreamState];
if (state == null) {
return;
}
const { request } = state;
stream.off("response", onResponse);
if (state.body != null && !state.bodySent && !stream.writableEnded) {
stream.removeListener("continue", writeBodyH2);
stream.end();
}
const statusCode = headers[HTTP2_HEADER_STATUS];
delete headers[HTTP2_HEADER_STATUS];
request.onResponseStarted();
state.responseReceived = true;
if (request.aborted) {
if (state.headersTimeout || state.bodyTimeout) {
stream.setTimeout(state.bodyTimeout);
}
if (request.aborted || request.completed) {
releaseRequestStream(stream);
return;
}
@@ -28105,14 +28398,15 @@ var require_client_h22 = __commonJS({
function onEnd() {
const stream = this;
const state = stream[kRequestStreamState];
if (state == null) {
return;
}
const { request } = state;
stream.off("end", onEnd);
releaseRequestStream(stream);
if (state.responseReceived) {
if (!request.aborted && !request.completed) {
request.onResponseEnd({});
state.pendingEnd = true;
}
state.finalizeRequest();
} else {
state.abort(new InformationalError("HTTP/2: stream half-closed (remote)"), true);
}
@@ -28120,15 +28414,19 @@ var require_client_h22 = __commonJS({
function onError(err) {
const stream = this;
const state = stream[kRequestStreamState];
if (state == null) {
return;
}
stream.off("error", onError);
releaseRequestStream(stream);
state.abort(err);
}
function onFrameError(type, code) {
const stream = this;
const state = stream[kRequestStreamState];
if (state == null) {
return;
}
stream.off("frameError", onFrameError);
releaseRequestStream(stream);
state.abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`));
}
function onAborted() {
@@ -28137,25 +28435,31 @@ var require_client_h22 = __commonJS({
function onTimeout() {
const stream = this;
const state = stream[kRequestStreamState];
releaseRequestStream(stream);
const err = new InformationalError(`HTTP/2: "stream timeout after ${state.requestTimeout}"`);
if (state == null) {
return;
}
stream.off("timeout", onTimeout);
const err = state.responseReceived ? new BodyTimeoutError(`HTTP/2: "stream timeout after ${state.bodyTimeout}"`) : new HeadersTimeoutError(`HTTP/2: "headers timeout after ${state.headersTimeout}"`);
state.abort(err);
}
function onTrailers(trailers) {
const stream = this;
const state = stream[kRequestStreamState];
if (state == null) {
return;
}
const { request } = state;
stream.off("trailers", onTrailers);
stream.off("data", onData);
if (request.aborted || request.completed) {
return;
}
releaseRequestStream(stream);
request.onResponseEnd(trailers);
state.finalizeRequest();
state.trailers = trailers;
}
function writeBodyH2() {
const stream = this;
const state = stream[kRequestStreamState];
state.bodySent = true;
const { abort, body, client, contentLength, expectsPayload, request } = state;
if (!body || contentLength === 0) {
writeBuffer(
@@ -28411,6 +28715,12 @@ var require_client2 = __commonJS({
function getPipelining(client) {
return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1;
}
function getMaxConcurrent(client) {
if (client[kHTTPContext]?.version === "h2") {
return client[kMaxConcurrentStreams];
}
return getPipelining(client);
}
var Client = class extends DispatcherBase {
/**
*
@@ -28601,8 +28911,9 @@ var require_client2 = __commonJS({
return !!this[kHTTPContext] && !this[kConnecting] && !this[kHTTPContext].destroyed;
}
get [kBusy]() {
const allowsMux = this[kHTTPContext]?.version === "h2";
return Boolean(
this[kHTTPContext]?.busy(null) || this[kSize] >= (getPipelining(this) || 1) || this[kPending] > 0
this[kHTTPContext]?.busy(null) || this[kSize] >= (getMaxConcurrent(this) || 1) || this[kPending] > 0 && !allowsMux
);
}
[kConnect](cb) {
@@ -28638,7 +28949,9 @@ var require_client2 = __commonJS({
const requests = this[kQueue].splice(this[kPendingIdx]);
for (let i = 0; i < requests.length; i++) {
const request = requests[i];
util.errorRequest(this, request, err);
if (request != null) {
util.errorRequest(this, request, err);
}
}
const callback = () => {
if (this[kClosedResolve]) {
@@ -28663,7 +28976,9 @@ var require_client2 = __commonJS({
const requests = client[kQueue].splice(client[kRunningIdx]);
for (let i = 0; i < requests.length; i++) {
const request = requests[i];
util.errorRequest(client, request, err);
if (request != null) {
util.errorRequest(client, request, err);
}
}
assert(client[kSize] === 0);
}
@@ -28771,9 +29086,13 @@ var require_client2 = __commonJS({
});
}
if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
assert(client[kRunning] === 0);
const running = client[kQueue].splice(client[kRunningIdx], client[kRunning]);
client[kPendingIdx] = client[kRunningIdx];
for (let i = 0; i < running.length; i++) {
util.errorRequest(client, running[i], err);
}
while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
const request = client[kQueue][client[kPendingIdx]++];
const request = client[kQueue].splice(client[kPendingIdx], 1)[0];
util.errorRequest(client, request, err);
}
} else {
@@ -28826,7 +29145,7 @@ var require_client2 = __commonJS({
if (client[kPending] === 0) {
return;
}
if (client[kRunning] >= (getPipelining(client) || 1)) {
if (client[kRunning] >= (getMaxConcurrent(client) || 1)) {
return;
}
const request = client[kQueue][client[kPendingIdx]];
@@ -30268,6 +30587,7 @@ var require_socks5_proxy_agent = __commonJS({
var kProxyProtocol = /* @__PURE__ */ Symbol("proxy protocol");
var kPools = /* @__PURE__ */ Symbol("pools");
var kConnector = /* @__PURE__ */ Symbol("connector");
var kRequestTls = /* @__PURE__ */ Symbol("request tls settings");
var experimentalWarningEmitted = false;
var Socks5ProxyAgent = class extends DispatcherBase {
constructor(proxyUrl, options = {}) {
@@ -30289,6 +30609,7 @@ var require_socks5_proxy_agent = __commonJS({
this[kProxyUrl] = url;
this[kProxyHeaders] = options.headers || {};
this[kProxyProtocol] = options.proxyTls ? "https:" : "http:";
this[kRequestTls] = options.requestTls;
this[kProxyAuth] = {
username: options.username || (url.username ? decodeURIComponent(url.username) : null),
password: options.password || (url.password ? decodeURIComponent(url.password) : null)
@@ -30396,9 +30717,9 @@ var require_socks5_proxy_agent = __commonJS({
}
debug2("upgrading to TLS");
finalSocket = tls.connect({
...this[kRequestTls],
socket,
servername: targetHost,
...connectOpts.tls || {}
servername: this[kRequestTls]?.servername || targetHost
});
const tlsReady = Promise.withResolvers();
finalSocket.once("secureConnect", tlsReady.resolve);
@@ -30457,7 +30778,7 @@ var require_proxy_agent2 = __commonJS({
var Agent = require_agent2();
var Pool = require_pool2();
var DispatcherBase = require_dispatcher_base2();
var { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = require_errors2();
var { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError, ProxyConnectionError } = require_errors2();
var buildConnector = require_connect2();
var Client = require_client2();
var { channels } = require_diagnostics2();
@@ -30485,14 +30806,19 @@ var require_proxy_agent2 = __commonJS({
}
return new Pool(origin, opts);
}
function shouldProxyTunnel(requestProtocol, proxyTunnel) {
return proxyTunnel === true || requestProtocol !== "http:";
}
var Http1ProxyWrapper = class extends DispatcherBase {
#client;
constructor(proxyUrl, { headers = {}, connect, factory }) {
#proxyServername;
constructor(proxyUrl, { headers = {}, connect, factory, proxyServername }) {
if (!proxyUrl) {
throw new InvalidArgumentError("Proxy URL is mandatory");
}
super();
this[kProxyHeaders] = headers;
this.#proxyServername = proxyServername;
if (factory) {
this.#client = factory(proxyUrl, { connect });
} else {
@@ -30521,6 +30847,9 @@ var require_proxy_agent2 = __commonJS({
headers.host = host;
}
opts.headers = { ...this[kProxyHeaders], ...headers };
if (this.#proxyServername != null) {
opts.servername = this.#proxyServername;
}
return this.#client[kDispatch](opts, handler);
}
[kClose]() {
@@ -30539,7 +30868,7 @@ var require_proxy_agent2 = __commonJS({
if (typeof clientFactory !== "function") {
throw new InvalidArgumentError("Proxy opts.clientFactory must be a function.");
}
const { proxyTunnel = true, connectTimeout } = opts;
const { proxyTunnel, connectTimeout } = opts;
super();
const url = this.#getUrl(opts);
const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url;
@@ -30560,6 +30889,7 @@ var require_proxy_agent2 = __commonJS({
this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:`).toString("base64")}`;
}
const connect = buildConnector({ timeout: connectTimeout, ...opts.proxyTls });
const connectHTTP1 = buildConnector({ timeout: connectTimeout, ...opts.proxyTls, allowH2: false });
this[kConnectEndpoint] = buildConnector({ timeout: connectTimeout, ...opts.requestTls });
this[kConnectEndpointHTTP1] = buildConnector({ timeout: connectTimeout, ...opts.requestTls, allowH2: false });
const agentFactory = opts.factory || defaultAgentFactory;
@@ -30572,14 +30902,23 @@ var require_proxy_agent2 = __commonJS({
factory: agentFactory,
username: opts.username || username,
password: opts.password || password,
proxyTls: opts.proxyTls
proxyTls: opts.proxyTls,
requestTls: opts.requestTls
});
}
if (!this[kTunnelProxy] && protocol2 === "http:" && this[kProxy].protocol === "http:") {
if (!shouldProxyTunnel(protocol2, this[kTunnelProxy])) {
const forwardConnect = this[kProxy].protocol === "https:" ? (opts2, cb) => connectHTTP1(opts2, (err, socket) => {
if (err && err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
cb(new SecureProxyConnectionError(err));
} else {
cb(err, socket);
}
}) : connectHTTP1;
return new Http1ProxyWrapper(this[kProxy].uri, {
headers: this[kProxyHeaders],
connect,
factory: agentFactory
connect: forwardConnect,
factory: agentFactory,
proxyServername: this[kProxy].protocol === "https:" ? this[kProxyTls]?.servername || proxyHostname : void 0
});
}
return agentFactory(origin2, options);
@@ -30641,6 +30980,8 @@ var require_proxy_agent2 = __commonJS({
} catch (err) {
if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
callback(new SecureProxyConnectionError(err));
} else if (err.code === "UND_ERR_SOCKET") {
callback(new ProxyConnectionError(err));
} else {
callback(err);
}
@@ -30860,6 +31201,35 @@ var require_retry_handler2 = __commonJS({
const retryTime = new Date(retryAfter).getTime();
return isNaN(retryTime) ? 0 : retryTime - Date.now();
}
var RetryController = class {
constructor() {
this.target = null;
}
pause() {
this.target?.pause();
}
resume() {
this.target?.resume();
}
abort(reason) {
this.target?.abort(reason);
}
get paused() {
return this.target?.paused ?? false;
}
get aborted() {
return this.target?.aborted ?? false;
}
get reason() {
return this.target?.reason ?? null;
}
get rawHeaders() {
return this.target?.rawHeaders ?? null;
}
get rawTrailers() {
return this.target?.rawTrailers ?? null;
}
};
var RetryHandler = class _RetryHandler {
constructor(opts, { dispatch, handler }) {
const { retryOptions, ...dispatchOpts } = opts;
@@ -30892,7 +31262,7 @@ var require_retry_handler2 = __commonJS({
timeoutFactor: timeoutFactor ?? 2,
maxRetries: maxRetries ?? 5,
// What errors we should retry
methods: methods ?? ["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE"],
methods: methods ?? ["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE", "QUERY"],
// Indicates which errors to retry
statusCodes: statusCodes ?? [500, 502, 503, 504, 429],
// List of errors to retry
@@ -30916,12 +31286,13 @@ var require_retry_handler2 = __commonJS({
this.etag = null;
this.statusCode = null;
this.headers = null;
this.controllerProxy = new RetryController();
}
onResponseStartWithRetry(controller, statusCode, headers, statusMessage, err) {
if (this.retryOpts.throwOnError) {
if (this.retryOpts.statusCodes.includes(statusCode) === false) {
this.headersSent = true;
this.handler.onResponseStart?.(controller, statusCode, headers, statusMessage);
this.handler.onResponseStart?.(this.controllerProxy, statusCode, headers, statusMessage);
} else {
this.error = err;
}
@@ -30929,13 +31300,13 @@ var require_retry_handler2 = __commonJS({
}
if (isDisturbed(this.opts.body)) {
this.headersSent = true;
this.handler.onResponseStart?.(controller, statusCode, headers, statusMessage);
this.handler.onResponseStart?.(this.controllerProxy, statusCode, headers, statusMessage);
return;
}
function shouldRetry(passedErr) {
if (passedErr) {
this.headersSent = true;
this.handler.onResponseStart?.(controller, statusCode, headers, statusMessage);
this.handler.onResponseStart?.(this.controllerProxy, statusCode, headers, statusMessage);
controller.resume();
return;
}
@@ -30953,12 +31324,13 @@ var require_retry_handler2 = __commonJS({
);
}
onRequestStart(controller, context) {
this.controllerProxy.target = controller;
if (!this.headersSent) {
this.handler.onRequestStart?.(controller, context);
this.handler.onRequestStart?.(this.controllerProxy, context);
}
}
onRequestUpgrade(controller, statusCode, headers, socket) {
this.handler.onRequestUpgrade?.(controller, statusCode, headers, socket);
onRequestUpgrade(_controller, statusCode, headers, socket) {
this.handler.onRequestUpgrade?.(this.controllerProxy, statusCode, headers, socket);
}
static [kRetryHandlerDefaultRetry](err, { state, opts }, cb) {
const { statusCode, code, headers } = err;
@@ -31043,7 +31415,7 @@ var require_retry_handler2 = __commonJS({
if (range == null) {
this.headersSent = true;
this.handler.onResponseStart?.(
controller,
this.controllerProxy,
statusCode,
headers,
statusMessage
@@ -31075,7 +31447,7 @@ var require_retry_handler2 = __commonJS({
}
this.headersSent = true;
this.handler.onResponseStart?.(
controller,
this.controllerProxy,
statusCode,
headers,
statusMessage
@@ -31087,14 +31459,14 @@ var require_retry_handler2 = __commonJS({
});
}
}
onResponseData(controller, chunk) {
onResponseData(_controller, chunk) {
if (this.error) {
return;
}
this.start += chunk.length;
this.handler.onResponseData?.(controller, chunk);
this.handler.onResponseData?.(this.controllerProxy, chunk);
}
onResponseEnd(controller, trailers) {
onResponseEnd(_controller, trailers) {
if (this.error && this.retryOpts.throwOnError) {
throw this.error;
}
@@ -31108,11 +31480,11 @@ var require_retry_handler2 = __commonJS({
}
}
this.retryCount = 0;
return this.handler.onResponseEnd?.(controller, trailers);
return this.handler.onResponseEnd?.(this.controllerProxy, trailers);
}
this.retry(controller);
this.retry();
}
retry(controller) {
retry() {
if (this.start !== 0) {
const headers = { range: `bytes=${this.start}-${this.end ?? ""}` };
if (this.etag != null) {
@@ -31130,20 +31502,20 @@ var require_retry_handler2 = __commonJS({
this.retryCountCheckpoint = this.retryCount;
this.dispatch(this.opts, this);
} catch (err) {
this.handler.onResponseError?.(controller, err);
this.handler.onResponseError?.(this.controllerProxy, err);
}
}
onResponseError(controller, err) {
if (controller?.aborted || isDisturbed(this.opts.body)) {
this.handler.onResponseError?.(controller, err);
this.handler.onResponseError?.(this.controllerProxy, err);
return;
}
function shouldRetry(returnedErr) {
if (!returnedErr) {
this.retry(controller);
this.retry();
return;
}
this.handler?.onResponseError?.(controller, returnedErr);
this.handler?.onResponseError?.(this.controllerProxy, returnedErr);
}
if (this.retryCount - this.retryCountCheckpoint > 0) {
this.retryCount = this.retryCountCheckpoint + (this.retryCount - this.retryCountCheckpoint);
@@ -31260,6 +31632,7 @@ var require_readable2 = __commonJS({
var kContentLength = /* @__PURE__ */ Symbol("kContentLength");
var kUsed = /* @__PURE__ */ Symbol("kUsed");
var kBytesRead = /* @__PURE__ */ Symbol("kBytesRead");
var kPreservedBuffer = /* @__PURE__ */ Symbol("kPreservedBuffer");
var noop = () => {
};
var BodyReadable = class extends Readable2 {
@@ -31498,7 +31871,22 @@ var require_readable2 = __commonJS({
*/
setEncoding(encoding) {
if (Buffer.isEncoding(encoding)) {
this._readableState.encoding = encoding;
const state = this._readableState;
const buffer = state.buffer;
if (buffer && state.length > 0) {
const bufferIndex = state.bufferIndex ?? 0;
const preserved = [];
const source = typeof buffer.slice === "function" ? buffer.slice(bufferIndex) : buffer;
for (const data of source) {
if (Buffer.isBuffer(data)) {
preserved.push(data);
}
}
if (preserved.length > 0) {
this[kPreservedBuffer] = (this[kPreservedBuffer] || []).concat(preserved);
}
}
super.setEncoding(encoding);
}
return this;
}
@@ -31548,7 +31936,13 @@ var require_readable2 = __commonJS({
return;
}
const { _readableState: state } = consume2.stream;
if (state.bufferIndex) {
const preserved = consume2.stream[kPreservedBuffer];
if (preserved && preserved.length > 0) {
for (const chunk of preserved) {
consumePush(consume2, chunk);
}
consume2.stream[kPreservedBuffer] = null;
} else if (state.bufferIndex) {
const start = state.bufferIndex;
const end = state.buffer.length;
for (let n = start; n < end; n++) {
@@ -31619,6 +32013,9 @@ var require_readable2 = __commonJS({
}
}
function consumePush(consume2, chunk) {
if (consume2.body === null) {
return;
}
consume2.length += chunk.length;
consume2.body.push(chunk);
}
@@ -31705,7 +32102,9 @@ var require_api_request2 = __commonJS({
this.removeAbortListener = util.addAbortListener(signal, () => {
this.reason = signal.reason ?? new RequestAbortedError();
if (this.res) {
util.destroy(this.res.on("error", noop), this.reason);
const res = this.res;
this.res = null;
util.destroy(res.on("error", noop), this.reason);
} else if (this.abort) {
this.abort(this.reason);
}
@@ -33224,7 +33623,7 @@ var require_mock_call_history = __commonJS({
return finalOptions;
}
function makeFilterCalls(parameterName) {
return (parameterValue, logs) => {
return (parameterValue, logs = this.logs) => {
if (typeof parameterValue === "string" || parameterValue == null) {
return logs.filter((log) => {
return log[parameterName] === parameterValue;
@@ -34442,7 +34841,11 @@ var require_snapshot_agent = __commonJS({
* @returns {Promise<void>}
*/
async close() {
await this[kSnapshotRecorder].close();
if (this[kSnapshotMode] === "playback") {
this[kSnapshotRecorder].destroy();
} else {
await this[kSnapshotRecorder].close();
}
await this[kRealAgent]?.close();
await super.close();
}
@@ -34589,9 +34992,11 @@ var require_redirect_handler2 = __commonJS({
}
this.dispatch = dispatch;
this.location = null;
const { maxRedirections: _, ...cleanOpts } = opts;
const { maxRedirections: _, stripHeadersOnRedirect, stripHeadersOnCrossOriginRedirect, ...cleanOpts } = opts;
this.opts = cleanOpts;
this.opts.body = util.wrapRequestBody(this.opts.body);
this.stripHeadersOnRedirect = normalizeStripHeaders(stripHeadersOnRedirect, "stripHeadersOnRedirect");
this.stripHeadersOnCrossOriginRedirect = normalizeStripHeaders(stripHeadersOnCrossOriginRedirect, "stripHeadersOnCrossOriginRedirect");
this.maxRedirections = maxRedirections;
this.handler = handler;
this.history = [];
@@ -34636,7 +35041,7 @@ var require_redirect_handler2 = __commonJS({
throw new InvalidArgumentError(`Redirect loop detected. Cannot redirect to ${origin}. This typically happens when using a Client or Pool with cross-origin redirects. Use an Agent for cross-origin redirects.`);
}
}
this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin, this.stripHeadersOnRedirect, this.stripHeadersOnCrossOriginRedirect);
this.opts.path = path;
this.opts.origin = origin;
this.opts.query = null;
@@ -34658,31 +35063,50 @@ var require_redirect_handler2 = __commonJS({
this.handler.onResponseError?.(controller, error2);
}
};
function shouldRemoveHeader(header, removeContent, unknownOrigin) {
if (header.length === 4) {
return util.headerNameToString(header) === "host";
}
if (removeContent && util.headerNameToString(header).startsWith("content-")) {
function shouldRemoveHeader(header, removeContent, unknownOrigin, stripHeaders, stripHeadersOnCrossOrigin) {
const name = util.headerNameToString(header);
if (name === "host") {
return true;
}
if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) {
const name = util.headerNameToString(header);
if (stripHeaders?.has(name) || unknownOrigin && stripHeadersOnCrossOrigin?.has(name)) {
return true;
}
if (removeContent && name.startsWith("content-")) {
return true;
}
if (unknownOrigin) {
return name === "authorization" || name === "cookie" || name === "proxy-authorization";
}
return false;
}
function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
function normalizeStripHeaders(headers, optionName) {
if (headers == null) {
return null;
}
if (!Array.isArray(headers)) {
throw new InvalidArgumentError(`${optionName} must be an array`);
}
const normalized = /* @__PURE__ */ new Set();
for (const header of headers) {
if (typeof header !== "string") {
throw new InvalidArgumentError(`${optionName} must contain header names`);
}
normalized.add(util.headerNameToString(header));
}
return normalized;
}
function cleanRequestHeaders(headers, removeContent, unknownOrigin, stripHeaders, stripHeadersOnCrossOrigin) {
const ret = [];
if (Array.isArray(headers)) {
for (let i = 0; i < headers.length; i += 2) {
if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) {
if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin, stripHeaders, stripHeadersOnCrossOrigin)) {
ret.push(headers[i], headers[i + 1]);
}
}
} else if (headers && typeof headers === "object") {
const entries = util.hasSafeIterator(headers) ? headers : Object.entries(headers);
for (const [key, value] of entries) {
if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
if (!shouldRemoveHeader(key, removeContent, unknownOrigin, stripHeaders, stripHeadersOnCrossOrigin)) {
ret.push(key, value);
}
}
@@ -34700,14 +35124,14 @@ var require_redirect2 = __commonJS({
"node_modules/undici/lib/interceptor/redirect.js"(exports2, module2) {
"use strict";
var RedirectHandler = require_redirect_handler2();
function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections, throwOnMaxRedirect: defaultThrowOnMaxRedirect } = {}) {
function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections, throwOnMaxRedirect: defaultThrowOnMaxRedirect, stripHeadersOnRedirect: defaultStripHeadersOnRedirect, stripHeadersOnCrossOriginRedirect: defaultStripHeadersOnCrossOriginRedirect } = {}) {
return (dispatch) => {
return function Intercept(opts, handler) {
const { maxRedirections = defaultMaxRedirections, throwOnMaxRedirect = defaultThrowOnMaxRedirect, ...rest } = opts;
const { maxRedirections = defaultMaxRedirections, throwOnMaxRedirect = defaultThrowOnMaxRedirect, stripHeadersOnRedirect = defaultStripHeadersOnRedirect, stripHeadersOnCrossOriginRedirect = defaultStripHeadersOnCrossOriginRedirect, ...rest } = opts;
if (maxRedirections == null || maxRedirections === 0) {
return dispatch(opts, handler);
}
const dispatchOpts = { ...rest, throwOnMaxRedirect };
const dispatchOpts = { ...rest, throwOnMaxRedirect, stripHeadersOnRedirect, stripHeadersOnCrossOriginRedirect };
const redirectHandler = new RedirectHandler(dispatch, maxRedirections, dispatchOpts, handler);
return dispatch(dispatchOpts, redirectHandler);
};
@@ -35318,6 +35742,9 @@ var require_dns2 = __commonJS({
const instance = new DNSInstance(opts);
return (dispatch) => {
return function dnsInterceptor(origDispatchOpts, handler) {
if (origDispatchOpts.origin == null) {
return dispatch(origDispatchOpts, handler);
}
const origin = origDispatchOpts.origin.constructor === URL ? origDispatchOpts.origin : new URL(origDispatchOpts.origin);
if (isIP(origin.hostname) !== 0) {
return dispatch(origDispatchOpts, handler);
@@ -35503,6 +35930,9 @@ var require_cache2 = __commonJS({
lastHeader = lastHeader.substring(0, lastHeader.length - 1);
headers[headers.length - 1] = lastHeader;
}
for (let j = 0; j < headers.length; j++) {
headers[j] = headers[j].trim();
}
if (key in output) {
output[key] = output[key].concat(headers);
} else {
@@ -35510,10 +35940,11 @@ var require_cache2 = __commonJS({
}
}
} else {
const fieldName = value.trim();
if (key in output) {
output[key] = output[key].concat(value);
output[key] = output[key].concat(fieldName);
} else {
output[key] = [value];
output[key] = [fieldName];
}
}
break;
@@ -39101,6 +39532,12 @@ var require_request4 = __commonJS({
/** @type {Headers} */
#headers;
#state;
/**
* Removes the `abort` listener that makes this request's signal follow the
* passed signal. `null` when no such listener was registered.
* @type {(() => void) | null}
*/
#abortCleanup = null;
// https://fetch.spec.whatwg.org/#dom-request
constructor(input, init = void 0) {
webidl.util.markAsUncloneable(this);
@@ -39298,8 +39735,13 @@ var require_request4 = __commonJS({
if (abortSignalHasEventHandlerLeakWarning && getMaxListeners(signal) === defaultMaxListeners) {
setMaxListeners(1500, signal);
}
util.addAbortListener(signal, abort);
const removeAbortListener = util.addAbortListener(signal, abort);
requestFinalizer.register(ac, { signal, abort }, abort);
this.#abortCleanup = () => {
requestFinalizer.unregister(abort);
removeAbortListener();
this.#abortCleanup = null;
};
}
}
this.#headers = new Headers2(kConstruct);
@@ -39578,14 +40020,23 @@ var require_request4 = __commonJS({
static setRequestState(request, newState) {
request.#state = newState;
}
/**
* Removes the `abort` listener that makes this request's signal follow the
* signal passed to its constructor, if any. Idempotent.
* @param {Request} request
*/
static removeRequestAbortListener(request) {
request.#abortCleanup?.();
}
};
var { setRequestSignal, getRequestDispatcher, setRequestDispatcher, setRequestHeaders, getRequestState, setRequestState } = Request;
var { setRequestSignal, getRequestDispatcher, setRequestDispatcher, setRequestHeaders, getRequestState, setRequestState, removeRequestAbortListener } = Request;
Reflect.deleteProperty(Request, "setRequestSignal");
Reflect.deleteProperty(Request, "getRequestDispatcher");
Reflect.deleteProperty(Request, "setRequestDispatcher");
Reflect.deleteProperty(Request, "setRequestHeaders");
Reflect.deleteProperty(Request, "getRequestState");
Reflect.deleteProperty(Request, "setRequestState");
Reflect.deleteProperty(Request, "removeRequestAbortListener");
mixinBody(Request, getRequestState);
function makeRequest(init) {
return {
@@ -39608,6 +40059,7 @@ var require_request4 = __commonJS({
referrerPolicy: init.referrerPolicy ?? "",
mode: init.mode ?? "no-cors",
useCORSPreflightFlag: init.useCORSPreflightFlag ?? false,
// TODO: is this credentials mode? https://fetch.spec.whatwg.org/#concept-request-credentials-mode
credentials: init.credentials ?? "same-origin",
useCredentials: init.useCredentials ?? false,
cache: init.cache ?? "default",
@@ -39779,7 +40231,8 @@ var require_request4 = __commonJS({
fromInnerRequest,
cloneRequest,
getRequestDispatcher,
getRequestState
getRequestState,
removeRequestAbortListener
};
}
});
@@ -39936,7 +40389,7 @@ var require_fetch2 = __commonJS({
getResponseState
} = require_response2();
var { HeadersList } = require_headers2();
var { Request, cloneRequest, getRequestDispatcher, getRequestState } = require_request4();
var { Request, cloneRequest, getRequestDispatcher, getRequestState, removeRequestAbortListener } = require_request4();
var zlib = require("node:zlib");
var {
makePolicyContainer,
@@ -40073,7 +40526,7 @@ var require_fetch2 = __commonJS({
let responseObject = null;
let locallyAborted = false;
let controller = null;
addAbortListener(
const removeAbortListener = addAbortListener(
requestObject.signal,
() => {
locallyAborted = true;
@@ -40083,16 +40536,22 @@ var require_fetch2 = __commonJS({
abortFetch(p, request, realResponse, requestObject.signal.reason, controller.controller);
}
);
const cleanupAbortListeners = () => {
removeAbortListener();
removeRequestAbortListener(requestObject);
};
const processResponse = (response) => {
if (locallyAborted) {
return;
}
if (response.aborted) {
abortFetch(p, request, responseObject, controller.serializedAbortReason, controller.controller);
cleanupAbortListeners();
return;
}
if (response.type === "error") {
p.reject(new TypeError("fetch failed", { cause: response.error }));
cleanupAbortListeners();
return;
}
responseObject = new WeakRef(fromInnerResponse(response, "immutable"));
@@ -40101,7 +40560,10 @@ var require_fetch2 = __commonJS({
};
controller = fetching({
request,
processResponseEndOfBody: handleFetchDone,
processResponseEndOfBody: (response) => {
handleFetchDone(response);
cleanupAbortListeners();
},
processResponse,
dispatcher: getRequestDispatcher(requestObject),
// undici
@@ -40600,7 +41062,12 @@ var require_fetch2 = __commonJS({
httpFetchParams = fetchParams;
httpRequest = request;
} else {
httpRequest = cloneRequest(request);
if (request.body?.source != null) {
httpRequest = cloneRequest(request);
} else {
httpRequest = cloneRequest({ ...request, body: null });
httpRequest.body = request.body;
}
httpFetchParams = { ...fetchParams };
httpFetchParams.request = httpRequest;
}
@@ -40645,7 +41112,7 @@ var require_fetch2 = __commonJS({
}
if (!httpRequest.headersList.contains("accept-encoding", true)) {
if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) {
httpRequest.headersList.append("accept-encoding", "br, gzip, deflate", true);
httpRequest.headersList.append("accept-encoding", "br, gzip, deflate, zstd", true);
} else {
httpRequest.headersList.append("accept-encoding", "gzip, deflate", true);
}
@@ -41823,7 +42290,7 @@ var require_util12 = __commonJS({
for (let i = 0; i < path.length; ++i) {
const code = path.charCodeAt(i);
if (code < 32 || // exclude CTLs (0-31)
code === 127 || // DEL
code > 126 || // exclude non-ascii and DEL
code === 59) {
throw new Error("Invalid cookie path");
}
@@ -41936,7 +42403,6 @@ var require_parse2 = __commonJS({
var { maxNameValuePairSize, maxAttributeValueSize } = require_constants9();
var { isCTLExcludingHtab } = require_util12();
var assert = require("node:assert");
var { unescape: qsUnescape } = require("node:querystring");
function parseSetCookie(header) {
if (isCTLExcludingHtab(header)) {
return null;
@@ -41970,7 +42436,7 @@ var require_parse2 = __commonJS({
}
return {
name,
value: qsUnescape(value),
value,
...parseUnparsedAttributes(unparsedAttributes)
};
}
@@ -42013,7 +42479,9 @@ var require_parse2 = __commonJS({
const attributeNameLowercase = attributeName.toLowerCase();
if (attributeNameLowercase === "expires") {
const expiryTime = new Date(attributeValue);
cookieAttributeList.expires = expiryTime;
if (!Number.isNaN(expiryTime.getTime())) {
cookieAttributeList.expires = expiryTime;
}
} else if (attributeNameLowercase === "max-age") {
const charCode = attributeValue.charCodeAt(0);
if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") {
@@ -42044,18 +42512,14 @@ var require_parse2 = __commonJS({
} else if (attributeNameLowercase === "httponly") {
cookieAttributeList.httpOnly = true;
} else if (attributeNameLowercase === "samesite") {
let enforcement = "Default";
const attributeValueLowercase = attributeValue.toLowerCase();
if (attributeValueLowercase.includes("none")) {
enforcement = "None";
if (attributeValueLowercase === "none") {
cookieAttributeList.sameSite = "None";
} else if (attributeValueLowercase === "strict") {
cookieAttributeList.sameSite = "Strict";
} else if (attributeValueLowercase === "lax") {
cookieAttributeList.sameSite = "Lax";
}
if (attributeValueLowercase.includes("strict")) {
enforcement = "Strict";
}
if (attributeValueLowercase.includes("lax")) {
enforcement = "Lax";
}
cookieAttributeList.sameSite = enforcement;
} else {
cookieAttributeList.unparsed ??= [];
cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`);
@@ -43075,6 +43539,8 @@ var require_receiver2 = __commonJS({
/** @type {import('./websocket').Handler} */
#handler;
/** @type {number} */
#maxFragments;
/** @type {number} */
#maxPayloadSize;
/**
* @param {import('./websocket').Handler} handler
@@ -43085,6 +43551,7 @@ var require_receiver2 = __commonJS({
super();
this.#handler = handler;
this.#extensions = extensions == null ? /* @__PURE__ */ new Map() : extensions;
this.#maxFragments = options.maxFragments ?? 0;
this.#maxPayloadSize = options.maxPayloadSize ?? 0;
if (this.#extensions.has("permessage-deflate")) {
this.#extensions.set("permessage-deflate", new PerMessageDeflate(extensions, options));
@@ -43101,7 +43568,7 @@ var require_receiver2 = __commonJS({
this.run(callback);
}
#validatePayloadLength() {
if (this.#maxPayloadSize > 0 && !isControlFrame(this.#info.opcode) && this.#info.payloadLength > this.#maxPayloadSize) {
if (this.#maxPayloadSize > 0 && !isControlFrame(this.#info.opcode) && this.#info.payloadLength + this.#fragmentsBytes > this.#maxPayloadSize) {
failWebsocketConnection(this.#handler, 1009, "Payload size exceeds maximum allowed size");
return false;
}
@@ -43218,7 +43685,9 @@ var require_receiver2 = __commonJS({
this.#state = parserStates.INFO;
} else {
if (!this.#info.compressed) {
this.writeFragments(body);
if (!this.writeFragments(body)) {
return;
}
if (!this.#info.fragmented && this.#info.fin) {
websocketMessageReceived(this.#handler, this.#info.binaryType, this.consumeFragments());
}
@@ -43233,7 +43702,9 @@ var require_receiver2 = __commonJS({
failWebsocketConnection(this.#handler, code, error2.message);
return;
}
this.writeFragments(data);
if (!this.writeFragments(data)) {
return;
}
if (this.#maxPayloadSize > 0 && this.#fragmentsBytes > this.#maxPayloadSize) {
failWebsocketConnection(this.#handler, 1009, new MessageSizeExceededError().message);
return;
@@ -43298,8 +43769,13 @@ var require_receiver2 = __commonJS({
}
}
writeFragments(fragment) {
if (this.#maxFragments > 0 && this.#fragments.length === this.#maxFragments) {
failWebsocketConnection(this.#handler, 1008, "Too many message fragments");
return false;
}
this.#fragmentsBytes += fragment.length;
this.#fragments.push(fragment);
return true;
}
consumeFragments() {
const fragments = this.#fragments;
@@ -43766,8 +44242,10 @@ var require_websocket2 = __commonJS({
*/
#onConnectionEstablished(response, parsedExtensions) {
this.#handler.socket = response.socket;
const maxFragments = this.#handler.controller.dispatcher?.webSocketOptions?.maxFragments;
const maxPayloadSize = this.#handler.controller.dispatcher?.webSocketOptions?.maxPayloadSize;
const parser = new ByteParser(this.#handler, parsedExtensions, {
maxFragments,
maxPayloadSize
});
parser.on("drain", () => this.#handler.onParserDrain());
@@ -44213,7 +44691,12 @@ var require_websocketstream = __commonJS({
/** @type {import('../websocket').Handler['onConnectionEstablished']} */
#onConnectionEstablished(response, parsedExtensions) {
this.#handler.socket = response.socket;
const parser = new ByteParser(this.#handler, parsedExtensions);
const maxFragments = this.#handler.controller.dispatcher?.webSocketOptions?.maxFragments;
const maxPayloadSize = this.#handler.controller.dispatcher?.webSocketOptions?.maxPayloadSize;
const parser = new ByteParser(this.#handler, parsedExtensions, {
maxFragments,
maxPayloadSize
});
parser.on("drain", () => this.#handler.onParserDrain());
parser.on("error", (err) => this.#handler.onParserError(err));
this.#parser = parser;
@@ -44353,6 +44836,7 @@ var require_websocketstream = __commonJS({
var require_util14 = __commonJS({
"node_modules/undici/lib/web/eventsource/util.js"(exports2, module2) {
"use strict";
var { makeRequest } = require_request4();
function isValidLastEventId(value) {
return value.indexOf("\0") === -1;
}
@@ -44363,9 +44847,27 @@ var require_util14 = __commonJS({
}
return true;
}
function createPotentialCORSRequest(url, destination, corsAttributeState, sameOriginFallback) {
let mode = corsAttributeState === "no cors" ? "no-cors" : "cors";
if (sameOriginFallback && mode === "no-cors") {
mode = "same-origin";
}
let credentialsMode = "include";
if (corsAttributeState === "anonymous") {
credentialsMode = "same-origin";
}
return makeRequest({
urlList: [url],
destination,
mode,
credentials: credentialsMode,
useURLCredentials: true
});
}
module2.exports = {
isValidLastEventId,
isASCIINumber
isASCIINumber,
createPotentialCORSRequest
};
}
});
@@ -44717,7 +45219,6 @@ var require_eventsource2 = __commonJS({
"use strict";
var { pipeline } = require("node:stream");
var { fetching } = require_fetch2();
var { makeRequest } = require_request4();
var { webidl } = require_webidl2();
var { EventSourceStream } = require_eventsource_stream2();
var { parseMIMEType } = require_data_url2();
@@ -44725,6 +45226,7 @@ var require_eventsource2 = __commonJS({
var { isNetworkError } = require_response2();
var { kEnumerableProperty } = require_util9();
var { environmentSettingsObject } = require_util10();
var { createPotentialCORSRequest } = require_util14();
var experimentalWarned = false;
var defaultReconnectionTime = 3e3;
var CONNECTING = 0;
@@ -44789,20 +45291,12 @@ var require_eventsource2 = __commonJS({
corsAttributeState = USE_CREDENTIALS;
this.#withCredentials = true;
}
const initRequest = {
redirect: "follow",
keepalive: true,
// @see https://html.spec.whatwg.org/multipage/urls-and-fetching.html#cors-settings-attributes
mode: "cors",
credentials: corsAttributeState === "anonymous" ? "same-origin" : "omit",
referrer: "no-referrer"
};
initRequest.client = environmentSettingsObject.settingsObject;
initRequest.headersList = [["accept", { name: "accept", value: "text/event-stream" }]];
initRequest.cache = "no-store";
initRequest.initiator = "other";
initRequest.urlList = [new URL(this.#url)];
this.#request = makeRequest(initRequest);
const request = createPotentialCORSRequest(urlRecord, "", corsAttributeState);
request.client = environmentSettingsObject.settingsObject;
request.headersList.set("Accept", "text/event-stream");
request.cache = "no-store";
request.initiator = "other";
this.#request = request;
this.#connect();
}
/**