Skip to content

Instantly share code, notes, and snippets.

@guest271314

guest271314/websocketstream-undici-bundle.js

Created March 8, 2025 03:11
Show Gist options
  • Save guest271314/542aae19acefe97ffdb87bdcb6e0339a to your computer and use it in GitHub Desktop.
Save guest271314/542aae19acefe97ffdb87bdcb6e0339a to your computer and use it in GitHub Desktop.
Download ZIP
Node.js Undici WebSocketStream bundled with bun build
Raw
websocketstream-undici-bundle.js
// bun build undici/lib/web/websocket/stream/websocketstream.js --target=node --packages=external --format=esm --minify-syntax --outfile=websocketstream-undici-bundle.js
import { createRequire } from "node:module";
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __require = /* @__PURE__ */ createRequire(import.meta.url);
// undici/lib/web/fetch/constants.js
var require_constants = __commonJS((exports, module) => {
var corsSafeListedMethods = ["GET", "HEAD", "POST"], corsSafeListedMethodsSet = new Set(corsSafeListedMethods), nullBodyStatus = [101, 204, 205, 304], redirectStatus = [301, 302, 303, 307, 308], redirectStatusSet = new Set(redirectStatus), badPorts = [
"1",
"7",
"9",
"11",
"13",
"15",
"17",
"19",
"20",
"21",
"22",
"23",
"25",
"37",
"42",
"43",
"53",
"69",
"77",
"79",
"87",
"95",
"101",
"102",
"103",
"104",
"109",
"110",
"111",
"113",
"115",
"117",
"119",
"123",
"135",
"137",
"139",
"143",
"161",
"179",
"389",
"427",
"465",
"512",
"513",
"514",
"515",
"526",
"530",
"531",
"532",
"540",
"548",
"554",
"556",
"563",
"587",
"601",
"636",
"989",
"990",
"993",
"995",
"1719",
"1720",
"1723",
"2049",
"3659",
"4045",
"4190",
"5060",
"5061",
"6000",
"6566",
"6665",
"6666",
"6667",
"6668",
"6669",
"6679",
"6697",
"10080"
], badPortsSet = new Set(badPorts), referrerPolicyTokens = [
"no-referrer",
"no-referrer-when-downgrade",
"same-origin",
"origin",
"strict-origin",
"origin-when-cross-origin",
"strict-origin-when-cross-origin",
"unsafe-url"
], referrerPolicy = [
"",
...referrerPolicyTokens
], referrerPolicyTokensSet = new Set(referrerPolicyTokens), requestRedirect = ["follow", "manual", "error"], safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"], safeMethodsSet = new Set(safeMethods), requestMode = ["navigate", "same-origin", "no-cors", "cors"], requestCredentials = ["omit", "same-origin", "include"], requestCache = [
"default",
"no-store",
"reload",
"no-cache",
"force-cache",
"only-if-cached"
], requestBodyHeader = [
"content-encoding",
"content-language",
"content-location",
"content-type",
"content-length"
], requestDuplex = [
"half"
], forbiddenMethods = ["CONNECT", "TRACE", "TRACK"], forbiddenMethodsSet = new Set(forbiddenMethods), subresource = [
"audio",
"audioworklet",
"font",
"image",
"manifest",
"paintworklet",
"script",
"style",
"track",
"video",
"xslt",
""
], subresourceSet = new Set(subresource);
module.exports = {
subresource,
forbiddenMethods,
requestBodyHeader,
referrerPolicy,
requestRedirect,
requestMode,
requestCredentials,
requestCache,
redirectStatus,
corsSafeListedMethods,
nullBodyStatus,
safeMethods,
badPorts,
requestDuplex,
subresourceSet,
badPortsSet,
redirectStatusSet,
corsSafeListedMethodsSet,
safeMethodsSet,
forbiddenMethodsSet,
referrerPolicyTokens: referrerPolicyTokensSet
};
});
// undici/lib/web/fetch/global.js
var require_global = __commonJS((exports, module) => {
var globalOrigin = Symbol.for("undici.globalOrigin.1");
function getGlobalOrigin() {
return globalThis[globalOrigin];
}
function setGlobalOrigin(newOrigin) {
if (newOrigin === void 0) {
Object.defineProperty(globalThis, globalOrigin, {
value: void 0,
writable: !0,
enumerable: !1,
configurable: !1
});
return;
}
let parsedURL = new URL(newOrigin);
if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:")
throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`);
Object.defineProperty(globalThis, globalOrigin, {
value: parsedURL,
writable: !0,
enumerable: !1,
configurable: !1
});
}
module.exports = {
getGlobalOrigin,
setGlobalOrigin
};
});
// undici/lib/web/fetch/data-url.js
var require_data_url = __commonJS((exports, module) => {
var assert = __require("node:assert"), encoder = /* @__PURE__ */ new TextEncoder, HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+\-.^_|~A-Za-z0-9]+$/, HTTP_WHITESPACE_REGEX = /[\u000A\u000D\u0009\u0020]/, ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g, HTTP_QUOTED_STRING_TOKENS = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;
function dataURLProcessor(dataURL) {
assert(dataURL.protocol === "data:");
let input = URLSerializer(dataURL, !0);
input = input.slice(5);
let position = { position: 0 }, mimeType = collectASequenceOfCodePointsFast(",", input, position), mimeTypeLength = mimeType.length;
if (mimeType = removeASCIIWhitespace(mimeType, !0, !0), position.position >= input.length)
return "failure";
position.position++;
let encodedBody = input.slice(mimeTypeLength + 1), body = stringPercentDecode(encodedBody);
if (/;(\u0020){0,}base64$/i.test(mimeType)) {
let stringBody = isomorphicDecode(body);
if (body = forgivingBase64(stringBody), body === "failure")
return "failure";
mimeType = mimeType.slice(0, -6), mimeType = mimeType.replace(/(\u0020)+$/, ""), mimeType = mimeType.slice(0, -1);
}
if (mimeType.startsWith(";"))
mimeType = "text/plain" + mimeType;
let mimeTypeRecord = parseMIMEType(mimeType);
if (mimeTypeRecord === "failure")
mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII");
return { mimeType: mimeTypeRecord, body };
}
function URLSerializer(url, excludeFragment = !1) {
if (!excludeFragment)
return url.href;
let href = url.href, hashLength = url.hash.length, serialized = hashLength === 0 ? href : href.substring(0, href.length - hashLength);
if (!hashLength && href.endsWith("#"))
return serialized.slice(0, -1);
return serialized;
}
function collectASequenceOfCodePoints(condition, input, position) {
let result = "";
while (position.position < input.length && condition(input[position.position]))
result += input[position.position], position.position++;
return result;
}
function collectASequenceOfCodePointsFast(char, input, position) {
let idx = input.indexOf(char, position.position), start = position.position;
if (idx === -1)
return position.position = input.length, input.slice(start);
return position.position = idx, input.slice(start, position.position);
}
function stringPercentDecode(input) {
let bytes = encoder.encode(input);
return percentDecode(bytes);
}
function isHexCharByte(byte) {
return byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102;
}
function hexByteToNumber(byte) {
return byte >= 48 && byte <= 57 ? byte - 48 : (byte & 223) - 55;
}
function percentDecode(input) {
let length = input.length, output = new Uint8Array(length), j = 0;
for (let i = 0;i < length; ++i) {
let byte = input[i];
if (byte !== 37)
output[j++] = byte;
else if (byte === 37 && !(isHexCharByte(input[i + 1]) && isHexCharByte(input[i + 2])))
output[j++] = 37;
else
output[j++] = hexByteToNumber(input[i + 1]) << 4 | hexByteToNumber(input[i + 2]), i += 2;
}
return length === j ? output : output.subarray(0, j);
}
function parseMIMEType(input) {
input = removeHTTPWhitespace(input, !0, !0);
let position = { position: 0 }, type = collectASequenceOfCodePointsFast("/", input, position);
if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type))
return "failure";
if (position.position >= input.length)
return "failure";
position.position++;
let subtype = collectASequenceOfCodePointsFast(";", input, position);
if (subtype = removeHTTPWhitespace(subtype, !1, !0), subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype))
return "failure";
let typeLowercase = type.toLowerCase(), subtypeLowercase = subtype.toLowerCase(), mimeType = {
type: typeLowercase,
subtype: subtypeLowercase,
parameters: /* @__PURE__ */ new Map,
essence: `${typeLowercase}/${subtypeLowercase}`
};
while (position.position < input.length) {
position.position++, collectASequenceOfCodePoints((char) => HTTP_WHITESPACE_REGEX.test(char), input, position);
let parameterName = collectASequenceOfCodePoints((char) => char !== ";" && char !== "=", input, position);
if (parameterName = parameterName.toLowerCase(), position.position < input.length) {
if (input[position.position] === ";")
continue;
position.position++;
}
if (position.position >= input.length)
break;
let parameterValue = null;
if (input[position.position] === '"')
parameterValue = collectAnHTTPQuotedString(input, position, !0), collectASequenceOfCodePointsFast(";", input, position);
else if (parameterValue = collectASequenceOfCodePointsFast(";", input, position), parameterValue = removeHTTPWhitespace(parameterValue, !1, !0), parameterValue.length === 0)
continue;
if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName))
mimeType.parameters.set(parameterName, parameterValue);
}
return mimeType;
}
function forgivingBase64(data) {
data = data.replace(ASCII_WHITESPACE_REPLACE_REGEX, "");
let dataLength = data.length;
if (dataLength % 4 === 0) {
if (data.charCodeAt(dataLength - 1) === 61) {
if (--dataLength, data.charCodeAt(dataLength - 1) === 61)
--dataLength;
}
}
if (dataLength % 4 === 1)
return "failure";
if (/[^+/0-9A-Za-z]/.test(data.length === dataLength ? data : data.substring(0, dataLength)))
return "failure";
let buffer = Buffer.from(data, "base64");
return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
}
function collectAnHTTPQuotedString(input, position, extractValue = !1) {
let positionStart = position.position, value = "";
assert(input[position.position] === '"'), position.position++;
while (!0) {
if (value += collectASequenceOfCodePoints((char) => char !== '"' && char !== "\\", input, position), position.position >= input.length)
break;
let quoteOrBackslash = input[position.position];
if (position.position++, quoteOrBackslash === "\\") {
if (position.position >= input.length) {
value += "\\";
break;
}
value += input[position.position], position.position++;
} else {
assert(quoteOrBackslash === '"');
break;
}
}
if (extractValue)
return value;
return input.slice(positionStart, position.position);
}
function serializeAMimeType(mimeType) {
assert(mimeType !== "failure");
let { parameters, essence } = mimeType, serialization = essence;
for (let [name, value] of parameters.entries()) {
if (serialization += ";", serialization += name, serialization += "=", !HTTP_TOKEN_CODEPOINTS.test(value))
value = value.replace(/(\\|")/g, "\\$1"), value = '"' + value, value += '"';
serialization += value;
}
return serialization;
}
function isHTTPWhiteSpace(char) {
return char === 13 || char === 10 || char === 9 || char === 32;
}
function removeHTTPWhitespace(str, leading = !0, trailing = !0) {
return removeChars(str, leading, trailing, isHTTPWhiteSpace);
}
function isASCIIWhitespace(char) {
return char === 13 || char === 10 || char === 9 || char === 12 || char === 32;
}
function removeASCIIWhitespace(str, leading = !0, trailing = !0) {
return removeChars(str, leading, trailing, isASCIIWhitespace);
}
function removeChars(str, leading, trailing, predicate) {
let lead = 0, trail = str.length - 1;
if (leading)
while (lead < str.length && predicate(str.charCodeAt(lead)))
lead++;
if (trailing)
while (trail > 0 && predicate(str.charCodeAt(trail)))
trail--;
return lead === 0 && trail === str.length - 1 ? str : str.slice(lead, trail + 1);
}
function isomorphicDecode(input) {
let length = input.length;
if (65535 > length)
return String.fromCharCode.apply(null, input);
let result = "", i = 0, addition = 65535;
while (i < length) {
if (i + addition > length)
addition = length - i;
result += String.fromCharCode.apply(null, input.subarray(i, i += addition));
}
return result;
}
function minimizeSupportedMimeType(mimeType) {
switch (mimeType.essence) {
case "application/ecmascript":
case "application/javascript":
case "application/x-ecmascript":
case "application/x-javascript":
case "text/ecmascript":
case "text/javascript":
case "text/javascript1.0":
case "text/javascript1.1":
case "text/javascript1.2":
case "text/javascript1.3":
case "text/javascript1.4":
case "text/javascript1.5":
case "text/jscript":
case "text/livescript":
case "text/x-ecmascript":
case "text/x-javascript":
return "text/javascript";
case "application/json":
case "text/json":
return "application/json";
case "image/svg+xml":
return "image/svg+xml";
case "text/xml":
case "application/xml":
return "application/xml";
}
if (mimeType.subtype.endsWith("+json"))
return "application/json";
if (mimeType.subtype.endsWith("+xml"))
return "application/xml";
return "";
}
module.exports = {
dataURLProcessor,
URLSerializer,
collectASequenceOfCodePoints,
collectASequenceOfCodePointsFast,
stringPercentDecode,
parseMIMEType,
collectAnHTTPQuotedString,
serializeAMimeType,
removeChars,
removeHTTPWhitespace,
minimizeSupportedMimeType,
HTTP_TOKEN_CODEPOINTS,
isomorphicDecode
};
});
// undici/lib/core/symbols.js
var require_symbols = __commonJS((exports, module) => {
module.exports = {
kClose: Symbol("close"),
kDestroy: Symbol("destroy"),
kDispatch: Symbol("dispatch"),
kUrl: Symbol("url"),
kWriting: Symbol("writing"),
kResuming: Symbol("resuming"),
kQueue: Symbol("queue"),
kConnect: Symbol("connect"),
kConnecting: Symbol("connecting"),
kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"),
kKeepAliveMaxTimeout: Symbol("max keep alive timeout"),
kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"),
kKeepAliveTimeoutValue: Symbol("keep alive timeout"),
kKeepAlive: Symbol("keep alive"),
kHeadersTimeout: Symbol("headers timeout"),
kBodyTimeout: Symbol("body timeout"),
kServerName: Symbol("server name"),
kLocalAddress: Symbol("local address"),
kHost: Symbol("host"),
kNoRef: Symbol("no ref"),
kBodyUsed: Symbol("used"),
kBody: Symbol("abstracted request body"),
kRunning: Symbol("running"),
kBlocking: Symbol("blocking"),
kPending: Symbol("pending"),
kSize: Symbol("size"),
kBusy: Symbol("busy"),
kQueued: Symbol("queued"),
kFree: Symbol("free"),
kConnected: Symbol("connected"),
kClosed: Symbol("closed"),
kNeedDrain: Symbol("need drain"),
kReset: Symbol("reset"),
kDestroyed: Symbol.for("nodejs.stream.destroyed"),
kResume: Symbol("resume"),
kOnError: Symbol("on error"),
kMaxHeadersSize: Symbol("max headers size"),
kRunningIdx: Symbol("running index"),
kPendingIdx: Symbol("pending index"),
kError: Symbol("error"),
kClients: Symbol("clients"),
kClient: Symbol("client"),
kParser: Symbol("parser"),
kOnDestroyed: Symbol("destroy callbacks"),
kPipelining: Symbol("pipelining"),
kSocket: Symbol("socket"),
kHostHeader: Symbol("host header"),
kConnector: Symbol("connector"),
kStrictContentLength: Symbol("strict content length"),
kMaxRedirections: Symbol("maxRedirections"),
kMaxRequests: Symbol("maxRequestsPerClient"),
kProxy: Symbol("proxy agent options"),
kCounter: Symbol("socket request counter"),
kMaxResponseSize: Symbol("max response size"),
kHTTP2Session: Symbol("http2Session"),
kHTTP2SessionState: Symbol("http2Session state"),
kRetryHandlerDefaultRetry: Symbol("retry agent default retry"),
kConstruct: Symbol("constructable"),
kListeners: Symbol("listeners"),
kHTTPContext: Symbol("http context"),
kMaxConcurrentStreams: Symbol("max concurrent streams"),
kNoProxyAgent: Symbol("no proxy agent"),
kHttpProxyAgent: Symbol("http proxy agent"),
kHttpsProxyAgent: Symbol("https proxy agent")
};
});
// undici/lib/core/errors.js
var require_errors = __commonJS((exports, module) => {
class UndiciError extends Error {
constructor(message, options) {
super(message, options);
this.name = "UndiciError", this.code = "UND_ERR";
}
}
class ConnectTimeoutError extends UndiciError {
constructor(message) {
super(message);
this.name = "ConnectTimeoutError", this.message = message || "Connect Timeout Error", this.code = "UND_ERR_CONNECT_TIMEOUT";
}
}
class HeadersTimeoutError extends UndiciError {
constructor(message) {
super(message);
this.name = "HeadersTimeoutError", this.message = message || "Headers Timeout Error", this.code = "UND_ERR_HEADERS_TIMEOUT";
}
}
class HeadersOverflowError extends UndiciError {
constructor(message) {
super(message);
this.name = "HeadersOverflowError", this.message = message || "Headers Overflow Error", this.code = "UND_ERR_HEADERS_OVERFLOW";
}
}
class BodyTimeoutError extends UndiciError {
constructor(message) {
super(message);
this.name = "BodyTimeoutError", this.message = message || "Body Timeout Error", this.code = "UND_ERR_BODY_TIMEOUT";
}
}
class ResponseStatusCodeError extends UndiciError {
constructor(message, statusCode, headers, body) {
super(message);
this.name = "ResponseStatusCodeError", this.message = message || "Response Status Code Error", this.code = "UND_ERR_RESPONSE_STATUS_CODE", this.body = body, this.status = statusCode, this.statusCode = statusCode, this.headers = headers;
}
}
class InvalidArgumentError extends UndiciError {
constructor(message) {
super(message);
this.name = "InvalidArgumentError", this.message = message || "Invalid Argument Error", this.code = "UND_ERR_INVALID_ARG";
}
}
class InvalidReturnValueError extends UndiciError {
constructor(message) {
super(message);
this.name = "InvalidReturnValueError", this.message = message || "Invalid Return Value Error", this.code = "UND_ERR_INVALID_RETURN_VALUE";
}
}
class AbortError extends UndiciError {
constructor(message) {
super(message);
this.name = "AbortError", this.message = message || "The operation was aborted";
}
}
class RequestAbortedError extends AbortError {
constructor(message) {
super(message);
this.name = "AbortError", this.message = message || "Request aborted", this.code = "UND_ERR_ABORTED";
}
}
class InformationalError extends UndiciError {
constructor(message) {
super(message);
this.name = "InformationalError", this.message = message || "Request information", this.code = "UND_ERR_INFO";
}
}
class RequestContentLengthMismatchError extends UndiciError {
constructor(message) {
super(message);
this.name = "RequestContentLengthMismatchError", this.message = message || "Request body length does not match content-length header", this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH";
}
}
class ResponseContentLengthMismatchError extends UndiciError {
constructor(message) {
super(message);
this.name = "ResponseContentLengthMismatchError", this.message = message || "Response body length does not match content-length header", this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH";
}
}
class ClientDestroyedError extends UndiciError {
constructor(message) {
super(message);
this.name = "ClientDestroyedError", this.message = message || "The client is destroyed", this.code = "UND_ERR_DESTROYED";
}
}
class ClientClosedError extends UndiciError {
constructor(message) {
super(message);
this.name = "ClientClosedError", this.message = message || "The client is closed", this.code = "UND_ERR_CLOSED";
}
}
class SocketError extends UndiciError {
constructor(message, socket) {
super(message);
this.name = "SocketError", this.message = message || "Socket error", this.code = "UND_ERR_SOCKET", this.socket = socket;
}
}
class NotSupportedError extends UndiciError {
constructor(message) {
super(message);
this.name = "NotSupportedError", this.message = message || "Not supported error", this.code = "UND_ERR_NOT_SUPPORTED";
}
}
class BalancedPoolMissingUpstreamError extends UndiciError {
constructor(message) {
super(message);
this.name = "MissingUpstreamError", this.message = message || "No upstream has been added to the BalancedPool", this.code = "UND_ERR_BPL_MISSING_UPSTREAM";
}
}
class HTTPParserError extends Error {
constructor(message, code, data) {
super(message);
this.name = "HTTPParserError", this.code = code ? `HPE_${code}` : void 0, this.data = data ? data.toString() : void 0;
}
}
class ResponseExceededMaxSizeError extends UndiciError {
constructor(message) {
super(message);
this.name = "ResponseExceededMaxSizeError", this.message = message || "Response content exceeded max size", this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE";
}
}
class RequestRetryError extends UndiciError {
constructor(message, code, { headers, data }) {
super(message);
this.name = "RequestRetryError", this.message = message || "Request retry error", this.code = "UND_ERR_REQ_RETRY", this.statusCode = code, this.data = data, this.headers = headers;
}
}
class ResponseError extends UndiciError {
constructor(message, code, { headers, body }) {
super(message);
this.name = "ResponseError", this.message = message || "Response error", this.code = "UND_ERR_RESPONSE", this.statusCode = code, this.body = body, this.headers = headers;
}
}
class SecureProxyConnectionError extends UndiciError {
constructor(cause, message, options = {}) {
super(message, { cause, ...options });
this.name = "SecureProxyConnectionError", this.message = message || "Secure Proxy Connection failed", this.code = "UND_ERR_PRX_TLS", this.cause = cause;
}
}
module.exports = {
AbortError,
HTTPParserError,
UndiciError,
HeadersTimeoutError,
HeadersOverflowError,
BodyTimeoutError,
RequestContentLengthMismatchError,
ConnectTimeoutError,
ResponseStatusCodeError,
InvalidArgumentError,
InvalidReturnValueError,
RequestAbortedError,
ClientDestroyedError,
ClientClosedError,
InformationalError,
SocketError,
NotSupportedError,
ResponseContentLengthMismatchError,
BalancedPoolMissingUpstreamError,
ResponseExceededMaxSizeError,
RequestRetryError,
ResponseError,
SecureProxyConnectionError
};
});
// undici/lib/core/constants.js
var require_constants2 = __commonJS((exports, module) => {
var wellknownHeaderNames = [
"Accept",
"Accept-Encoding",
"Accept-Language",
"Accept-Ranges",
"Access-Control-Allow-Credentials",
"Access-Control-Allow-Headers",
"Access-Control-Allow-Methods",
"Access-Control-Allow-Origin",
"Access-Control-Expose-Headers",
"Access-Control-Max-Age",
"Access-Control-Request-Headers",
"Access-Control-Request-Method",
"Age",
"Allow",
"Alt-Svc",
"Alt-Used",
"Authorization",
"Cache-Control",
"Clear-Site-Data",
"Connection",
"Content-Disposition",
"Content-Encoding",
"Content-Language",
"Content-Length",
"Content-Location",
"Content-Range",
"Content-Security-Policy",
"Content-Security-Policy-Report-Only",
"Content-Type",
"Cookie",
"Cross-Origin-Embedder-Policy",
"Cross-Origin-Opener-Policy",
"Cross-Origin-Resource-Policy",
"Date",
"Device-Memory",
"Downlink",
"ECT",
"ETag",
"Expect",
"Expect-CT",
"Expires",
"Forwarded",
"From",
"Host",
"If-Match",
"If-Modified-Since",
"If-None-Match",
"If-Range",
"If-Unmodified-Since",
"Keep-Alive",
"Last-Modified",
"Link",
"Location",
"Max-Forwards",
"Origin",
"Permissions-Policy",
"Pragma",
"Proxy-Authenticate",
"Proxy-Authorization",
"RTT",
"Range",
"Referer",
"Referrer-Policy",
"Refresh",
"Retry-After",
"Sec-WebSocket-Accept",
"Sec-WebSocket-Extensions",
"Sec-WebSocket-Key",
"Sec-WebSocket-Protocol",
"Sec-WebSocket-Version",
"Server",
"Server-Timing",
"Service-Worker-Allowed",
"Service-Worker-Navigation-Preload",
"Set-Cookie",
"SourceMap",
"Strict-Transport-Security",
"Supports-Loading-Mode",
"TE",
"Timing-Allow-Origin",
"Trailer",
"Transfer-Encoding",
"Upgrade",
"Upgrade-Insecure-Requests",
"User-Agent",
"Vary",
"Via",
"WWW-Authenticate",
"X-Content-Type-Options",
"X-DNS-Prefetch-Control",
"X-Frame-Options",
"X-Permitted-Cross-Domain-Policies",
"X-Powered-By",
"X-Requested-With",
"X-XSS-Protection"
], headerNameLowerCasedRecord = {};
Object.setPrototypeOf(headerNameLowerCasedRecord, null);
var wellknownHeaderNameBuffers = {};
Object.setPrototypeOf(wellknownHeaderNameBuffers, null);
function getHeaderNameAsBuffer(header) {
let buffer = wellknownHeaderNameBuffers[header];
if (buffer === void 0)
buffer = Buffer.from(header);
return buffer;
}
for (let i = 0;i < wellknownHeaderNames.length; ++i) {
let key = wellknownHeaderNames[i], lowerCasedKey = key.toLowerCase();
headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey;
}
module.exports = {
wellknownHeaderNames,
headerNameLowerCasedRecord,
getHeaderNameAsBuffer
};
});
// undici/lib/core/tree.js
var require_tree = __commonJS((exports, module) => {
var {
wellknownHeaderNames,
headerNameLowerCasedRecord
} = require_constants2();
class TstNode {
value = null;
left = null;
middle = null;
right = null;
code;
constructor(key, value, index) {
if (index === void 0 || index >= key.length)
throw new TypeError("Unreachable");
if ((this.code = key.charCodeAt(index)) > 127)
throw new TypeError("key must be ascii string");
if (key.length !== ++index)
this.middle = new TstNode(key, value, index);
else
this.value = value;
}
add(key, value) {
let length = key.length;
if (length === 0)
throw new TypeError("Unreachable");
let index = 0, node = this;
while (!0) {
let code = key.charCodeAt(index);
if (code > 127)
throw new TypeError("key must be ascii string");
if (node.code === code)
if (length === ++index) {
node.value = value;
break;
} else if (node.middle !== null)
node = node.middle;
else {
node.middle = new TstNode(key, value, index);
break;
}
else if (node.code < code)
if (node.left !== null)
node = node.left;
else {
node.left = new TstNode(key, value, index);
break;
}
else if (node.right !== null)
node = node.right;
else {
node.right = new TstNode(key, value, index);
break;
}
}
}
search(key) {
let keylength = key.length, index = 0, node = this;
while (node !== null && index < keylength) {
let code = key[index];
if (code <= 90 && code >= 65)
code |= 32;
while (node !== null) {
if (code === node.code) {
if (keylength === ++index)
return node;
node = node.middle;
break;
}
node = node.code < code ? node.left : node.right;
}
}
return null;
}
}
class TernarySearchTree {
node = null;
insert(key, value) {
if (this.node === null)
this.node = new TstNode(key, value, 0);
else
this.node.add(key, value);
}
lookup(key) {
return this.node?.search(key)?.value ?? null;
}
}
var tree = new TernarySearchTree;
for (let i = 0;i < wellknownHeaderNames.length; ++i) {
let key = headerNameLowerCasedRecord[wellknownHeaderNames[i]];
tree.insert(key, key);
}
module.exports = {
TernarySearchTree,
tree
};
});
// undici/lib/core/util.js
var require_util = __commonJS((exports, module) => {
var assert = __require("node:assert"), { kDestroyed, kBodyUsed, kListeners, kBody } = require_symbols(), { IncomingMessage } = __require("node:http"), stream = __require("node:stream"), net = __require("node:net"), { Blob: Blob2 } = __require("node:buffer"), nodeUtil = __require("node:util"), { stringify } = __require("node:querystring"), { EventEmitter: EE } = __require("node:events"), { InvalidArgumentError } = require_errors(), { headerNameLowerCasedRecord } = require_constants2(), { tree } = require_tree(), [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v));
class BodyAsyncIterable {
constructor(body) {
this[kBody] = body, this[kBodyUsed] = !1;
}
async* [Symbol.asyncIterator]() {
assert(!this[kBodyUsed], "disturbed"), this[kBodyUsed] = !0, yield* this[kBody];
}
}
function wrapRequestBody(body) {
if (isStream(body)) {
if (bodyLength(body) === 0)
body.on("data", function() {
assert(!1);
});
if (typeof body.readableDidRead !== "boolean")
body[kBodyUsed] = !1, EE.prototype.on.call(body, "data", function() {
this[kBodyUsed] = !0;
});
return body;
} else if (body && typeof body.pipeTo === "function")
return new BodyAsyncIterable(body);
else if (body && typeof body !== "string" && !ArrayBuffer.isView(body) && isIterable(body))
return new BodyAsyncIterable(body);
else
return body;
}
function isStream(obj) {
return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function";
}
function isBlobLike(object) {
if (object === null)
return !1;
else if (object instanceof Blob2)
return !0;
else if (typeof object !== "object")
return !1;
else {
let sTag = object[Symbol.toStringTag];
return (sTag === "Blob" || sTag === "File") && (("stream" in object) && typeof object.stream === "function" || ("arrayBuffer" in object) && typeof object.arrayBuffer === "function");
}
}
function serializePathWithQuery(url, queryParams) {
if (url.includes("?") || url.includes("#"))
throw new Error('Query params cannot be passed when url already contains "?" or "#".');
let stringified = stringify(queryParams);
if (stringified)
url += "?" + stringified;
return url;
}
function isValidPort(port) {
let value = parseInt(port, 10);
return value === Number(port) && value >= 0 && value <= 65535;
}
function isHttpOrHttpsPrefixed(value) {
return value != null && value[0] === "h" && value[1] === "t" && value[2] === "t" && value[3] === "p" && (value[4] === ":" || value[4] === "s" && value[5] === ":");
}
function parseURL(url) {
if (typeof url === "string") {
if (url = new URL(url), !isHttpOrHttpsPrefixed(url.origin || url.protocol))
throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
return url;
}
if (!url || typeof url !== "object")
throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object.");
if (!(url instanceof URL)) {
if (url.port != null && url.port !== "" && isValidPort(url.port) === !1)
throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer.");
if (url.path != null && typeof url.path !== "string")
throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined.");
if (url.pathname != null && typeof url.pathname !== "string")
throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined.");
if (url.hostname != null && typeof url.hostname !== "string")
throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined.");
if (url.origin != null && typeof url.origin !== "string")
throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined.");
if (!isHttpOrHttpsPrefixed(url.origin || url.protocol))
throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
let port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80, origin = url.origin != null ? url.origin : `${url.protocol || ""}//${url.hostname || ""}:${port}`, path = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
if (origin[origin.length - 1] === "/")
origin = origin.slice(0, origin.length - 1);
if (path && path[0] !== "/")
path = `/${path}`;
return new URL(`${origin}${path}`);
}
if (!isHttpOrHttpsPrefixed(url.origin || url.protocol))
throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
return url;
}
function parseOrigin(url) {
if (url = parseURL(url), url.pathname !== "/" || url.search || url.hash)
throw new InvalidArgumentError("invalid url");
return url;
}
function getHostname(host) {
if (host[0] === "[") {
let idx2 = host.indexOf("]");
return assert(idx2 !== -1), host.substring(1, idx2);
}
let idx = host.indexOf(":");
if (idx === -1)
return host;
return host.substring(0, idx);
}
function getServerName(host) {
if (!host)
return null;
assert(typeof host === "string");
let servername = getHostname(host);
if (net.isIP(servername))
return "";
return servername;
}
function deepClone(obj) {
return JSON.parse(JSON.stringify(obj));
}
function isAsyncIterable(obj) {
return obj != null && typeof obj[Symbol.asyncIterator] === "function";
}
function isIterable(obj) {
return obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function");
}
function bodyLength(body) {
if (body == null)
return 0;
else if (isStream(body)) {
let state = body._readableState;
return state && state.objectMode === !1 && state.ended === !0 && Number.isFinite(state.length) ? state.length : null;
} else if (isBlobLike(body))
return body.size != null ? body.size : null;
else if (isBuffer(body))
return body.byteLength;
return null;
}
function isDestroyed(body) {
return body && !!(body.destroyed || body[kDestroyed] || stream.isDestroyed?.(body));
}
function destroy(stream2, err) {
if (stream2 == null || !isStream(stream2) || isDestroyed(stream2))
return;
if (typeof stream2.destroy === "function") {
if (Object.getPrototypeOf(stream2).constructor === IncomingMessage)
stream2.socket = null;
stream2.destroy(err);
} else if (err)
queueMicrotask(() => {
stream2.emit("error", err);
});
if (stream2.destroyed !== !0)
stream2[kDestroyed] = !0;
}
var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/;
function parseKeepAliveTimeout(val) {
let m = val.match(KEEPALIVE_TIMEOUT_EXPR);
return m ? parseInt(m[1], 10) * 1000 : null;
}
function headerNameToString(value) {
return typeof value === "string" ? headerNameLowerCasedRecord[value] ?? value.toLowerCase() : tree.lookup(value) ?? value.toString("latin1").toLowerCase();
}
function bufferToLowerCasedHeaderName(value) {
return tree.lookup(value) ?? value.toString("latin1").toLowerCase();
}
function parseHeaders(headers, obj) {
if (obj === void 0)
obj = {};
for (let i = 0;i < headers.length; i += 2) {
let key = headerNameToString(headers[i]), val = obj[key];
if (val) {
if (typeof val === "string")
val = [val], obj[key] = val;
val.push(headers[i + 1].toString("utf8"));
} else {
let headersValue = headers[i + 1];
if (typeof headersValue === "string")
obj[key] = headersValue;
else
obj[key] = Array.isArray(headersValue) ? headersValue.map((x) => x.toString("utf8")) : headersValue.toString("utf8");
}
}
if ("content-length" in obj && "content-disposition" in obj)
obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1");
return obj;
}
function parseRawHeaders(headers) {
let headersLength = headers.length, ret = new Array(headersLength), hasContentLength = !1, contentDispositionIdx = -1, key, val, kLen = 0;
for (let n = 0;n < headersLength; n += 2) {
if (key = headers[n], val = headers[n + 1], typeof key !== "string" && (key = key.toString()), typeof val !== "string" && (val = val.toString("utf8")), kLen = key.length, kLen === 14 && key[7] === "-" && (key === "content-length" || key.toLowerCase() === "content-length"))
hasContentLength = !0;
else if (kLen === 19 && key[7] === "-" && (key === "content-disposition" || key.toLowerCase() === "content-disposition"))
contentDispositionIdx = n + 1;
ret[n] = key, ret[n + 1] = val;
}
if (hasContentLength && contentDispositionIdx !== -1)
ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1");
return ret;
}
function encodeRawHeaders(headers) {
if (!Array.isArray(headers))
throw new TypeError("expected headers to be an array");
return headers.map((x) => Buffer.from(x));
}
function isBuffer(buffer) {
return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
}
function assertRequestHandler(handler, method, upgrade) {
if (!handler || typeof handler !== "object")
throw new InvalidArgumentError("handler must be an object");
if (typeof handler.onRequestStart === "function")
return;
if (typeof handler.onConnect !== "function")
throw new InvalidArgumentError("invalid onConnect method");
if (typeof handler.onError !== "function")
throw new InvalidArgumentError("invalid onError method");
if (typeof handler.onBodySent !== "function" && handler.onBodySent !== void 0)
throw new InvalidArgumentError("invalid onBodySent method");
if (upgrade || method === "CONNECT") {
if (typeof handler.onUpgrade !== "function")
throw new InvalidArgumentError("invalid onUpgrade method");
} else {
if (typeof handler.onHeaders !== "function")
throw new InvalidArgumentError("invalid onHeaders method");
if (typeof handler.onData !== "function")
throw new InvalidArgumentError("invalid onData method");
if (typeof handler.onComplete !== "function")
throw new InvalidArgumentError("invalid onComplete method");
}
}
function isDisturbed(body) {
return !!(body && (stream.isDisturbed(body) || body[kBodyUsed]));
}
function getSocketInfo(socket) {
return {
localAddress: socket.localAddress,
localPort: socket.localPort,
remoteAddress: socket.remoteAddress,
remotePort: socket.remotePort,
remoteFamily: socket.remoteFamily,
timeout: socket.timeout,
bytesWritten: socket.bytesWritten,
bytesRead: socket.bytesRead
};
}
function ReadableStreamFrom(iterable) {
let iterator;
return new ReadableStream({
async start() {
iterator = iterable[Symbol.asyncIterator]();
},
pull(controller) {
async function pull() {
let { done, value } = await iterator.next();
if (done)
queueMicrotask(() => {
controller.close(), controller.byobRequest?.respond(0);
});
else {
let buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
if (buf.byteLength)
controller.enqueue(new Uint8Array(buf));
else
return await pull();
}
}
return pull();
},
async cancel() {
await iterator.return();
},
type: "bytes"
});
}
function isFormDataLike(object) {
return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData";
}
function addAbortListener(signal, listener) {
if ("addEventListener" in signal)
return signal.addEventListener("abort", listener, { once: !0 }), () => signal.removeEventListener("abort", listener);
return signal.once("abort", listener), () => signal.removeListener("abort", listener);
}
var toUSVString = (() => {
if (typeof String.prototype.toWellFormed === "function")
return (value) => `${value}`.toWellFormed();
else
return nodeUtil.toUSVString;
})(), isUSVString = (() => {
if (typeof String.prototype.isWellFormed === "function")
return (value) => `${value}`.isWellFormed();
else
return (value) => toUSVString(value) === `${value}`;
})();
function isTokenCharCode(c) {
switch (c) {
case 34:
case 40:
case 41:
case 44:
case 47:
case 58:
case 59:
case 60:
case 61:
case 62:
case 63:
case 64:
case 91:
case 92:
case 93:
case 123:
case 125:
return !1;
default:
return c >= 33 && c <= 126;
}
}
function isValidHTTPToken(characters) {
if (characters.length === 0)
return !1;
for (let i = 0;i < characters.length; ++i)
if (!isTokenCharCode(characters.charCodeAt(i)))
return !1;
return !0;
}
var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
function isValidHeaderValue(characters) {
return !headerCharRegex.test(characters);
}
var rangeHeaderRegex = /^bytes (\d+)-(\d+)\/(\d+)?$/;
function parseRangeHeader(range) {
if (range == null || range === "")
return { start: 0, end: null, size: null };
let m = range ? range.match(rangeHeaderRegex) : null;
return m ? {
start: parseInt(m[1]),
end: m[2] ? parseInt(m[2]) : null,
size: m[3] ? parseInt(m[3]) : null
} : null;
}
function addListener(obj, name, listener) {
return (obj[kListeners] ??= []).push([name, listener]), obj.on(name, listener), obj;
}
function removeAllListeners(obj) {
if (obj[kListeners] != null) {
for (let [name, listener] of obj[kListeners])
obj.removeListener(name, listener);
obj[kListeners] = null;
}
return obj;
}
function errorRequest(client, request, err) {
try {
request.onError(err), assert(request.aborted);
} catch (err2) {
client.emit("error", err2);
}
}
var kEnumerableProperty = Object.create(null);
kEnumerableProperty.enumerable = !0;
var normalizedMethodRecordsBase = {
delete: "DELETE",
DELETE: "DELETE",
get: "GET",
GET: "GET",
head: "HEAD",
HEAD: "HEAD",
options: "OPTIONS",
OPTIONS: "OPTIONS",
post: "POST",
POST: "POST",
put: "PUT",
PUT: "PUT"
}, normalizedMethodRecords = {
...normalizedMethodRecordsBase,
patch: "patch",
PATCH: "PATCH"
};
Object.setPrototypeOf(normalizedMethodRecordsBase, null);
Object.setPrototypeOf(normalizedMethodRecords, null);
module.exports = {
kEnumerableProperty,
isDisturbed,
toUSVString,
isUSVString,
isBlobLike,
parseOrigin,
parseURL,
getServerName,
isStream,
isIterable,
isAsyncIterable,
isDestroyed,
headerNameToString,
bufferToLowerCasedHeaderName,
addListener,
removeAllListeners,
errorRequest,
parseRawHeaders,
encodeRawHeaders,
parseHeaders,
parseKeepAliveTimeout,
destroy,
bodyLength,
deepClone,
ReadableStreamFrom,
isBuffer,
assertRequestHandler,
getSocketInfo,
isFormDataLike,
serializePathWithQuery,
addAbortListener,
isValidHTTPToken,
isValidHeaderValue,
isTokenCharCode,
parseRangeHeader,
normalizedMethodRecordsBase,
normalizedMethodRecords,
isValidPort,
isHttpOrHttpsPrefixed,
nodeMajor,
nodeMinor,
safeHTTPMethods: Object.freeze(["GET", "HEAD", "OPTIONS", "TRACE"]),
wrapRequestBody
};
});
// undici/lib/web/fetch/webidl.js
var require_webidl = __commonJS((exports, module) => {
var { types, inspect } = __require("node:util"), { markAsUncloneable } = __require("node:worker_threads"), { toUSVString } = require_util(), FunctionPrototypeSymbolHasInstance = Function.call.bind(Function.prototype[Symbol.hasInstance]), webidl = {
converters: {},
util: {},
errors: {},
is: {}
};
webidl.errors.exception = function(message) {
return new TypeError(`${message.header}: ${message.message}`);
};
webidl.errors.conversionFailed = function(context) {
let plural = context.types.length === 1 ? "" : " one of", message = `${context.argument} could not be converted to${plural}: ${context.types.join(", ")}.`;
return webidl.errors.exception({
header: context.prefix,
message
});
};
webidl.errors.invalidArgument = function(context) {
return webidl.errors.exception({
header: context.prefix,
message: `"${context.value}" is an invalid ${context.type}.`
});
};
webidl.brandCheck = function(V, I) {
if (!FunctionPrototypeSymbolHasInstance(I, V)) {
let err = new TypeError("Illegal invocation");
throw err.code = "ERR_INVALID_THIS", err;
}
};
webidl.brandCheckMultiple = function(List) {
let prototypes = List.map((c) => webidl.util.MakeTypeAssertion(c));
return (V) => {
if (prototypes.every((typeCheck) => !typeCheck(V))) {
let err = new TypeError("Illegal invocation");
throw err.code = "ERR_INVALID_THIS", err;
}
};
};
webidl.argumentLengthCheck = function({ length }, min, ctx) {
if (length < min)
throw webidl.errors.exception({
message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`,
header: ctx
});
};
webidl.illegalConstructor = function() {
throw webidl.errors.exception({
header: "TypeError",
message: "Illegal constructor"
});
};
webidl.util.MakeTypeAssertion = function(I) {
return (O) => FunctionPrototypeSymbolHasInstance(I, O);
};
webidl.util.Type = function(V) {
switch (typeof V) {
case "undefined":
return 1;
case "boolean":
return 2;
case "string":
return 3;
case "symbol":
return 4;
case "number":
return 5;
case "bigint":
return 6;
case "function":
case "object": {
if (V === null)
return 7;
return 8;
}
}
};
webidl.util.Types = {
UNDEFINED: 1,
BOOLEAN: 2,
STRING: 3,
SYMBOL: 4,
NUMBER: 5,
BIGINT: 6,
NULL: 7,
OBJECT: 8
};
webidl.util.TypeValueToString = function(o) {
switch (webidl.util.Type(o)) {
case 1:
return "Undefined";
case 2:
return "Boolean";
case 3:
return "String";
case 4:
return "Symbol";
case 5:
return "Number";
case 6:
return "BigInt";
case 7:
return "Null";
case 8:
return "Object";
}
};
webidl.util.markAsUncloneable = markAsUncloneable || (() => {
});
webidl.util.ConvertToInt = function(V, bitLength, signedness, opts) {
let upperBound, lowerBound;
if (bitLength === 64)
if (upperBound = Math.pow(2, 53) - 1, signedness === "unsigned")
lowerBound = 0;
else
lowerBound = Math.pow(-2, 53) + 1;
else if (signedness === "unsigned")
lowerBound = 0, upperBound = Math.pow(2, bitLength) - 1;
else
lowerBound = Math.pow(-2, bitLength) - 1, upperBound = Math.pow(2, bitLength - 1) - 1;
let x = Number(V);
if (x === 0)
x = 0;
if (opts?.enforceRange === !0) {
if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY)
throw webidl.errors.exception({
header: "Integer conversion",
message: `Could not convert ${webidl.util.Stringify(V)} to an integer.`
});
if (x = webidl.util.IntegerPart(x), x < lowerBound || x > upperBound)
throw webidl.errors.exception({
header: "Integer conversion",
message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.`
});
return x;
}
if (!Number.isNaN(x) && opts?.clamp === !0) {
if (x = Math.min(Math.max(x, lowerBound), upperBound), Math.floor(x) % 2 === 0)
x = Math.floor(x);
else
x = Math.ceil(x);
return x;
}
if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY)
return 0;
if (x = webidl.util.IntegerPart(x), x = x % Math.pow(2, bitLength), signedness === "signed" && x >= Math.pow(2, bitLength) - 1)
return x - Math.pow(2, bitLength);
return x;
};
webidl.util.IntegerPart = function(n) {
let r = Math.floor(Math.abs(n));
if (n < 0)
return -1 * r;
return r;
};
webidl.util.Stringify = function(V) {
switch (webidl.util.Type(V)) {
case 4:
return `Symbol(${V.description})`;
case 8:
return inspect(V);
case 3:
return `"${V}"`;
default:
return `${V}`;
}
};
webidl.sequenceConverter = function(converter) {
return (V, prefix, argument, Iterable) => {
if (webidl.util.Type(V) !== 8)
throw webidl.errors.exception({
header: prefix,
message: `${argument} (${webidl.util.Stringify(V)}) is not iterable.`
});
let method = typeof Iterable === "function" ? Iterable() : V?.[Symbol.iterator]?.(), seq = [], index = 0;
if (method === void 0 || typeof method.next !== "function")
throw webidl.errors.exception({
header: prefix,
message: `${argument} is not iterable.`
});
while (!0) {
let { done, value } = method.next();
if (done)
break;
seq.push(converter(value, prefix, `${argument}[${index++}]`));
}
return seq;
};
};
webidl.recordConverter = function(keyConverter, valueConverter) {
return (O, prefix, argument) => {
if (webidl.util.Type(O) !== 8)
throw webidl.errors.exception({
header: prefix,
message: `${argument} ("${webidl.util.TypeValueToString(O)}") is not an Object.`
});
let result = {};
if (!types.isProxy(O)) {
let keys2 = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)];
for (let key of keys2) {
let keyName = webidl.util.Stringify(key), typedKey = keyConverter(key, prefix, `Key ${keyName} in ${argument}`), typedValue = valueConverter(O[key], prefix, `${argument}[${keyName}]`);
result[typedKey] = typedValue;
}
return result;
}
let keys = Reflect.ownKeys(O);
for (let key of keys)
if (Reflect.getOwnPropertyDescriptor(O, key)?.enumerable) {
let typedKey = keyConverter(key, prefix, argument), typedValue = valueConverter(O[key], prefix, argument);
result[typedKey] = typedValue;
}
return result;
};
};
webidl.interfaceConverter = function(TypeCheck, name) {
return (V, prefix, argument) => {
if (!TypeCheck(V))
throw webidl.errors.exception({
header: prefix,
message: `Expected ${argument} ("${webidl.util.Stringify(V)}") to be an instance of ${name}.`
});
return V;
};
};
webidl.dictionaryConverter = function(converters) {
return (dictionary, prefix, argument) => {
let dict = {};
if (dictionary != null && webidl.util.Type(dictionary) !== 8)
throw webidl.errors.exception({
header: prefix,
message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
});
for (let options of converters) {
let { key, defaultValue, required, converter } = options;
if (required === !0) {
if (dictionary == null || !Object.hasOwn(dictionary, key))
throw webidl.errors.exception({
header: prefix,
message: `Missing required key "${key}".`
});
}
let value = dictionary?.[key], hasDefault = defaultValue !== void 0;
if (hasDefault && value === void 0)
value = defaultValue();
if (required || hasDefault || value !== void 0) {
if (value = converter(value, prefix, `${argument}.${key}`), options.allowedValues && !options.allowedValues.includes(value))
throw webidl.errors.exception({
header: prefix,
message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.`
});
dict[key] = value;
}
}
return dict;
};
};
webidl.nullableConverter = function(converter) {
return (V, prefix, argument) => {
if (V === null)
return V;
return converter(V, prefix, argument);
};
};
webidl.is.ReadableStream = webidl.util.MakeTypeAssertion(ReadableStream);
webidl.is.Blob = webidl.util.MakeTypeAssertion(Blob);
webidl.is.URLSearchParams = webidl.util.MakeTypeAssertion(URLSearchParams);
webidl.is.File = webidl.util.MakeTypeAssertion(globalThis.File ?? __require("node:buffer").File);
webidl.is.URL = webidl.util.MakeTypeAssertion(URL);
webidl.is.AbortSignal = webidl.util.MakeTypeAssertion(AbortSignal);
webidl.is.MessagePort = webidl.util.MakeTypeAssertion(MessagePort);
webidl.converters.DOMString = function(V, prefix, argument, opts) {
if (V === null && opts?.legacyNullToEmptyString)
return "";
if (typeof V === "symbol")
throw webidl.errors.exception({
header: prefix,
message: `${argument} is a symbol, which cannot be converted to a DOMString.`
});
return String(V);
};
webidl.converters.ByteString = function(V, prefix, argument) {
if (typeof V === "symbol")
throw webidl.errors.exception({
header: prefix,
message: `${argument} is a symbol, which cannot be converted to a ByteString.`
});
let x = String(V);
for (let index = 0;index < x.length; index++)
if (x.charCodeAt(index) > 255)
throw new TypeError(`Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.`);
return x;
};
webidl.converters.USVString = toUSVString;
webidl.converters.boolean = function(V) {
return Boolean(V);
};
webidl.converters.any = function(V) {
return V;
};
webidl.converters["long long"] = function(V, prefix, argument) {
return webidl.util.ConvertToInt(V, 64, "signed", void 0, prefix, argument);
};
webidl.converters["unsigned long long"] = function(V, prefix, argument) {
return webidl.util.ConvertToInt(V, 64, "unsigned", void 0, prefix, argument);
};
webidl.converters["unsigned long"] = function(V, prefix, argument) {
return webidl.util.ConvertToInt(V, 32, "unsigned", void 0, prefix, argument);
};
webidl.converters["unsigned short"] = function(V, prefix, argument, opts) {
return webidl.util.ConvertToInt(V, 16, "unsigned", opts, prefix, argument);
};
webidl.converters.ArrayBuffer = function(V, prefix, argument, opts) {
if (webidl.util.Type(V) !== 8 || !types.isAnyArrayBuffer(V))
throw webidl.errors.conversionFailed({
prefix,
argument: `${argument} ("${webidl.util.Stringify(V)}")`,
types: ["ArrayBuffer"]
});
if (opts?.allowShared === !1 && types.isSharedArrayBuffer(V))
throw webidl.errors.exception({
header: "ArrayBuffer",
message: "SharedArrayBuffer is not allowed."
});
if (V.resizable || V.growable)
throw webidl.errors.exception({
header: "ArrayBuffer",
message: "Received a resizable ArrayBuffer."
});
return V;
};
webidl.converters.TypedArray = function(V, T, prefix, name, opts) {
if (webidl.util.Type(V) !== 8 || !types.isTypedArray(V) || V.constructor.name !== T.name)
throw webidl.errors.conversionFailed({
prefix,
argument: `${name} ("${webidl.util.Stringify(V)}")`,
types: [T.name]
});
if (opts?.allowShared === !1 && types.isSharedArrayBuffer(V.buffer))
throw webidl.errors.exception({
header: "ArrayBuffer",
message: "SharedArrayBuffer is not allowed."
});
if (V.buffer.resizable || V.buffer.growable)
throw webidl.errors.exception({
header: "ArrayBuffer",
message: "Received a resizable ArrayBuffer."
});
return V;
};
webidl.converters.DataView = function(V, prefix, name, opts) {
if (webidl.util.Type(V) !== 8 || !types.isDataView(V))
throw webidl.errors.exception({
header: prefix,
message: `${name} is not a DataView.`
});
if (opts?.allowShared === !1 && types.isSharedArrayBuffer(V.buffer))
throw webidl.errors.exception({
header: "ArrayBuffer",
message: "SharedArrayBuffer is not allowed."
});
if (V.buffer.resizable || V.buffer.growable)
throw webidl.errors.exception({
header: "ArrayBuffer",
message: "Received a resizable ArrayBuffer."
});
return V;
};
webidl.converters["sequence<ByteString>"] = webidl.sequenceConverter(webidl.converters.ByteString);
webidl.converters["sequence<sequence<ByteString>>"] = webidl.sequenceConverter(webidl.converters["sequence<ByteString>"]);
webidl.converters["record<ByteString, ByteString>"] = webidl.recordConverter(webidl.converters.ByteString, webidl.converters.ByteString);
webidl.converters.Blob = webidl.interfaceConverter(webidl.is.Blob, "Blob");
webidl.converters.AbortSignal = webidl.interfaceConverter(webidl.is.AbortSignal, "AbortSignal");
module.exports = {
webidl
};
});
// undici/lib/web/fetch/util.js
var require_util2 = __commonJS((exports, module) => {
var { Transform } = __require("node:stream"), zlib = __require("node:zlib"), { redirectStatusSet, referrerPolicyTokens, badPortsSet } = require_constants(), { getGlobalOrigin } = require_global(), { collectASequenceOfCodePoints, collectAnHTTPQuotedString, removeChars, parseMIMEType } = require_data_url(), { performance: performance2 } = __require("node:perf_hooks"), { ReadableStreamFrom, isValidHTTPToken, normalizedMethodRecordsBase } = require_util(), assert = __require("node:assert"), { isUint8Array } = __require("node:util/types"), { webidl } = require_webidl(), supportedHashes = [], crypto;
try {
crypto = __require("node:crypto");
let possibleRelevantHashes = ["sha256", "sha384", "sha512"];
supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
} catch {
}
function responseURL(response) {
let urlList = response.urlList, length = urlList.length;
return length === 0 ? null : urlList[length - 1].toString();
}
function responseLocationURL(response, requestFragment) {
if (!redirectStatusSet.has(response.status))
return null;
let location = response.headersList.get("location", !0);
if (location !== null && isValidHeaderValue(location)) {
if (!isValidEncodedURL(location))
location = normalizeBinaryStringToUtf8(location);
location = new URL(location, responseURL(response));
}
if (location && !location.hash)
location.hash = requestFragment;
return location;
}
function isValidEncodedURL(url) {
for (let i = 0;i < url.length; ++i) {
let code = url.charCodeAt(i);
if (code > 126 || code < 32)
return !1;
}
return !0;
}
function normalizeBinaryStringToUtf8(value) {
return Buffer.from(value, "binary").toString("utf8");
}
function requestCurrentURL(request) {
return request.urlList[request.urlList.length - 1];
}
function requestBadPort(request) {
let url = requestCurrentURL(request);
if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port))
return "blocked";
return "allowed";
}
function isErrorLike(object) {
return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException");
}
function isValidReasonPhrase(statusText) {
for (let i = 0;i < statusText.length; ++i) {
let c = statusText.charCodeAt(i);
if (!(c === 9 || c >= 32 && c <= 126 || c >= 128 && c <= 255))
return !1;
}
return !0;
}
var isValidHeaderName = isValidHTTPToken;
function isValidHeaderValue(potentialValue) {
return (potentialValue[0] === "\t" || potentialValue[0] === " " || potentialValue[potentialValue.length - 1] === "\t" || potentialValue[potentialValue.length - 1] === " " || potentialValue.includes(`
`) || potentialValue.includes("\r") || potentialValue.includes("\x00")) === !1;
}
function parseReferrerPolicy(actualResponse) {
let policyHeader = (actualResponse.headersList.get("referrer-policy", !0) ?? "").split(","), policy = "";
if (policyHeader.length)
for (let i = policyHeader.length;i !== 0; i--) {
let token = policyHeader[i - 1].trim();
if (referrerPolicyTokens.has(token)) {
policy = token;
break;
}
}
return policy;
}
function setRequestReferrerPolicyOnRedirect(request, actualResponse) {
let policy = parseReferrerPolicy(actualResponse);
if (policy !== "")
request.referrerPolicy = policy;
}
function crossOriginResourcePolicyCheck() {
return "allowed";
}
function corsCheck() {
return "success";
}
function TAOCheck() {
return "success";
}
function appendFetchMetadata(httpRequest) {
let header = null;
header = httpRequest.mode, httpRequest.headersList.set("sec-fetch-mode", header, !0);
}
function appendRequestOriginHeader(request) {
let serializedOrigin = request.origin;
if (serializedOrigin === "client" || serializedOrigin === void 0)
return;
if (request.responseTainting === "cors" || request.mode === "websocket")
request.headersList.append("origin", serializedOrigin, !0);
else if (request.method !== "GET" && request.method !== "HEAD") {
switch (request.referrerPolicy) {
case "no-referrer":
serializedOrigin = null;
break;
case "no-referrer-when-downgrade":
case "strict-origin":
case "strict-origin-when-cross-origin":
if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request)))
serializedOrigin = null;
break;
case "same-origin":
if (!sameOrigin(request, requestCurrentURL(request)))
serializedOrigin = null;
break;
default:
}
request.headersList.append("origin", serializedOrigin, !0);
}
}
function coarsenTime(timestamp, crossOriginIsolatedCapability) {
return timestamp;
}
function clampAndCoarsenConnectionTimingInfo(connectionTimingInfo, defaultStartTime, crossOriginIsolatedCapability) {
if (!connectionTimingInfo?.startTime || connectionTimingInfo.startTime < defaultStartTime)
return {
domainLookupStartTime: defaultStartTime,
domainLookupEndTime: defaultStartTime,
connectionStartTime: defaultStartTime,
connectionEndTime: defaultStartTime,
secureConnectionStartTime: defaultStartTime,
ALPNNegotiatedProtocol: connectionTimingInfo?.ALPNNegotiatedProtocol
};
return {
domainLookupStartTime: coarsenTime(connectionTimingInfo.domainLookupStartTime, crossOriginIsolatedCapability),
domainLookupEndTime: coarsenTime(connectionTimingInfo.domainLookupEndTime, crossOriginIsolatedCapability),
connectionStartTime: coarsenTime(connectionTimingInfo.connectionStartTime, crossOriginIsolatedCapability),
connectionEndTime: coarsenTime(connectionTimingInfo.connectionEndTime, crossOriginIsolatedCapability),
secureConnectionStartTime: coarsenTime(connectionTimingInfo.secureConnectionStartTime, crossOriginIsolatedCapability),
ALPNNegotiatedProtocol: connectionTimingInfo.ALPNNegotiatedProtocol
};
}
function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
return coarsenTime(performance2.now(), crossOriginIsolatedCapability);
}
function createOpaqueTimingInfo(timingInfo) {
return {
startTime: timingInfo.startTime ?? 0,
redirectStartTime: 0,
redirectEndTime: 0,
postRedirectStartTime: timingInfo.startTime ?? 0,
finalServiceWorkerStartTime: 0,
finalNetworkResponseStartTime: 0,
finalNetworkRequestStartTime: 0,
endTime: 0,
encodedBodySize: 0,
decodedBodySize: 0,
finalConnectionTimingInfo: null
};
}
function makePolicyContainer() {
return {
referrerPolicy: "strict-origin-when-cross-origin"
};
}
function clonePolicyContainer(policyContainer) {
return {
referrerPolicy: policyContainer.referrerPolicy
};
}
function determineRequestsReferrer(request) {
let policy = request.referrerPolicy;
assert(policy);
let referrerSource = null;
if (request.referrer === "client") {
let globalOrigin = getGlobalOrigin();
if (!globalOrigin || globalOrigin.origin === "null")
return "no-referrer";
referrerSource = new URL(globalOrigin);
} else if (webidl.is.URL(request.referrer))
referrerSource = request.referrer;
let referrerURL = stripURLForReferrer(referrerSource), referrerOrigin = stripURLForReferrer(referrerSource, !0);
if (referrerURL.toString().length > 4096)
referrerURL = referrerOrigin;
switch (policy) {
case "no-referrer":
return "no-referrer";
case "origin":
if (referrerOrigin != null)
return referrerOrigin;
return stripURLForReferrer(referrerSource, !0);
case "unsafe-url":
return referrerURL;
case "strict-origin": {
let currentURL = requestCurrentURL(request);
if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL))
return "no-referrer";
return referrerOrigin;
}
case "strict-origin-when-cross-origin": {
let currentURL = requestCurrentURL(request);
if (sameOrigin(referrerURL, currentURL))
return referrerURL;
if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL))
return "no-referrer";
return referrerOrigin;
}
case "same-origin":
if (sameOrigin(request, referrerURL))
return referrerURL;
return "no-referrer";
case "origin-when-cross-origin":
if (sameOrigin(request, referrerURL))
return referrerURL;
return referrerOrigin;
case "no-referrer-when-downgrade": {
let currentURL = requestCurrentURL(request);
if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL))
return "no-referrer";
return referrerOrigin;
}
}
}
function stripURLForReferrer(url, originOnly = !1) {
if (assert(webidl.is.URL(url)), url = new URL(url), urlIsLocal(url))
return "no-referrer";
if (url.username = "", url.password = "", url.hash = "", originOnly === !0)
url.pathname = "", url.search = "";
return url;
}
var potentialleTrustworthyIPv4RegExp = new RegExp("^(?:(?:127\\.)(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){2}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9]))$"), potentialleTrustworthyIPv6RegExp = new RegExp("^(?:(?:(?:0{1,4}):){7}(?:(?:0{0,3}1))|(?:(?:0{1,4}):){1,6}(?::(?:0{0,3}1))|(?:::(?:0{0,3}1))|)$");
function isOriginIPPotentiallyTrustworthy(origin) {
if (origin.includes(":")) {
if (origin[0] === "[" && origin[origin.length - 1] === "]")
origin = origin.slice(1, -1);
return potentialleTrustworthyIPv6RegExp.test(origin);
}
return potentialleTrustworthyIPv4RegExp.test(origin);
}
function isOriginPotentiallyTrustworthy(origin) {
if (origin == null || origin === "null")
return !1;
if (origin = new URL(origin), origin.protocol === "https:" || origin.protocol === "wss:")
return !0;
if (isOriginIPPotentiallyTrustworthy(origin.hostname))
return !0;
if (origin.hostname === "localhost" || origin.hostname === "localhost.")
return !0;
if (origin.hostname.endsWith(".localhost") || origin.hostname.endsWith(".localhost."))
return !0;
if (origin.protocol === "file:")
return !0;
return !1;
}
function isURLPotentiallyTrustworthy(url) {
if (!webidl.is.URL(url))
return !1;
if (url.href === "about:blank" || url.href === "about:srcdoc")
return !0;
if (url.protocol === "data:")
return !0;
if (url.protocol === "blob:")
return !0;
return isOriginPotentiallyTrustworthy(url.origin);
}
function bytesMatch(bytes, metadataList) {
if (crypto === void 0)
return !0;
let parsedMetadata = parseMetadata(metadataList);
if (parsedMetadata === "no metadata")
return !0;
if (parsedMetadata.length === 0)
return !0;
let strongest = getStrongestMetadata(parsedMetadata), metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest);
for (let item of metadata) {
let { algo: algorithm, hash: expectedValue } = item, actualValue = crypto.createHash(algorithm).update(bytes).digest("base64");
if (actualValue[actualValue.length - 1] === "=")
if (actualValue[actualValue.length - 2] === "=")
actualValue = actualValue.slice(0, -2);
else
actualValue = actualValue.slice(0, -1);
if (compareBase64Mixed(actualValue, expectedValue))
return !0;
}
return !1;
}
var parseHashWithOptions = /(?<algo>sha256|sha384|sha512)-((?<hash>[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i;
function parseMetadata(metadata) {
let result = [], empty = !0;
for (let token of metadata.split(" ")) {
empty = !1;
let parsedToken = parseHashWithOptions.exec(token);
if (parsedToken === null || parsedToken.groups === void 0 || parsedToken.groups.algo === void 0)
continue;
let algorithm = parsedToken.groups.algo.toLowerCase();
if (supportedHashes.includes(algorithm))
result.push(parsedToken.groups);
}
if (empty === !0)
return "no metadata";
return result;
}
function getStrongestMetadata(metadataList) {
let algorithm = metadataList[0].algo;
if (algorithm[3] === "5")
return algorithm;
for (let i = 1;i < metadataList.length; ++i) {
let metadata = metadataList[i];
if (metadata.algo[3] === "5") {
algorithm = "sha512";
break;
} else if (algorithm[3] === "3")
continue;
else if (metadata.algo[3] === "3")
algorithm = "sha384";
}
return algorithm;
}
function filterMetadataListByAlgorithm(metadataList, algorithm) {
if (metadataList.length === 1)
return metadataList;
let pos = 0;
for (let i = 0;i < metadataList.length; ++i)
if (metadataList[i].algo === algorithm)
metadataList[pos++] = metadataList[i];
return metadataList.length = pos, metadataList;
}
function compareBase64Mixed(actualValue, expectedValue) {
if (actualValue.length !== expectedValue.length)
return !1;
for (let i = 0;i < actualValue.length; ++i)
if (actualValue[i] !== expectedValue[i]) {
if (actualValue[i] === "+" && expectedValue[i] === "-" || actualValue[i] === "/" && expectedValue[i] === "_")
continue;
return !1;
}
return !0;
}
function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) {
}
function sameOrigin(A, B) {
if (A.origin === B.origin && A.origin === "null")
return !0;
if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port)
return !0;
return !1;
}
function createDeferredPromise() {
let res, rej;
return { promise: new Promise((resolve, reject) => {
res = resolve, rej = reject;
}), resolve: res, reject: rej };
}
function isAborted(fetchParams) {
return fetchParams.controller.state === "aborted";
}
function isCancelled(fetchParams) {
return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated";
}
function normalizeMethod(method) {
return normalizedMethodRecordsBase[method.toLowerCase()] ?? method;
}
function serializeJavascriptValueToJSONString(value) {
let result = JSON.stringify(value);
if (result === void 0)
throw new TypeError("Value is not JSON serializable");
return assert(typeof result === "string"), result;
}
var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
function createIterator(name, kInternalIterator, keyIndex = 0, valueIndex = 1) {
class FastIterableIterator {
#target;
#kind;
#index;
constructor(target, kind) {
this.#target = target, this.#kind = kind, this.#index = 0;
}
next() {
if (typeof this !== "object" || this === null || !(#target in this))
throw new TypeError(`'next' called on an object that does not implement interface ${name} Iterator.`);
let index = this.#index, values = kInternalIterator(this.#target), len = values.length;
if (index >= len)
return {
value: void 0,
done: !0
};
let { [keyIndex]: key, [valueIndex]: value } = values[index];
this.#index = index + 1;
let result;
switch (this.#kind) {
case "key":
result = key;
break;
case "value":
result = value;
break;
case "key+value":
result = [key, value];
break;
}
return {
value: result,
done: !1
};
}
}
return delete FastIterableIterator.prototype.constructor, Object.setPrototypeOf(FastIterableIterator.prototype, esIteratorPrototype), Object.defineProperties(FastIterableIterator.prototype, {
[Symbol.toStringTag]: {
writable: !1,
enumerable: !1,
configurable: !0,
value: `${name} Iterator`
},
next: { writable: !0, enumerable: !0, configurable: !0 }
}), function(target, kind) {
return new FastIterableIterator(target, kind);
};
}
function iteratorMixin(name, object, kInternalIterator, keyIndex = 0, valueIndex = 1) {
let makeIterator = createIterator(name, kInternalIterator, keyIndex, valueIndex), properties = {
keys: {
writable: !0,
enumerable: !0,
configurable: !0,
value: function keys() {
return webidl.brandCheck(this, object), makeIterator(this, "key");
}
},
values: {
writable: !0,
enumerable: !0,
configurable: !0,
value: function values() {
return webidl.brandCheck(this, object), makeIterator(this, "value");
}
},
entries: {
writable: !0,
enumerable: !0,
configurable: !0,
value: function entries() {
return webidl.brandCheck(this, object), makeIterator(this, "key+value");
}
},
forEach: {
writable: !0,
enumerable: !0,
configurable: !0,
value: function forEach(callbackfn, thisArg = globalThis) {
if (webidl.brandCheck(this, object), webidl.argumentLengthCheck(arguments, 1, `${name}.forEach`), typeof callbackfn !== "function")
throw new TypeError(`Failed to execute 'forEach' on '${name}': parameter 1 is not of type 'Function'.`);
for (let { 0: key, 1: value } of makeIterator(this, "key+value"))
callbackfn.call(thisArg, value, key, this);
}
}
};
return Object.defineProperties(object.prototype, {
...properties,
[Symbol.iterator]: {
writable: !0,
enumerable: !1,
configurable: !0,
value: properties.entries.value
}
});
}
function fullyReadBody(body, processBody, processBodyError) {
let successSteps = processBody, errorSteps = processBodyError, reader;
try {
reader = body.stream.getReader();
} catch (e) {
errorSteps(e);
return;
}
readAllBytes(reader, successSteps, errorSteps);
}
function readableStreamClose(controller) {
try {
controller.close(), controller.byobRequest?.respond(0);
} catch (err) {
if (!err.message.includes("Controller is already closed") && !err.message.includes("ReadableStream is already closed"))
throw err;
}
}
var invalidIsomorphicEncodeValueRegex = /[^\x00-\xFF]/;
function isomorphicEncode(input) {
return assert(!invalidIsomorphicEncodeValueRegex.test(input)), input;
}
async function readAllBytes(reader, successSteps, failureSteps) {
let bytes = [], byteLength = 0;
try {
do {
let { done, value: chunk } = await reader.read();
if (done) {
successSteps(Buffer.concat(bytes, byteLength));
return;
}
if (!isUint8Array(chunk)) {
failureSteps(TypeError("Received non-Uint8Array chunk"));
return;
}
bytes.push(chunk), byteLength += chunk.length;
} while (!0);
} catch (e) {
failureSteps(e);
}
}
function urlIsLocal(url) {
assert("protocol" in url);
let protocol = url.protocol;
return protocol === "about:" || protocol === "blob:" || protocol === "data:";
}
function urlHasHttpsScheme(url) {
return typeof url === "string" && url[5] === ":" && url[0] === "h" && url[1] === "t" && url[2] === "t" && url[3] === "p" && url[4] === "s" || url.protocol === "https:";
}
function urlIsHttpHttpsScheme(url) {
assert("protocol" in url);
let protocol = url.protocol;
return protocol === "http:" || protocol === "https:";
}
function simpleRangeHeaderValue(value, allowWhitespace) {
let data = value;
if (!data.startsWith("bytes"))
return "failure";
let position = { position: 5 };
if (allowWhitespace)
collectASequenceOfCodePoints((char) => char === "\t" || char === " ", data, position);
if (data.charCodeAt(position.position) !== 61)
return "failure";
if (position.position++, allowWhitespace)
collectASequenceOfCodePoints((char) => char === "\t" || char === " ", data, position);
let rangeStart = collectASequenceOfCodePoints((char) => {
let code = char.charCodeAt(0);
return code >= 48 && code <= 57;
}, data, position), rangeStartValue = rangeStart.length ? Number(rangeStart) : null;
if (allowWhitespace)
collectASequenceOfCodePoints((char) => char === "\t" || char === " ", data, position);
if (data.charCodeAt(position.position) !== 45)
return "failure";
if (position.position++, allowWhitespace)
collectASequenceOfCodePoints((char) => char === "\t" || char === " ", data, position);
let rangeEnd = collectASequenceOfCodePoints((char) => {
let code = char.charCodeAt(0);
return code >= 48 && code <= 57;
}, data, position), rangeEndValue = rangeEnd.length ? Number(rangeEnd) : null;
if (position.position < data.length)
return "failure";
if (rangeEndValue === null && rangeStartValue === null)
return "failure";
if (rangeStartValue > rangeEndValue)
return "failure";
return { rangeStartValue, rangeEndValue };
}
function buildContentRange(rangeStart, rangeEnd, fullLength) {
let contentRange = "bytes ";
return contentRange += isomorphicEncode(`${rangeStart}`), contentRange += "-", contentRange += isomorphicEncode(`${rangeEnd}`), contentRange += "/", contentRange += isomorphicEncode(`${fullLength}`), contentRange;
}
class InflateStream extends Transform {
#zlibOptions;
constructor(zlibOptions) {
super();
this.#zlibOptions = zlibOptions;
}
_transform(chunk, encoding, callback) {
if (!this._inflateStream) {
if (chunk.length === 0) {
callback();
return;
}
this._inflateStream = (chunk[0] & 15) === 8 ? zlib.createInflate(this.#zlibOptions) : zlib.createInflateRaw(this.#zlibOptions), this._inflateStream.on("data", this.push.bind(this)), this._inflateStream.on("end", () => this.push(null)), this._inflateStream.on("error", (err) => this.destroy(err));
}
this._inflateStream.write(chunk, encoding, callback);
}
_final(callback) {
if (this._inflateStream)
this._inflateStream.end(), this._inflateStream = null;
callback();
}
}
function createInflate(zlibOptions) {
return new InflateStream(zlibOptions);
}
function extractMimeType(headers) {
let charset = null, essence = null, mimeType = null, values = getDecodeSplit("content-type", headers);
if (values === null)
return "failure";
for (let value of values) {
let temporaryMimeType = parseMIMEType(value);
if (temporaryMimeType === "failure" || temporaryMimeType.essence === "*/*")
continue;
if (mimeType = temporaryMimeType, mimeType.essence !== essence) {
if (charset = null, mimeType.parameters.has("charset"))
charset = mimeType.parameters.get("charset");
essence = mimeType.essence;
} else if (!mimeType.parameters.has("charset") && charset !== null)
mimeType.parameters.set("charset", charset);
}
if (mimeType == null)
return "failure";
return mimeType;
}
function gettingDecodingSplitting(value) {
let input = value, position = { position: 0 }, values = [], temporaryValue = "";
while (position.position < input.length) {
if (temporaryValue += collectASequenceOfCodePoints((char) => char !== '"' && char !== ",", input, position), position.position < input.length)
if (input.charCodeAt(position.position) === 34) {
if (temporaryValue += collectAnHTTPQuotedString(input, position), position.position < input.length)
continue;
} else
assert(input.charCodeAt(position.position) === 44), position.position++;
temporaryValue = removeChars(temporaryValue, !0, !0, (char) => char === 9 || char === 32), values.push(temporaryValue), temporaryValue = "";
}
return values;
}
function getDecodeSplit(name, list) {
let value = list.get(name, !0);
if (value === null)
return null;
return gettingDecodingSplitting(value);
}
var textDecoder = /* @__PURE__ */ new TextDecoder;
function utf8DecodeBytes(buffer) {
if (buffer.length === 0)
return "";
if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191)
buffer = buffer.subarray(3);
return textDecoder.decode(buffer);
}
class EnvironmentSettingsObjectBase {
get baseUrl() {
return getGlobalOrigin();
}
get origin() {
return this.baseUrl?.origin;
}
policyContainer = makePolicyContainer();
}
class EnvironmentSettingsObject {
settingsObject = new EnvironmentSettingsObjectBase;
}
var environmentSettingsObject = new EnvironmentSettingsObject;
module.exports = {
isAborted,
isCancelled,
isValidEncodedURL,
createDeferredPromise,
ReadableStreamFrom,
tryUpgradeRequestToAPotentiallyTrustworthyURL,
clampAndCoarsenConnectionTimingInfo,
coarsenedSharedCurrentTime,
determineRequestsReferrer,
makePolicyContainer,
clonePolicyContainer,
appendFetchMetadata,
appendRequestOriginHeader,
TAOCheck,
corsCheck,
crossOriginResourcePolicyCheck,
createOpaqueTimingInfo,
setRequestReferrerPolicyOnRedirect,
isValidHTTPToken,
requestBadPort,
requestCurrentURL,
responseURL,
responseLocationURL,
isURLPotentiallyTrustworthy,
isValidReasonPhrase,
sameOrigin,
normalizeMethod,
serializeJavascriptValueToJSONString,
iteratorMixin,
createIterator,
isValidHeaderName,
isValidHeaderValue,
isErrorLike,
fullyReadBody,
bytesMatch,
readableStreamClose,
isomorphicEncode,
urlIsLocal,
urlHasHttpsScheme,
urlIsHttpHttpsScheme,
readAllBytes,
simpleRangeHeaderValue,
buildContentRange,
parseMetadata,
createInflate,
extractMimeType,
getDecodeSplit,
utf8DecodeBytes,
environmentSettingsObject,
isOriginIPPotentiallyTrustworthy
};
});
// undici/lib/web/websocket/constants.js
var require_constants3 = __commonJS((exports, module) => {
var staticPropertyDescriptors = {
enumerable: !0,
writable: !1,
configurable: !1
}, states = {
CONNECTING: 0,
OPEN: 1,
CLOSING: 2,
CLOSED: 3
}, sentCloseFrameState = {
SENT: 1,
RECEIVED: 2
}, opcodes = {
CONTINUATION: 0,
TEXT: 1,
BINARY: 2,
CLOSE: 8,
PING: 9,
PONG: 10
}, parserStates = {
INFO: 0,
PAYLOADLENGTH_16: 2,
PAYLOADLENGTH_64: 3,
READ_DATA: 4
}, emptyBuffer = Buffer.allocUnsafe(0), sendHints = {
text: 1,
typedArray: 2,
arrayBuffer: 3,
blob: 4
};
module.exports = {
uid: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
sentCloseFrameState,
staticPropertyDescriptors,
states,
opcodes,
maxUnsigned16Bit: 65535,
parserStates,
emptyBuffer,
sendHints
};
});
// undici/lib/web/websocket/util.js
var require_util3 = __commonJS((exports, module) => {
var { states, opcodes } = require_constants3(), { isUtf8 } = __require("node:buffer"), { collectASequenceOfCodePointsFast, removeHTTPWhitespace } = require_data_url();
function isConnecting(readyState) {
return readyState === states.CONNECTING;
}
function isEstablished(readyState) {
return readyState === states.OPEN;
}
function isClosing(readyState) {
return readyState === states.CLOSING;
}
function isClosed(readyState) {
return readyState === states.CLOSED;
}
function fireEvent(e, target, eventFactory = (type, init) => new Event(type, init), eventInitDict = {}) {
let event = eventFactory(e, eventInitDict);
target.dispatchEvent(event);
}
function websocketMessageReceived(handler, type, data) {
handler.onMessage(type, data);
}
function toArrayBuffer(buffer) {
if (buffer.byteLength === buffer.buffer.byteLength)
return buffer.buffer;
return new Uint8Array(buffer).buffer;
}
function isValidSubprotocol(protocol) {
if (protocol.length === 0)
return !1;
for (let i = 0;i < protocol.length; ++i) {
let code = protocol.charCodeAt(i);
if (code < 33 || code > 126 || code === 34 || code === 40 || code === 41 || code === 44 || code === 47 || code === 58 || code === 59 || code === 60 || code === 61 || code === 62 || code === 63 || code === 64 || code === 91 || code === 92 || code === 93 || code === 123 || code === 125)
return !1;
}
return !0;
}
function isValidStatusCode(code) {
if (code >= 1000 && code < 1015)
return code !== 1004 && code !== 1005 && code !== 1006;
return code >= 3000 && code <= 4999;
}
function isControlFrame(opcode) {
return opcode === opcodes.CLOSE || opcode === opcodes.PING || opcode === opcodes.PONG;
}
function isContinuationFrame(opcode) {
return opcode === opcodes.CONTINUATION;
}
function isTextBinaryFrame(opcode) {
return opcode === opcodes.TEXT || opcode === opcodes.BINARY;
}
function isValidOpcode(opcode) {
return isTextBinaryFrame(opcode) || isContinuationFrame(opcode) || isControlFrame(opcode);
}
function parseExtensions(extensions) {
let position = { position: 0 }, extensionList = /* @__PURE__ */ new Map;
while (position.position < extensions.length) {
let pair = collectASequenceOfCodePointsFast(";", extensions, position), [name, value = ""] = pair.split("=");
extensionList.set(removeHTTPWhitespace(name, !0, !1), removeHTTPWhitespace(value, !1, !0)), position.position++;
}
return extensionList;
}
function isValidClientWindowBits(value) {
for (let i = 0;i < value.length; i++) {
let byte = value.charCodeAt(i);
if (byte < 48 || byte > 57)
return !1;
}
return !0;
}
function getURLRecord(url, baseURL) {
let urlRecord;
try {
urlRecord = new URL(url, baseURL);
} catch (e) {
throw new DOMException(e, "SyntaxError");
}
if (urlRecord.protocol === "http:")
urlRecord.protocol = "ws:";
else if (urlRecord.protocol === "https:")
urlRecord.protocol = "wss:";
if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:")
throw new DOMException("expected a ws: or wss: url", "SyntaxError");
if (urlRecord.hash.length || urlRecord.href.endsWith("#"))
throw new DOMException("hash", "SyntaxError");
return urlRecord;
}
function validateCloseCodeAndReason(code, reason) {
if (code !== null) {
if (code !== 1000 && (code < 3000 || code > 4999))
throw new DOMException("invalid code", "InvalidAccessError");
}
if (reason !== null) {
let reasonBytesLength = Buffer.byteLength(reason);
if (reasonBytesLength > 123)
throw new DOMException(`Reason must be less than 123 bytes; received ${reasonBytesLength}`, "SyntaxError");
}
}
var utf8Decode = (() => {
if (typeof process.versions.icu === "string") {
let fatalDecoder = new TextDecoder("utf-8", { fatal: !0 });
return fatalDecoder.decode.bind(fatalDecoder);
}
return function(buffer) {
if (isUtf8(buffer))
return buffer.toString("utf-8");
throw new TypeError("Invalid utf-8 received.");
};
})();
module.exports = {
isConnecting,
isEstablished,
isClosing,
isClosed,
fireEvent,
isValidSubprotocol,
isValidStatusCode,
websocketMessageReceived,
utf8Decode,
isControlFrame,
isContinuationFrame,
isTextBinaryFrame,
isValidOpcode,
parseExtensions,
isValidClientWindowBits,
toArrayBuffer,
getURLRecord,
validateCloseCodeAndReason
};
});
// undici/lib/core/diagnostics.js
var require_diagnostics = __commonJS((exports, module) => {
var diagnosticsChannel = __require("node:diagnostics_channel"), util = __require("node:util"), undiciDebugLog = util.debuglog("undici"), fetchDebuglog = util.debuglog("fetch"), websocketDebuglog = util.debuglog("websocket"), channels = {
beforeConnect: diagnosticsChannel.channel("undici:client:beforeConnect"),
connected: diagnosticsChannel.channel("undici:client:connected"),
connectError: diagnosticsChannel.channel("undici:client:connectError"),
sendHeaders: diagnosticsChannel.channel("undici:client:sendHeaders"),
create: diagnosticsChannel.channel("undici:request:create"),
bodySent: diagnosticsChannel.channel("undici:request:bodySent"),
headers: diagnosticsChannel.channel("undici:request:headers"),
trailers: diagnosticsChannel.channel("undici:request:trailers"),
error: diagnosticsChannel.channel("undici:request:error"),
open: diagnosticsChannel.channel("undici:websocket:open"),
close: diagnosticsChannel.channel("undici:websocket:close"),
socketError: diagnosticsChannel.channel("undici:websocket:socket_error"),
ping: diagnosticsChannel.channel("undici:websocket:ping"),
pong: diagnosticsChannel.channel("undici:websocket:pong")
}, isTrackingClientEvents = !1;
function trackClientEvents(debugLog = undiciDebugLog) {
if (isTrackingClientEvents)
return;
isTrackingClientEvents = !0, diagnosticsChannel.subscribe("undici:client:beforeConnect", (evt) => {
let {
connectParams: { version, protocol, port, host }
} = evt;
debugLog("connecting to %s%s using %s%s", host, port ? `:${port}` : "", protocol, version);
}), diagnosticsChannel.subscribe("undici:client:connected", (evt) => {
let {
connectParams: { version, protocol, port, host }
} = evt;
debugLog("connected to %s%s using %s%s", host, port ? `:${port}` : "", protocol, version);
}), diagnosticsChannel.subscribe("undici:client:connectError", (evt) => {
let {
connectParams: { version, protocol, port, host },
error
} = evt;
debugLog("connection to %s%s using %s%s errored - %s", host, port ? `:${port}` : "", protocol, version, error.message);
}), diagnosticsChannel.subscribe("undici:client:sendHeaders", (evt) => {
let {
request: { method, path, origin }
} = evt;
debugLog("sending request to %s %s/%s", method, origin, path);
});
}
var isTrackingRequestEvents = !1;
function trackRequestEvents(debugLog = undiciDebugLog) {
if (isTrackingRequestEvents)
return;
isTrackingRequestEvents = !0, diagnosticsChannel.subscribe("undici:request:headers", (evt) => {
let {
request: { method, path, origin },
response: { statusCode }
} = evt;
debugLog("received response to %s %s/%s - HTTP %d", method, origin, path, statusCode);
}), diagnosticsChannel.subscribe("undici:request:trailers", (evt) => {
let {
request: { method, path, origin }
} = evt;
debugLog("trailers received from %s %s/%s", method, origin, path);
}), diagnosticsChannel.subscribe("undici:request:error", (evt) => {
let {
request: { method, path, origin },
error
} = evt;
debugLog("request to %s %s/%s errored - %s", method, origin, path, error.message);
});
}
var isTrackingWebSocketEvents = !1;
function trackWebSocketEvents(debugLog = websocketDebuglog) {
if (isTrackingWebSocketEvents)
return;
isTrackingWebSocketEvents = !0, diagnosticsChannel.subscribe("undici:websocket:open", (evt) => {
let {
address: { address, port }
} = evt;
debugLog("connection opened %s%s", address, port ? `:${port}` : "");
}), diagnosticsChannel.subscribe("undici:websocket:close", (evt) => {
let { websocket, code, reason } = evt;
debugLog("closed connection to %s - %s %s", websocket.url, code, reason);
}), diagnosticsChannel.subscribe("undici:websocket:socket_error", (err) => {
debugLog("connection errored - %s", err.message);
}), diagnosticsChannel.subscribe("undici:websocket:ping", (evt) => {
debugLog("ping received");
}), diagnosticsChannel.subscribe("undici:websocket:pong", (evt) => {
debugLog("pong received");
});
}
if (undiciDebugLog.enabled || fetchDebuglog.enabled)
trackClientEvents(fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog), trackRequestEvents(fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog);
if (websocketDebuglog.enabled)
trackClientEvents(undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog), trackWebSocketEvents(websocketDebuglog);
module.exports = {
channels
};
});
// undici/lib/web/fetch/formdata.js
var require_formdata = __commonJS((exports, module) => {
var { iteratorMixin } = require_util2(), { kEnumerableProperty } = require_util(), { webidl } = require_webidl(), { File: NativeFile } = __require("node:buffer"), nodeUtil = __require("node:util"), File = globalThis.File ?? NativeFile;
class FormData {
#state = [];
constructor(form) {
if (webidl.util.markAsUncloneable(this), form !== void 0)
throw webidl.errors.conversionFailed({
prefix: "FormData constructor",
argument: "Argument 1",
types: ["undefined"]
});
}
append(name, value, filename = void 0) {
webidl.brandCheck(this, FormData);
let prefix = "FormData.append";
if (webidl.argumentLengthCheck(arguments, 2, prefix), name = webidl.converters.USVString(name), arguments.length === 3 || webidl.is.Blob(value)) {
if (value = webidl.converters.Blob(value, prefix, "value"), filename !== void 0)
filename = webidl.converters.USVString(filename);
} else
value = webidl.converters.USVString(value);
let entry = makeEntry(name, value, filename);
this.#state.push(entry);
}
delete(name) {
webidl.brandCheck(this, FormData);
let prefix = "FormData.delete";
webidl.argumentLengthCheck(arguments, 1, prefix), name = webidl.converters.USVString(name), this.#state = this.#state.filter((entry) => entry.name !== name);
}
get(name) {
webidl.brandCheck(this, FormData);
let prefix = "FormData.get";
webidl.argumentLengthCheck(arguments, 1, prefix), name = webidl.converters.USVString(name);
let idx = this.#state.findIndex((entry) => entry.name === name);
if (idx === -1)
return null;
return this.#state[idx].value;
}
getAll(name) {
webidl.brandCheck(this, FormData);
let prefix = "FormData.getAll";
return webidl.argumentLengthCheck(arguments, 1, prefix), name = webidl.converters.USVString(name), this.#state.filter((entry) => entry.name === name).map((entry) => entry.value);
}
has(name) {
webidl.brandCheck(this, FormData);
let prefix = "FormData.has";
return webidl.argumentLengthCheck(arguments, 1, prefix), name = webidl.converters.USVString(name), this.#state.findIndex((entry) => entry.name === name) !== -1;
}
set(name, value, filename = void 0) {
webidl.brandCheck(this, FormData);
let prefix = "FormData.set";
if (webidl.argumentLengthCheck(arguments, 2, prefix), name = webidl.converters.USVString(name), arguments.length === 3 || webidl.is.Blob(value)) {
if (value = webidl.converters.Blob(value, prefix, "value"), filename !== void 0)
filename = webidl.converters.USVString(filename);
} else
value = webidl.converters.USVString(value);
let entry = makeEntry(name, value, filename), idx = this.#state.findIndex((entry2) => entry2.name === name);
if (idx !== -1)
this.#state = [
...this.#state.slice(0, idx),
entry,
...this.#state.slice(idx + 1).filter((entry2) => entry2.name !== name)
];
else
this.#state.push(entry);
}
[nodeUtil.inspect.custom](depth, options) {
let state = this.#state.reduce((a, b) => {
if (a[b.name])
if (Array.isArray(a[b.name]))
a[b.name].push(b.value);
else
a[b.name] = [a[b.name], b.value];
else
a[b.name] = b.value;
return a;
}, { __proto__: null });
options.depth ??= depth, options.colors ??= !0;
let output = nodeUtil.formatWithOptions(options, state);
return `FormData ${output.slice(output.indexOf("]") + 2)}`;
}
static getFormDataState(formData) {
return formData.#state;
}
static setFormDataState(formData, newState) {
formData.#state = newState;
}
}
var { getFormDataState, setFormDataState } = FormData;
Reflect.deleteProperty(FormData, "getFormDataState");
Reflect.deleteProperty(FormData, "setFormDataState");
iteratorMixin("FormData", FormData, getFormDataState, "name", "value");
Object.defineProperties(FormData.prototype, {
append: kEnumerableProperty,
delete: kEnumerableProperty,
get: kEnumerableProperty,
getAll: kEnumerableProperty,
has: kEnumerableProperty,
set: kEnumerableProperty,
[Symbol.toStringTag]: {
value: "FormData",
configurable: !0
}
});
function makeEntry(name, value, filename) {
if (typeof value === "string")
;
else {
if (!webidl.is.File(value))
value = new File([value], "blob", { type: value.type });
if (filename !== void 0) {
let options = {
type: value.type,
lastModified: value.lastModified
};
value = new File([value], filename, options);
}
}
return { name, value };
}
webidl.is.FormData = webidl.util.MakeTypeAssertion(FormData);
module.exports = { FormData, makeEntry, setFormDataState };
});
// undici/lib/web/fetch/formdata-parser.js
var require_formdata_parser = __commonJS((exports, module) => {
var { isUSVString, bufferToLowerCasedHeaderName } = require_util(), { utf8DecodeBytes } = require_util2(), { HTTP_TOKEN_CODEPOINTS, isomorphicDecode } = require_data_url(), { makeEntry } = require_formdata(), { webidl } = require_webidl(), assert = __require("node:assert"), { File: NodeFile } = __require("node:buffer"), File = globalThis.File ?? NodeFile, formDataNameBuffer = Buffer.from('form-data; name="'), filenameBuffer = Buffer.from("filename"), dd = Buffer.from("--"), ddcrlf = Buffer.from(`--\r
`);
function isAsciiString(chars) {
for (let i = 0;i < chars.length; ++i)
if ((chars.charCodeAt(i) & -128) !== 0)
return !1;
return !0;
}
function validateBoundary(boundary) {
let length = boundary.length;
if (length < 27 || length > 70)
return !1;
for (let i = 0;i < length; ++i) {
let cp = boundary.charCodeAt(i);
if (!(cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 39 || cp === 45 || cp === 95))
return !1;
}
return !0;
}
function multipartFormDataParser(input, mimeType) {
assert(mimeType !== "failure" && mimeType.essence === "multipart/form-data");
let boundaryString = mimeType.parameters.get("boundary");
if (boundaryString === void 0)
throw parsingError("missing boundary in content-type header");
let boundary = Buffer.from(`--${boundaryString}`, "utf8"), entryList = [], position = { position: 0 };
while (input[position.position] === 13 && input[position.position + 1] === 10)
position.position += 2;
let trailing = input.length;
while (input[trailing - 1] === 10 && input[trailing - 2] === 13)
trailing -= 2;
if (trailing !== input.length)
input = input.subarray(0, trailing);
while (!0) {
if (input.subarray(position.position, position.position + boundary.length).equals(boundary))
position.position += boundary.length;
else
throw parsingError("expected a value starting with -- and the boundary");
if (position.position === input.length - 2 && bufferStartsWith(input, dd, position) || position.position === input.length - 4 && bufferStartsWith(input, ddcrlf, position))
return entryList;
if (input[position.position] !== 13 || input[position.position + 1] !== 10)
throw parsingError("expected CRLF");
position.position += 2;
let result = parseMultipartFormDataHeaders(input, position), { name, filename, contentType, encoding } = result;
position.position += 2;
let body;
{
let boundaryIndex = input.indexOf(boundary.subarray(2), position.position);
if (boundaryIndex === -1)
throw parsingError("expected boundary after body");
if (body = input.subarray(position.position, boundaryIndex - 4), position.position += body.length, encoding === "base64")
body = Buffer.from(body.toString(), "base64");
}
if (input[position.position] !== 13 || input[position.position + 1] !== 10)
throw parsingError("expected CRLF");
else
position.position += 2;
let value;
if (filename !== null) {
if (contentType ??= "text/plain", !isAsciiString(contentType))
contentType = "";
value = new File([body], filename, { type: contentType });
} else
value = utf8DecodeBytes(Buffer.from(body));
assert(isUSVString(name)), assert(typeof value === "string" && isUSVString(value) || webidl.is.File(value)), entryList.push(makeEntry(name, value, filename));
}
}
function parseMultipartFormDataHeaders(input, position) {
let name = null, filename = null, contentType = null, encoding = null;
while (!0) {
if (input[position.position] === 13 && input[position.position + 1] === 10) {
if (name === null)
throw parsingError("header name is null");
return { name, filename, contentType, encoding };
}
let headerName = collectASequenceOfBytes((char) => char !== 10 && char !== 13 && char !== 58, input, position);
if (headerName = removeChars(headerName, !0, !0, (char) => char === 9 || char === 32), !HTTP_TOKEN_CODEPOINTS.test(headerName.toString()))
throw parsingError("header name does not match the field-name token production");
if (input[position.position] !== 58)
throw parsingError("expected :");
switch (position.position++, collectASequenceOfBytes((char) => char === 32 || char === 9, input, position), bufferToLowerCasedHeaderName(headerName)) {
case "content-disposition": {
if (name = filename = null, !bufferStartsWith(input, formDataNameBuffer, position))
throw parsingError('expected form-data; name=" for content-disposition header');
if (position.position += 17, name = parseMultipartFormDataName(input, position), input[position.position] === 59 && input[position.position + 1] === 32) {
let at = { position: position.position + 2 };
if (bufferStartsWith(input, filenameBuffer, at))
if (input[at.position + 8] === 42) {
at.position += 10, collectASequenceOfBytes((char) => char === 32 || char === 9, input, at);
let headerValue = collectASequenceOfBytes((char) => char !== 32 && char !== 13 && char !== 10, input, at);
if (headerValue[0] !== 117 && headerValue[0] !== 85 || headerValue[1] !== 116 && headerValue[1] !== 84 || headerValue[2] !== 102 && headerValue[2] !== 70 || headerValue[3] !== 45 || headerValue[4] !== 56)
throw parsingError("unknown encoding, expected utf-8''");
filename = decodeURIComponent((/* @__PURE__ */ new TextDecoder()).decode(headerValue.subarray(7))), position.position = at.position;
} else
position.position += 11, collectASequenceOfBytes((char) => char === 32 || char === 9, input, position), position.position++, filename = parseMultipartFormDataName(input, position);
}
break;
}
case "content-type": {
let headerValue = collectASequenceOfBytes((char) => char !== 10 && char !== 13, input, position);
headerValue = removeChars(headerValue, !1, !0, (char) => char === 9 || char === 32), contentType = isomorphicDecode(headerValue);
break;
}
case "content-transfer-encoding": {
let headerValue = collectASequenceOfBytes((char) => char !== 10 && char !== 13, input, position);
headerValue = removeChars(headerValue, !1, !0, (char) => char === 9 || char === 32), encoding = isomorphicDecode(headerValue);
break;
}
default:
collectASequenceOfBytes((char) => char !== 10 && char !== 13, input, position);
}
if (input[position.position] !== 13 && input[position.position + 1] !== 10)
throw parsingError("expected CRLF");
else
position.position += 2;
}
}
function parseMultipartFormDataName(input, position) {
assert(input[position.position - 1] === 34);
let name = collectASequenceOfBytes((char) => char !== 10 && char !== 13 && char !== 34, input, position);
if (input[position.position] !== 34)
throw parsingError('expected "');
else
position.position++;
return name = (/* @__PURE__ */ new TextDecoder()).decode(name).replace(/%0A/ig, `
`).replace(/%0D/ig, "\r").replace(/%22/g, '"'), name;
}
function collectASequenceOfBytes(condition, input, position) {
let start = position.position;
while (start < input.length && condition(input[start]))
++start;
return input.subarray(position.position, position.position = start);
}
function removeChars(buf, leading, trailing, predicate) {
let lead = 0, trail = buf.length - 1;
if (leading)
while (lead < buf.length && predicate(buf[lead]))
lead++;
if (trailing)
while (trail > 0 && predicate(buf[trail]))
trail--;
return lead === 0 && trail === buf.length - 1 ? buf : buf.subarray(lead, trail + 1);
}
function bufferStartsWith(buffer, start, position) {
if (buffer.length < start.length)
return !1;
for (let i = 0;i < start.length; i++)
if (start[i] !== buffer[position.position + i])
return !1;
return !0;
}
function parsingError(cause) {
return new TypeError("Failed to parse body as FormData.", { cause: new TypeError(cause) });
}
module.exports = {
multipartFormDataParser,
validateBoundary
};
});
// undici/lib/web/fetch/body.js
var require_body = __commonJS((exports, module) => {
var util = require_util(), {
ReadableStreamFrom,
readableStreamClose,
createDeferredPromise,
fullyReadBody,
extractMimeType,
utf8DecodeBytes
} = require_util2(), { FormData, setFormDataState } = require_formdata(), { webidl } = require_webidl(), { Blob: Blob2 } = __require("node:buffer"), assert = __require("node:assert"), { isErrored, isDisturbed } = __require("node:stream"), { isArrayBuffer } = __require("node:util/types"), { serializeAMimeType } = require_data_url(), { multipartFormDataParser } = require_formdata_parser(), random;
try {
let crypto = __require("node:crypto");
random = (max) => crypto.randomInt(0, max);
} catch {
random = (max) => Math.floor(Math.random() * max);
}
var textEncoder = /* @__PURE__ */ new TextEncoder;
function noop() {
}
var hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf("v18") !== 0, streamRegistry;
if (hasFinalizationRegistry)
streamRegistry = new FinalizationRegistry((weakRef) => {
let stream = weakRef.deref();
if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream))
stream.cancel("Response object has been garbage collected").catch(noop);
});
function extractBody(object, keepalive = !1) {
let stream = null;
if (webidl.is.ReadableStream(object))
stream = object;
else if (webidl.is.Blob(object))
stream = object.stream();
else
stream = new ReadableStream({
async pull(controller) {
let buffer = typeof source === "string" ? textEncoder.encode(source) : source;
if (buffer.byteLength)
controller.enqueue(buffer);
queueMicrotask(() => readableStreamClose(controller));
},
start() {
},
type: "bytes"
});
assert(webidl.is.ReadableStream(stream));
let action = null, source = null, length = null, type = null;
if (typeof object === "string")
source = object, type = "text/plain;charset=UTF-8";
else if (webidl.is.URLSearchParams(object))
source = object.toString(), type = "application/x-www-form-urlencoded;charset=UTF-8";
else if (isArrayBuffer(object))
source = new Uint8Array(object.slice());
else if (ArrayBuffer.isView(object))
source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength));
else if (webidl.is.FormData(object)) {
let boundary = `----formdata-undici-0${`${random(100000000000)}`.padStart(11, "0")}`, prefix = `--${boundary}\r
Content-Disposition: form-data`;
/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
let escape = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, `\r
`), blobParts = [], rn = new Uint8Array([13, 10]);
length = 0;
let hasUnknownSizeValue = !1;
for (let [name, value] of object)
if (typeof value === "string") {
let chunk2 = textEncoder.encode(prefix + `; name="${escape(normalizeLinefeeds(name))}"\r
\r
${normalizeLinefeeds(value)}\r
`);
blobParts.push(chunk2), length += chunk2.byteLength;
} else {
let chunk2 = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape(value.name)}"` : "") + `\r
Content-Type: ${value.type || "application/octet-stream"}\r
\r
`);
if (blobParts.push(chunk2, value, rn), typeof value.size === "number")
length += chunk2.byteLength + value.size + rn.byteLength;
else
hasUnknownSizeValue = !0;
}
let chunk = textEncoder.encode(`--${boundary}--\r
`);
if (blobParts.push(chunk), length += chunk.byteLength, hasUnknownSizeValue)
length = null;
source = object, action = async function* () {
for (let part of blobParts)
if (part.stream)
yield* part.stream();
else
yield part;
}, type = `multipart/form-data; boundary=${boundary}`;
} else if (webidl.is.Blob(object)) {
if (source = object, length = object.size, object.type)
type = object.type;
} else if (typeof object[Symbol.asyncIterator] === "function") {
if (keepalive)
throw new TypeError("keepalive");
if (util.isDisturbed(object) || object.locked)
throw new TypeError("Response body object should not be disturbed or locked");
stream = webidl.is.ReadableStream(object) ? object : ReadableStreamFrom(object);
}
if (typeof source === "string" || util.isBuffer(source))
length = Buffer.byteLength(source);
if (action != null) {
let iterator;
stream = new ReadableStream({
async start() {
iterator = action(object)[Symbol.asyncIterator]();
},
async pull(controller) {
let { value, done } = await iterator.next();
if (done)
queueMicrotask(() => {
controller.close(), controller.byobRequest?.respond(0);
});
else if (!isErrored(stream)) {
let buffer = new Uint8Array(value);
if (buffer.byteLength)
controller.enqueue(buffer);
}
return controller.desiredSize > 0;
},
async cancel(reason) {
await iterator.return();
},
type: "bytes"
});
}
return [{ stream, source, length }, type];
}
function safelyExtractBody(object, keepalive = !1) {
if (webidl.is.ReadableStream(object))
assert(!util.isDisturbed(object), "The body has already been consumed."), assert(!object.locked, "The stream is locked.");
return extractBody(object, keepalive);
}
function cloneBody(instance, body) {
let [out1, out2] = body.stream.tee();
if (hasFinalizationRegistry)
streamRegistry.register(instance, new WeakRef(out1));
return body.stream = out1, {
stream: out2,
length: body.length,
source: body.source
};
}
function throwIfAborted(state) {
if (state.aborted)
throw new DOMException("The operation was aborted.", "AbortError");
}
function bodyMixinMethods(instance, getInternalState) {
return {
blob() {
return consumeBody(this, (bytes) => {
let mimeType = bodyMimeType(getInternalState(this));
if (mimeType === null)
mimeType = "";
else if (mimeType)
mimeType = serializeAMimeType(mimeType);
return new Blob2([bytes], { type: mimeType });
}, instance, getInternalState);
},
arrayBuffer() {
return consumeBody(this, (bytes) => {
return new Uint8Array(bytes).buffer;
}, instance, getInternalState);
},
text() {
return consumeBody(this, utf8DecodeBytes, instance, getInternalState);
},
json() {
return consumeBody(this, parseJSONFromBytes, instance, getInternalState);
},
formData() {
return consumeBody(this, (value) => {
let mimeType = bodyMimeType(getInternalState(this));
if (mimeType !== null)
switch (mimeType.essence) {
case "multipart/form-data": {
let parsed = multipartFormDataParser(value, mimeType), fd = new FormData;
return setFormDataState(fd, parsed), fd;
}
case "application/x-www-form-urlencoded": {
let entries = new URLSearchParams(value.toString()), fd = new FormData;
for (let [name, value2] of entries)
fd.append(name, value2);
return fd;
}
}
throw new TypeError('Content-Type was not one of "multipart/form-data" or "application/x-www-form-urlencoded".');
}, instance, getInternalState);
},
bytes() {
return consumeBody(this, (bytes) => {
return new Uint8Array(bytes);
}, instance, getInternalState);
}
};
}
function mixinBody(prototype, getInternalState) {
Object.assign(prototype.prototype, bodyMixinMethods(prototype, getInternalState));
}
async function consumeBody(object, convertBytesToJSValue, instance, getInternalState) {
webidl.brandCheck(object, instance);
let state = getInternalState(object);
if (bodyUnusable(state))
throw new TypeError("Body is unusable: Body has already been read");
throwIfAborted(state);
let promise = createDeferredPromise(), errorSteps = (error) => promise.reject(error), successSteps = (data) => {
try {
promise.resolve(convertBytesToJSValue(data));
} catch (e) {
errorSteps(e);
}
};
if (state.body == null)
return successSteps(Buffer.allocUnsafe(0)), promise.promise;
return fullyReadBody(state.body, successSteps, errorSteps), promise.promise;
}
function bodyUnusable(object) {
let body = object.body;
return body != null && (body.stream.locked || util.isDisturbed(body.stream));
}
function parseJSONFromBytes(bytes) {
return JSON.parse(utf8DecodeBytes(bytes));
}
function bodyMimeType(requestOrResponse) {
let headers = requestOrResponse.headersList, mimeType = extractMimeType(headers);
if (mimeType === "failure")
return null;
return mimeType;
}
module.exports = {
extractBody,
safelyExtractBody,
cloneBody,
mixinBody,
streamRegistry,
hasFinalizationRegistry,
bodyUnusable
};
});
// undici/lib/web/fetch/headers.js
var require_headers = __commonJS((exports, module) => {
var { kConstruct } = require_symbols(), { kEnumerableProperty } = require_util(), {
iteratorMixin,
isValidHeaderName,
isValidHeaderValue
} = require_util2(), { webidl } = require_webidl(), assert = __require("node:assert"), util = __require("node:util");
function isHTTPWhiteSpaceCharCode(code) {
return code === 10 || code === 13 || code === 9 || code === 32;
}
function headerValueNormalize(potentialValue) {
let i = 0, j = potentialValue.length;
while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1)))
--j;
while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i)))
++i;
return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j);
}
function fill(headers, object) {
if (Array.isArray(object))
for (let i = 0;i < object.length; ++i) {
let header = object[i];
if (header.length !== 2)
throw webidl.errors.exception({
header: "Headers constructor",
message: `expected name/value pair to be length 2, found ${header.length}.`
});
appendHeader(headers, header[0], header[1]);
}
else if (typeof object === "object" && object !== null) {
let keys = Object.keys(object);
for (let i = 0;i < keys.length; ++i)
appendHeader(headers, keys[i], object[keys[i]]);
} else
throw webidl.errors.conversionFailed({
prefix: "Headers constructor",
argument: "Argument 1",
types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
});
}
function appendHeader(headers, name, value) {
if (value = headerValueNormalize(value), !isValidHeaderName(name))
throw webidl.errors.invalidArgument({
prefix: "Headers.append",
value: name,
type: "header name"
});
else if (!isValidHeaderValue(value))
throw webidl.errors.invalidArgument({
prefix: "Headers.append",
value,
type: "header value"
});
if (getHeadersGuard(headers) === "immutable")
throw new TypeError("immutable");
return getHeadersList(headers).append(name, value, !1);
}
function headersListSortAndCombine(target) {
let headersList = getHeadersList(target);
if (!headersList)
return [];
if (headersList.sortedMap)
return headersList.sortedMap;
let headers = [], names = headersList.toSortedArray(), cookies = headersList.cookies;
if (cookies === null || cookies.length === 1)
return headersList.sortedMap = names;
for (let i = 0;i < names.length; ++i) {
let { 0: name, 1: value } = names[i];
if (name === "set-cookie")
for (let j = 0;j < cookies.length; ++j)
headers.push([name, cookies[j]]);
else
headers.push([name, value]);
}
return headersList.sortedMap = headers;
}
function compareHeaderName(a, b) {
return a[0] < b[0] ? -1 : 1;
}
class HeadersList {
cookies = null;
sortedMap;
headersMap;
constructor(init) {
if (init instanceof HeadersList)
this.headersMap = new Map(init.headersMap), this.sortedMap = init.sortedMap, this.cookies = init.cookies === null ? null : [...init.cookies];
else
this.headersMap = new Map(init), this.sortedMap = null;
}
contains(name, isLowerCase) {
return this.headersMap.has(isLowerCase ? name : name.toLowerCase());
}
clear() {
this.headersMap.clear(), this.sortedMap = null, this.cookies = null;
}
append(name, value, isLowerCase) {
this.sortedMap = null;
let lowercaseName = isLowerCase ? name : name.toLowerCase(), exists = this.headersMap.get(lowercaseName);
if (exists) {
let delimiter = lowercaseName === "cookie" ? "; " : ", ";
this.headersMap.set(lowercaseName, {
name: exists.name,
value: `${exists.value}${delimiter}${value}`
});
} else
this.headersMap.set(lowercaseName, { name, value });
if (lowercaseName === "set-cookie")
(this.cookies ??= []).push(value);
}
set(name, value, isLowerCase) {
this.sortedMap = null;
let lowercaseName = isLowerCase ? name : name.toLowerCase();
if (lowercaseName === "set-cookie")
this.cookies = [value];
this.headersMap.set(lowercaseName, { name, value });
}
delete(name, isLowerCase) {
if (this.sortedMap = null, !isLowerCase)
name = name.toLowerCase();
if (name === "set-cookie")
this.cookies = null;
this.headersMap.delete(name);
}
get(name, isLowerCase) {
return this.headersMap.get(isLowerCase ? name : name.toLowerCase())?.value ?? null;
}
*[Symbol.iterator]() {
for (let { 0: name, 1: { value } } of this.headersMap)
yield [name, value];
}
get entries() {
let headers = {};
if (this.headersMap.size !== 0)
for (let { name, value } of this.headersMap.values())
headers[name] = value;
return headers;
}
rawValues() {
return this.headersMap.values();
}
get entriesList() {
let headers = [];
if (this.headersMap.size !== 0)
for (let { 0: lowerName, 1: { name, value } } of this.headersMap)
if (lowerName === "set-cookie")
for (let cookie of this.cookies)
headers.push([name, cookie]);
else
headers.push([name, value]);
return headers;
}
toSortedArray() {
let size = this.headersMap.size, array = new Array(size);
if (size <= 32) {
if (size === 0)
return array;
let iterator = this.headersMap[Symbol.iterator](), firstValue = iterator.next().value;
array[0] = [firstValue[0], firstValue[1].value], assert(firstValue[1].value !== null);
for (let i = 1, j = 0, right = 0, left = 0, pivot = 0, x, value;i < size; ++i) {
value = iterator.next().value, x = array[i] = [value[0], value[1].value], assert(x[1] !== null), left = 0, right = i;
while (left < right)
if (pivot = left + (right - left >> 1), array[pivot][0] <= x[0])
left = pivot + 1;
else
right = pivot;
if (i !== pivot) {
j = i;
while (j > left)
array[j] = array[--j];
array[left] = x;
}
}
if (!iterator.next().done)
throw new TypeError("Unreachable");
return array;
} else {
let i = 0;
for (let { 0: name, 1: { value } } of this.headersMap)
array[i++] = [name, value], assert(value !== null);
return array.sort(compareHeaderName);
}
}
}
class Headers {
#guard;
#headersList;
constructor(init = void 0) {
if (webidl.util.markAsUncloneable(this), init === kConstruct)
return;
if (this.#headersList = new HeadersList, this.#guard = "none", init !== void 0)
init = webidl.converters.HeadersInit(init, "Headers constructor", "init"), fill(this, init);
}
append(name, value) {
webidl.brandCheck(this, Headers), webidl.argumentLengthCheck(arguments, 2, "Headers.append");
let prefix = "Headers.append";
return name = webidl.converters.ByteString(name, prefix, "name"), value = webidl.converters.ByteString(value, prefix, "value"), appendHeader(this, name, value);
}
delete(name) {
webidl.brandCheck(this, Headers), webidl.argumentLengthCheck(arguments, 1, "Headers.delete");
let prefix = "Headers.delete";
if (name = webidl.converters.ByteString(name, prefix, "name"), !isValidHeaderName(name))
throw webidl.errors.invalidArgument({
prefix: "Headers.delete",
value: name,
type: "header name"
});
if (this.#guard === "immutable")
throw new TypeError("immutable");
if (!this.#headersList.contains(name, !1))
return;
this.#headersList.delete(name, !1);
}
get(name) {
webidl.brandCheck(this, Headers), webidl.argumentLengthCheck(arguments, 1, "Headers.get");
let prefix = "Headers.get";
if (name = webidl.converters.ByteString(name, prefix, "name"), !isValidHeaderName(name))
throw webidl.errors.invalidArgument({
prefix,
value: name,
type: "header name"
});
return this.#headersList.get(name, !1);
}
has(name) {
webidl.brandCheck(this, Headers), webidl.argumentLengthCheck(arguments, 1, "Headers.has");
let prefix = "Headers.has";
if (name = webidl.converters.ByteString(name, prefix, "name"), !isValidHeaderName(name))
throw webidl.errors.invalidArgument({
prefix,
value: name,
type: "header name"
});
return this.#headersList.contains(name, !1);
}
set(name, value) {
webidl.brandCheck(this, Headers), webidl.argumentLengthCheck(arguments, 2, "Headers.set");
let prefix = "Headers.set";
if (name = webidl.converters.ByteString(name, prefix, "name"), value = webidl.converters.ByteString(value, prefix, "value"), value = headerValueNormalize(value), !isValidHeaderName(name))
throw webidl.errors.invalidArgument({
prefix,
value: name,
type: "header name"
});
else if (!isValidHeaderValue(value))
throw webidl.errors.invalidArgument({
prefix,
value,
type: "header value"
});
if (this.#guard === "immutable")
throw new TypeError("immutable");
this.#headersList.set(name, value, !1);
}
getSetCookie() {
webidl.brandCheck(this, Headers);
let list = this.#headersList.cookies;
if (list)
return [...list];
return [];
}
[util.inspect.custom](depth, options) {
return options.depth ??= depth, `Headers ${util.formatWithOptions(options, this.#headersList.entries)}`;
}
static getHeadersGuard(o) {
return o.#guard;
}
static setHeadersGuard(o, guard) {
o.#guard = guard;
}
static getHeadersList(o) {
return o.#headersList;
}
static setHeadersList(target, list) {
target.#headersList = list;
}
}
var { getHeadersGuard, setHeadersGuard, getHeadersList, setHeadersList } = Headers;
Reflect.deleteProperty(Headers, "getHeadersGuard");
Reflect.deleteProperty(Headers, "setHeadersGuard");
Reflect.deleteProperty(Headers, "getHeadersList");
Reflect.deleteProperty(Headers, "setHeadersList");
iteratorMixin("Headers", Headers, headersListSortAndCombine, 0, 1);
Object.defineProperties(Headers.prototype, {
append: kEnumerableProperty,
delete: kEnumerableProperty,
get: kEnumerableProperty,
has: kEnumerableProperty,
set: kEnumerableProperty,
getSetCookie: kEnumerableProperty,
[Symbol.toStringTag]: {
value: "Headers",
configurable: !0
},
[util.inspect.custom]: {
enumerable: !1
}
});
webidl.converters.HeadersInit = function(V, prefix, argument) {
if (webidl.util.Type(V) === webidl.util.Types.OBJECT) {
let iterator = Reflect.get(V, Symbol.iterator);
if (!util.types.isProxy(V) && iterator === Headers.prototype.entries)
try {
return getHeadersList(V).entriesList;
} catch {
}
if (typeof iterator === "function")
return webidl.converters["sequence<sequence<ByteString>>"](V, prefix, argument, iterator.bind(V));
return webidl.converters["record<ByteString, ByteString>"](V, prefix, argument);
}
throw webidl.errors.conversionFailed({
prefix: "Headers constructor",
argument: "Argument 1",
types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
});
};
module.exports = {
fill,
compareHeaderName,
Headers,
HeadersList,
getHeadersGuard,
setHeadersGuard,
setHeadersList,
getHeadersList
};
});
// undici/lib/web/fetch/dispatcher-weakref.js
var require_dispatcher_weakref = __commonJS((exports, module) => {
var { kConnected, kSize } = require_symbols();
class CompatWeakRef {
constructor(value) {
this.value = value;
}
deref() {
return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value;
}
}
class CompatFinalizer {
constructor(finalizer) {
this.finalizer = finalizer;
}
register(dispatcher, key) {
if (dispatcher.on)
dispatcher.on("disconnect", () => {
if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0)
this.finalizer(key);
});
}
unregister(key) {
}
}
module.exports = function() {
if (process.env.NODE_V8_COVERAGE && process.version.startsWith("v18"))
return process._rawDebug("Using compatibility WeakRef and FinalizationRegistry"), {
WeakRef: CompatWeakRef,
FinalizationRegistry: CompatFinalizer
};
return { WeakRef, FinalizationRegistry };
};
});
// undici/lib/web/fetch/request.js
var require_request = __commonJS((exports, module) => {
var { extractBody, mixinBody, cloneBody, bodyUnusable } = require_body(), { Headers, fill: fillHeaders, HeadersList, setHeadersGuard, getHeadersGuard, setHeadersList, getHeadersList } = require_headers(), { FinalizationRegistry: FinalizationRegistry2 } = require_dispatcher_weakref()(), util = require_util(), nodeUtil = __require("node:util"), {
isValidHTTPToken,
sameOrigin,
environmentSettingsObject
} = require_util2(), {
forbiddenMethodsSet,
corsSafeListedMethodsSet,
referrerPolicy,
requestRedirect,
requestMode,
requestCredentials,
requestCache,
requestDuplex
} = require_constants(), { kEnumerableProperty, normalizedMethodRecordsBase, normalizedMethodRecords } = util, { webidl } = require_webidl(), { URLSerializer } = require_data_url(), { kConstruct } = require_symbols(), assert = __require("node:assert"), { getMaxListeners, setMaxListeners, defaultMaxListeners } = __require("node:events"), kAbortController = Symbol("abortController"), requestFinalizer = new FinalizationRegistry2(({ signal, abort }) => {
signal.removeEventListener("abort", abort);
}), dependentControllerMap = /* @__PURE__ */ new WeakMap, abortSignalHasEventHandlerLeakWarning;
try {
abortSignalHasEventHandlerLeakWarning = getMaxListeners(new AbortController().signal) > 0;
} catch {
abortSignalHasEventHandlerLeakWarning = !1;
}
function buildAbort(acRef) {
return abort;
function abort() {
let ac = acRef.deref();
if (ac !== void 0) {
requestFinalizer.unregister(abort), this.removeEventListener("abort", abort), ac.abort(this.reason);
let controllerList = dependentControllerMap.get(ac.signal);
if (controllerList !== void 0) {
if (controllerList.size !== 0) {
for (let ref of controllerList) {
let ctrl = ref.deref();
if (ctrl !== void 0)
ctrl.abort(this.reason);
}
controllerList.clear();
}
dependentControllerMap.delete(ac.signal);
}
}
}
}
var patchMethodWarning = !1;
class Request {
#signal;
#dispatcher;
#headers;
#state;
constructor(input, init = void 0) {
if (webidl.util.markAsUncloneable(this), input === kConstruct)
return;
let prefix = "Request constructor";
webidl.argumentLengthCheck(arguments, 1, prefix), input = webidl.converters.RequestInfo(input, prefix, "input"), init = webidl.converters.RequestInit(init, prefix, "init");
let request = null, fallbackMode = null, baseUrl = environmentSettingsObject.settingsObject.baseUrl, signal = null;
if (typeof input === "string") {
this.#dispatcher = init.dispatcher;
let parsedURL;
try {
parsedURL = new URL(input, baseUrl);
} catch (err) {
throw new TypeError("Failed to parse URL from " + input, { cause: err });
}
if (parsedURL.username || parsedURL.password)
throw new TypeError("Request cannot be constructed from a URL that includes credentials: " + input);
request = makeRequest({ urlList: [parsedURL] }), fallbackMode = "cors";
} else
assert(webidl.is.Request(input)), request = input.#state, signal = input.#signal, this.#dispatcher = init.dispatcher || input.#dispatcher;
let origin = environmentSettingsObject.settingsObject.origin, window = "client";
if (request.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request.window, origin))
window = request.window;
if (init.window != null)
throw new TypeError(`'window' option '${window}' must be null`);
if ("window" in init)
window = "no-window";
request = makeRequest({
method: request.method,
headersList: request.headersList,
unsafeRequest: request.unsafeRequest,
client: environmentSettingsObject.settingsObject,
window,
priority: request.priority,
origin: request.origin,
referrer: request.referrer,
referrerPolicy: request.referrerPolicy,
mode: request.mode,
credentials: request.credentials,
cache: request.cache,
redirect: request.redirect,
integrity: request.integrity,
keepalive: request.keepalive,
reloadNavigation: request.reloadNavigation,
historyNavigation: request.historyNavigation,
urlList: [...request.urlList]
});
let initHasKey = Object.keys(init).length !== 0;
if (initHasKey) {
if (request.mode === "navigate")
request.mode = "same-origin";
request.reloadNavigation = !1, request.historyNavigation = !1, request.origin = "client", request.referrer = "client", request.referrerPolicy = "", request.url = request.urlList[request.urlList.length - 1], request.urlList = [request.url];
}
if (init.referrer !== void 0) {
let referrer = init.referrer;
if (referrer === "")
request.referrer = "no-referrer";
else {
let parsedReferrer;
try {
parsedReferrer = new URL(referrer, baseUrl);
} catch (err) {
throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err });
}
if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, environmentSettingsObject.settingsObject.baseUrl))
request.referrer = "client";
else
request.referrer = parsedReferrer;
}
}
if (init.referrerPolicy !== void 0)
request.referrerPolicy = init.referrerPolicy;
let mode;
if (init.mode !== void 0)
mode = init.mode;
else
mode = fallbackMode;
if (mode === "navigate")
throw webidl.errors.exception({
header: "Request constructor",
message: "invalid request mode navigate."
});
if (mode != null)
request.mode = mode;
if (init.credentials !== void 0)
request.credentials = init.credentials;
if (init.cache !== void 0)
request.cache = init.cache;
if (request.cache === "only-if-cached" && request.mode !== "same-origin")
throw new TypeError("'only-if-cached' can be set only with 'same-origin' mode");
if (init.redirect !== void 0)
request.redirect = init.redirect;
if (init.integrity != null)
request.integrity = String(init.integrity);
if (init.keepalive !== void 0)
request.keepalive = Boolean(init.keepalive);
if (init.method !== void 0) {
let method = init.method, mayBeNormalized = normalizedMethodRecords[method];
if (mayBeNormalized !== void 0)
request.method = mayBeNormalized;
else {
if (!isValidHTTPToken(method))
throw new TypeError(`'${method}' is not a valid HTTP method.`);
let upperCase = method.toUpperCase();
if (forbiddenMethodsSet.has(upperCase))
throw new TypeError(`'${method}' HTTP method is unsupported.`);
method = normalizedMethodRecordsBase[upperCase] ?? method, request.method = method;
}
if (!patchMethodWarning && request.method === "patch")
process.emitWarning("Using `patch` is highly likely to result in a `405 Method Not Allowed`. `PATCH` is much more likely to succeed.", {
code: "UNDICI-FETCH-patch"
}), patchMethodWarning = !0;
}
if (init.signal !== void 0)
signal = init.signal;
this.#state = request;
let ac = new AbortController;
if (this.#signal = ac.signal, signal != null)
if (signal.aborted)
ac.abort(signal.reason);
else {
this[kAbortController] = ac;
let acRef = new WeakRef(ac), abort = buildAbort(acRef);
if (abortSignalHasEventHandlerLeakWarning && getMaxListeners(signal) === defaultMaxListeners)
setMaxListeners(1500, signal);
util.addAbortListener(signal, abort), requestFinalizer.register(ac, { signal, abort }, abort);
}
if (this.#headers = new Headers(kConstruct), setHeadersList(this.#headers, request.headersList), setHeadersGuard(this.#headers, "request"), mode === "no-cors") {
if (!corsSafeListedMethodsSet.has(request.method))
throw new TypeError(`'${request.method} is unsupported in no-cors mode.`);
setHeadersGuard(this.#headers, "request-no-cors");
}
if (initHasKey) {
let headersList = getHeadersList(this.#headers), headers = init.headers !== void 0 ? init.headers : new HeadersList(headersList);
if (headersList.clear(), headers instanceof HeadersList) {
for (let { name, value } of headers.rawValues())
headersList.append(name, value, !1);
headersList.cookies = headers.cookies;
} else
fillHeaders(this.#headers, headers);
}
let inputBody = webidl.is.Request(input) ? input.#state.body : null;
if ((init.body != null || inputBody != null) && (request.method === "GET" || request.method === "HEAD"))
throw new TypeError("Request with GET/HEAD method cannot have body.");
let initBody = null;
if (init.body != null) {
let [extractedBody, contentType] = extractBody(init.body, request.keepalive);
if (initBody = extractedBody, contentType && !getHeadersList(this.#headers).contains("content-type", !0))
this.#headers.append("content-type", contentType, !0);
}
let inputOrInitBody = initBody ?? inputBody;
if (inputOrInitBody != null && inputOrInitBody.source == null) {
if (initBody != null && init.duplex == null)
throw new TypeError("RequestInit: duplex option is required when sending a body.");
if (request.mode !== "same-origin" && request.mode !== "cors")
throw new TypeError('If request is made from ReadableStream, mode should be "same-origin" or "cors"');
request.useCORSPreflightFlag = !0;
}
let finalBody = inputOrInitBody;
if (initBody == null && inputBody != null) {
if (bodyUnusable(input.#state))
throw new TypeError("Cannot construct a Request with a Request object that has already been used.");
let identityTransform = new TransformStream;
inputBody.stream.pipeThrough(identityTransform), finalBody = {
source: inputBody.source,
length: inputBody.length,
stream: identityTransform.readable
};
}
this.#state.body = finalBody;
}
get method() {
return webidl.brandCheck(this, Request), this.#state.method;
}
get url() {
return webidl.brandCheck(this, Request), URLSerializer(this.#state.url);
}
get headers() {
return webidl.brandCheck(this, Request), this.#headers;
}
get destination() {
return webidl.brandCheck(this, Request), this.#state.destination;
}
get referrer() {
if (webidl.brandCheck(this, Request), this.#state.referrer === "no-referrer")
return "";
if (this.#state.referrer === "client")
return "about:client";
return this.#state.referrer.toString();
}
get referrerPolicy() {
return webidl.brandCheck(this, Request), this.#state.referrerPolicy;
}
get mode() {
return webidl.brandCheck(this, Request), this.#state.mode;
}
get credentials() {
return webidl.brandCheck(this, Request), this.#state.credentials;
}
get cache() {
return webidl.brandCheck(this, Request), this.#state.cache;
}
get redirect() {
return webidl.brandCheck(this, Request), this.#state.redirect;
}
get integrity() {
return webidl.brandCheck(this, Request), this.#state.integrity;
}
get keepalive() {
return webidl.brandCheck(this, Request), this.#state.keepalive;
}
get isReloadNavigation() {
return webidl.brandCheck(this, Request), this.#state.reloadNavigation;
}
get isHistoryNavigation() {
return webidl.brandCheck(this, Request), this.#state.historyNavigation;
}
get signal() {
return webidl.brandCheck(this, Request), this.#signal;
}
get body() {
return webidl.brandCheck(this, Request), this.#state.body ? this.#state.body.stream : null;
}
get bodyUsed() {
return webidl.brandCheck(this, Request), !!this.#state.body && util.isDisturbed(this.#state.body.stream);
}
get duplex() {
return webidl.brandCheck(this, Request), "half";
}
clone() {
if (webidl.brandCheck(this, Request), bodyUnusable(this.#state))
throw new TypeError("unusable");
let clonedRequest = cloneRequest(this.#state), ac = new AbortController;
if (this.signal.aborted)
ac.abort(this.signal.reason);
else {
let list = dependentControllerMap.get(this.signal);
if (list === void 0)
list = /* @__PURE__ */ new Set, dependentControllerMap.set(this.signal, list);
let acRef = new WeakRef(ac);
list.add(acRef), util.addAbortListener(ac.signal, buildAbort(acRef));
}
return fromInnerRequest(clonedRequest, this.#dispatcher, ac.signal, getHeadersGuard(this.#headers));
}
[nodeUtil.inspect.custom](depth, options) {
if (options.depth === null)
options.depth = 2;
options.colors ??= !0;
let properties = {
method: this.method,
url: this.url,
headers: this.headers,
destination: this.destination,
referrer: this.referrer,
referrerPolicy: this.referrerPolicy,
mode: this.mode,
credentials: this.credentials,
cache: this.cache,
redirect: this.redirect,
integrity: this.integrity,
keepalive: this.keepalive,
isReloadNavigation: this.isReloadNavigation,
isHistoryNavigation: this.isHistoryNavigation,
signal: this.signal
};
return `Request ${nodeUtil.formatWithOptions(options, properties)}`;
}
static setRequestSignal(request, newSignal) {
return request.#signal = newSignal, request;
}
static getRequestDispatcher(request) {
return request.#dispatcher;
}
static setRequestDispatcher(request, newDispatcher) {
request.#dispatcher = newDispatcher;
}
static setRequestHeaders(request, newHeaders) {
request.#headers = newHeaders;
}
static getRequestState(request) {
return request.#state;
}
static setRequestState(request, newState) {
request.#state = newState;
}
}
var { setRequestSignal, getRequestDispatcher, setRequestDispatcher, setRequestHeaders, getRequestState, setRequestState } = 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");
mixinBody(Request, getRequestState);
function makeRequest(init) {
return {
method: init.method ?? "GET",
localURLsOnly: init.localURLsOnly ?? !1,
unsafeRequest: init.unsafeRequest ?? !1,
body: init.body ?? null,
client: init.client ?? null,
reservedClient: init.reservedClient ?? null,
replacesClientId: init.replacesClientId ?? "",
window: init.window ?? "client",
keepalive: init.keepalive ?? !1,
serviceWorkers: init.serviceWorkers ?? "all",
initiator: init.initiator ?? "",
destination: init.destination ?? "",
priority: init.priority ?? null,
origin: init.origin ?? "client",
policyContainer: init.policyContainer ?? "client",
referrer: init.referrer ?? "client",
referrerPolicy: init.referrerPolicy ?? "",
mode: init.mode ?? "no-cors",
useCORSPreflightFlag: init.useCORSPreflightFlag ?? !1,
credentials: init.credentials ?? "same-origin",
useCredentials: init.useCredentials ?? !1,
cache: init.cache ?? "default",
redirect: init.redirect ?? "follow",
integrity: init.integrity ?? "",
cryptoGraphicsNonceMetadata: init.cryptoGraphicsNonceMetadata ?? "",
parserMetadata: init.parserMetadata ?? "",
reloadNavigation: init.reloadNavigation ?? !1,
historyNavigation: init.historyNavigation ?? !1,
userActivation: init.userActivation ?? !1,
taintedOrigin: init.taintedOrigin ?? !1,
redirectCount: init.redirectCount ?? 0,
responseTainting: init.responseTainting ?? "basic",
preventNoCacheCacheControlHeaderModification: init.preventNoCacheCacheControlHeaderModification ?? !1,
done: init.done ?? !1,
timingAllowFailed: init.timingAllowFailed ?? !1,
urlList: init.urlList,
url: init.urlList[0],
headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList
};
}
function cloneRequest(request) {
let newRequest = makeRequest({ ...request, body: null });
if (request.body != null)
newRequest.body = cloneBody(newRequest, request.body);
return newRequest;
}
function fromInnerRequest(innerRequest, dispatcher, signal, guard) {
let request = new Request(kConstruct);
setRequestState(request, innerRequest), setRequestDispatcher(request, dispatcher), setRequestSignal(request, signal);
let headers = new Headers(kConstruct);
return setRequestHeaders(request, headers), setHeadersList(headers, innerRequest.headersList), setHeadersGuard(headers, guard), request;
}
Object.defineProperties(Request.prototype, {
method: kEnumerableProperty,
url: kEnumerableProperty,
headers: kEnumerableProperty,
redirect: kEnumerableProperty,
clone: kEnumerableProperty,
signal: kEnumerableProperty,
duplex: kEnumerableProperty,
destination: kEnumerableProperty,
body: kEnumerableProperty,
bodyUsed: kEnumerableProperty,
isHistoryNavigation: kEnumerableProperty,
isReloadNavigation: kEnumerableProperty,
keepalive: kEnumerableProperty,
integrity: kEnumerableProperty,
cache: kEnumerableProperty,
credentials: kEnumerableProperty,
attribute: kEnumerableProperty,
referrerPolicy: kEnumerableProperty,
referrer: kEnumerableProperty,
mode: kEnumerableProperty,
[Symbol.toStringTag]: {
value: "Request",
configurable: !0
}
});
webidl.is.Request = webidl.util.MakeTypeAssertion(Request);
webidl.converters.RequestInfo = function(V, prefix, argument) {
if (typeof V === "string")
return webidl.converters.USVString(V);
if (webidl.is.Request(V))
return V;
return webidl.converters.USVString(V);
};
webidl.converters.RequestInit = webidl.dictionaryConverter([
{
key: "method",
converter: webidl.converters.ByteString
},
{
key: "headers",
converter: webidl.converters.HeadersInit
},
{
key: "body",
converter: webidl.nullableConverter(webidl.converters.BodyInit)
},
{
key: "referrer",
converter: webidl.converters.USVString
},
{
key: "referrerPolicy",
converter: webidl.converters.DOMString,
allowedValues: referrerPolicy
},
{
key: "mode",
converter: webidl.converters.DOMString,
allowedValues: requestMode
},
{
key: "credentials",
converter: webidl.converters.DOMString,
allowedValues: requestCredentials
},
{
key: "cache",
converter: webidl.converters.DOMString,
allowedValues: requestCache
},
{
key: "redirect",
converter: webidl.converters.DOMString,
allowedValues: requestRedirect
},
{
key: "integrity",
converter: webidl.converters.DOMString
},
{
key: "keepalive",
converter: webidl.converters.boolean
},
{
key: "signal",
converter: webidl.nullableConverter((signal) => webidl.converters.AbortSignal(signal, "RequestInit", "signal"))
},
{
key: "window",
converter: webidl.converters.any
},
{
key: "duplex",
converter: webidl.converters.DOMString,
allowedValues: requestDuplex
},
{
key: "dispatcher",
converter: webidl.converters.any
}
]);
module.exports = {
Request,
makeRequest,
fromInnerRequest,
cloneRequest,
getRequestDispatcher,
getRequestState
};
});
// undici/lib/web/fetch/response.js
var require_response = __commonJS((exports, module) => {
var { Headers, HeadersList, fill, getHeadersGuard, setHeadersGuard, setHeadersList } = require_headers(), { extractBody, cloneBody, mixinBody, hasFinalizationRegistry, streamRegistry, bodyUnusable } = require_body(), util = require_util(), nodeUtil = __require("node:util"), { kEnumerableProperty } = util, {
isValidReasonPhrase,
isCancelled,
isAborted,
serializeJavascriptValueToJSONString,
isErrorLike,
isomorphicEncode,
environmentSettingsObject: relevantRealm
} = require_util2(), {
redirectStatusSet,
nullBodyStatus
} = require_constants(), { webidl } = require_webidl(), { URLSerializer } = require_data_url(), { kConstruct } = require_symbols(), assert = __require("node:assert"), { types } = __require("node:util"), textEncoder = new TextEncoder("utf-8");
class Response {
#headers;
#state;
static error() {
return fromInnerResponse(makeNetworkError(), "immutable");
}
static json(data, init = void 0) {
if (webidl.argumentLengthCheck(arguments, 1, "Response.json"), init !== null)
init = webidl.converters.ResponseInit(init);
let bytes = textEncoder.encode(serializeJavascriptValueToJSONString(data)), body = extractBody(bytes), responseObject = fromInnerResponse(makeResponse({}), "response");
return initializeResponse(responseObject, init, { body: body[0], type: "application/json" }), responseObject;
}
static redirect(url, status = 302) {
webidl.argumentLengthCheck(arguments, 1, "Response.redirect"), url = webidl.converters.USVString(url), status = webidl.converters["unsigned short"](status);
let parsedURL;
try {
parsedURL = new URL(url, relevantRealm.settingsObject.baseUrl);
} catch (err) {
throw new TypeError(`Failed to parse URL from ${url}`, { cause: err });
}
if (!redirectStatusSet.has(status))
throw new RangeError(`Invalid status code ${status}`);
let responseObject = fromInnerResponse(makeResponse({}), "immutable");
responseObject.#state.status = status;
let value = isomorphicEncode(URLSerializer(parsedURL));
return responseObject.#state.headersList.append("location", value, !0), responseObject;
}
constructor(body = null, init = void 0) {
if (webidl.util.markAsUncloneable(this), body === kConstruct)
return;
if (body !== null)
body = webidl.converters.BodyInit(body);
init = webidl.converters.ResponseInit(init), this.#state = makeResponse({}), this.#headers = new Headers(kConstruct), setHeadersGuard(this.#headers, "response"), setHeadersList(this.#headers, this.#state.headersList);
let bodyWithType = null;
if (body != null) {
let [extractedBody, type] = extractBody(body);
bodyWithType = { body: extractedBody, type };
}
initializeResponse(this, init, bodyWithType);
}
get type() {
return webidl.brandCheck(this, Response), this.#state.type;
}
get url() {
webidl.brandCheck(this, Response);
let urlList = this.#state.urlList, url = urlList[urlList.length - 1] ?? null;
if (url === null)
return "";
return URLSerializer(url, !0);
}
get redirected() {
return webidl.brandCheck(this, Response), this.#state.urlList.length > 1;
}
get status() {
return webidl.brandCheck(this, Response), this.#state.status;
}
get ok() {
return webidl.brandCheck(this, Response), this.#state.status >= 200 && this.#state.status <= 299;
}
get statusText() {
return webidl.brandCheck(this, Response), this.#state.statusText;
}
get headers() {
return webidl.brandCheck(this, Response), this.#headers;
}
get body() {
return webidl.brandCheck(this, Response), this.#state.body ? this.#state.body.stream : null;
}
get bodyUsed() {
return webidl.brandCheck(this, Response), !!this.#state.body && util.isDisturbed(this.#state.body.stream);
}
clone() {
if (webidl.brandCheck(this, Response), bodyUnusable(this.#state))
throw webidl.errors.exception({
header: "Response.clone",
message: "Body has already been consumed."
});
let clonedResponse = cloneResponse(this.#state);
return fromInnerResponse(clonedResponse, getHeadersGuard(this.#headers));
}
[nodeUtil.inspect.custom](depth, options) {
if (options.depth === null)
options.depth = 2;
options.colors ??= !0;
let properties = {
status: this.status,
statusText: this.statusText,
headers: this.headers,
body: this.body,
bodyUsed: this.bodyUsed,
ok: this.ok,
redirected: this.redirected,
type: this.type,
url: this.url
};
return `Response ${nodeUtil.formatWithOptions(options, properties)}`;
}
static getResponseHeaders(response) {
return response.#headers;
}
static setResponseHeaders(response, newHeaders) {
response.#headers = newHeaders;
}
static getResponseState(response) {
return response.#state;
}
static setResponseState(response, newState) {
response.#state = newState;
}
}
var { getResponseHeaders, setResponseHeaders, getResponseState, setResponseState } = Response;
Reflect.deleteProperty(Response, "getResponseHeaders");
Reflect.deleteProperty(Response, "setResponseHeaders");
Reflect.deleteProperty(Response, "getResponseState");
Reflect.deleteProperty(Response, "setResponseState");
mixinBody(Response, getResponseState);
Object.defineProperties(Response.prototype, {
type: kEnumerableProperty,
url: kEnumerableProperty,
status: kEnumerableProperty,
ok: kEnumerableProperty,
redirected: kEnumerableProperty,
statusText: kEnumerableProperty,
headers: kEnumerableProperty,
clone: kEnumerableProperty,
body: kEnumerableProperty,
bodyUsed: kEnumerableProperty,
[Symbol.toStringTag]: {
value: "Response",
configurable: !0
}
});
Object.defineProperties(Response, {
json: kEnumerableProperty,
redirect: kEnumerableProperty,
error: kEnumerableProperty
});
function cloneResponse(response) {
if (response.internalResponse)
return filterResponse(cloneResponse(response.internalResponse), response.type);
let newResponse = makeResponse({ ...response, body: null });
if (response.body != null)
newResponse.body = cloneBody(newResponse, response.body);
return newResponse;
}
function makeResponse(init) {
return {
aborted: !1,
rangeRequested: !1,
timingAllowPassed: !1,
requestIncludesCredentials: !1,
type: "default",
status: 200,
timingInfo: null,
cacheState: "",
statusText: "",
...init,
headersList: init?.headersList ? new HeadersList(init?.headersList) : new HeadersList,
urlList: init?.urlList ? [...init.urlList] : []
};
}
function makeNetworkError(reason) {
let isError = isErrorLike(reason);
return makeResponse({
type: "error",
status: 0,
error: isError ? reason : new Error(reason ? String(reason) : reason),
aborted: reason && reason.name === "AbortError"
});
}
function isNetworkError(response) {
return response.type === "error" && response.status === 0;
}
function makeFilteredResponse(response, state) {
return state = {
internalResponse: response,
...state
}, new Proxy(response, {
get(target, p) {
return p in state ? state[p] : target[p];
},
set(target, p, value) {
return assert(!(p in state)), target[p] = value, !0;
}
});
}
function filterResponse(response, type) {
if (type === "basic")
return makeFilteredResponse(response, {
type: "basic",
headersList: response.headersList
});
else if (type === "cors")
return makeFilteredResponse(response, {
type: "cors",
headersList: response.headersList
});
else if (type === "opaque")
return makeFilteredResponse(response, {
type: "opaque",
urlList: Object.freeze([]),
status: 0,
statusText: "",
body: null
});
else if (type === "opaqueredirect")
return makeFilteredResponse(response, {
type: "opaqueredirect",
status: 0,
statusText: "",
headersList: [],
body: null
});
else
assert(!1);
}
function makeAppropriateNetworkError(fetchParams, err = null) {
return assert(isCancelled(fetchParams)), isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException("Request was cancelled."), { cause: err }));
}
function initializeResponse(response, init, body) {
if (init.status !== null && (init.status < 200 || init.status > 599))
throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.');
if ("statusText" in init && init.statusText != null) {
if (!isValidReasonPhrase(String(init.statusText)))
throw new TypeError("Invalid statusText");
}
if ("status" in init && init.status != null)
getResponseState(response).status = init.status;
if ("statusText" in init && init.statusText != null)
getResponseState(response).statusText = init.statusText;
if ("headers" in init && init.headers != null)
fill(getResponseHeaders(response), init.headers);
if (body) {
if (nullBodyStatus.includes(response.status))
throw webidl.errors.exception({
header: "Response constructor",
message: `Invalid response status code ${response.status}`
});
if (getResponseState(response).body = body.body, body.type != null && !getResponseState(response).headersList.contains("content-type", !0))
getResponseState(response).headersList.append("content-type", body.type, !0);
}
}
function fromInnerResponse(innerResponse, guard) {
let response = new Response(kConstruct);
setResponseState(response, innerResponse);
let headers = new Headers(kConstruct);
if (setResponseHeaders(response, headers), setHeadersList(headers, innerResponse.headersList), setHeadersGuard(headers, guard), hasFinalizationRegistry && innerResponse.body?.stream)
streamRegistry.register(response, new WeakRef(innerResponse.body.stream));
return response;
}
webidl.converters.XMLHttpRequestBodyInit = function(V, prefix, name) {
if (typeof V === "string")
return webidl.converters.USVString(V, prefix, name);
if (webidl.is.Blob(V))
return V;
if (ArrayBuffer.isView(V) || types.isArrayBuffer(V))
return V;
if (webidl.is.FormData(V))
return V;
if (webidl.is.URLSearchParams(V))
return V;
return webidl.converters.DOMString(V, prefix, name);
};
webidl.converters.BodyInit = function(V, prefix, argument) {
if (webidl.is.ReadableStream(V))
return V;
if (V?.[Symbol.asyncIterator])
return V;
return webidl.converters.XMLHttpRequestBodyInit(V, prefix, argument);
};
webidl.converters.ResponseInit = webidl.dictionaryConverter([
{
key: "status",
converter: webidl.converters["unsigned short"],
defaultValue: () => 200
},
{
key: "statusText",
converter: webidl.converters.ByteString,
defaultValue: () => ""
},
{
key: "headers",
converter: webidl.converters.HeadersInit
}
]);
webidl.is.Response = webidl.util.MakeTypeAssertion(Response);
module.exports = {
isNetworkError,
makeNetworkError,
makeResponse,
makeAppropriateNetworkError,
filterResponse,
Response,
cloneResponse,
fromInnerResponse,
getResponseState
};
});
// undici/lib/handler/wrap-handler.js
var require_wrap_handler = __commonJS((exports, module) => {
var { InvalidArgumentError } = require_errors();
module.exports = class WrapHandler {
#handler;
constructor(handler) {
this.#handler = handler;
}
static wrap(handler) {
return handler.onRequestStart ? handler : new WrapHandler(handler);
}
onConnect(abort, context) {
return this.#handler.onConnect?.(abort, context);
}
onHeaders(statusCode, rawHeaders, resume, statusMessage) {
return this.#handler.onHeaders?.(statusCode, rawHeaders, resume, statusMessage);
}
onUpgrade(statusCode, rawHeaders, socket) {
return this.#handler.onUpgrade?.(statusCode, rawHeaders, socket);
}
onData(data) {
return this.#handler.onData?.(data);
}
onComplete(trailers) {
return this.#handler.onComplete?.(trailers);
}
onError(err) {
if (!this.#handler.onError)
throw err;
return this.#handler.onError?.(err);
}
onRequestStart(controller, context) {
this.#handler.onConnect?.((reason) => controller.abort(reason), context);
}
onRequestUpgrade(controller, statusCode, headers, socket) {
let rawHeaders = [];
for (let [key, val] of Object.entries(headers))
rawHeaders.push(Buffer.from(key), Array.isArray(val) ? val.map((v) => Buffer.from(v)) : Buffer.from(val));
this.#handler.onUpgrade?.(statusCode, rawHeaders, socket);
}
onResponseStart(controller, statusCode, headers, statusMessage) {
let rawHeaders = [];
for (let [key, val] of Object.entries(headers))
rawHeaders.push(Buffer.from(key), Array.isArray(val) ? val.map((v) => Buffer.from(v)) : Buffer.from(val));
if (this.#handler.onHeaders?.(statusCode, rawHeaders, () => controller.resume(), statusMessage) === !1)
controller.pause();
}
onResponseData(controller, data) {
if (this.#handler.onData?.(data) === !1)
controller.pause();
}
onResponseEnd(controller, trailers) {
let rawTrailers = [];
for (let [key, val] of Object.entries(trailers))
rawTrailers.push(Buffer.from(key), Array.isArray(val) ? val.map((v) => Buffer.from(v)) : Buffer.from(val));
this.#handler.onComplete?.(rawTrailers);
}
onResponseError(controller, err) {
if (!this.#handler.onError)
throw new InvalidArgumentError("invalid onError method");
this.#handler.onError?.(err);
}
};
});
// undici/lib/dispatcher/dispatcher.js
var require_dispatcher = __commonJS((exports, module) => {
var EventEmitter = __require("node:events"), WrapHandler = require_wrap_handler(), wrapInterceptor = (dispatch) => (opts, handler) => dispatch(opts, WrapHandler.wrap(handler));
class Dispatcher extends EventEmitter {
dispatch() {
throw new Error("not implemented");
}
close() {
throw new Error("not implemented");
}
destroy() {
throw new Error("not implemented");
}
compose(...args) {
let interceptors = Array.isArray(args[0]) ? args[0] : args, dispatch = this.dispatch.bind(this);
for (let interceptor of interceptors) {
if (interceptor == null)
continue;
if (typeof interceptor !== "function")
throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`);
if (dispatch = interceptor(dispatch), dispatch = wrapInterceptor(dispatch), dispatch == null || typeof dispatch !== "function" || dispatch.length !== 2)
throw new TypeError("invalid interceptor");
}
return new Proxy(this, {
get: (target, key) => key === "dispatch" ? dispatch : target[key]
});
}
}
module.exports = Dispatcher;
});
// undici/lib/handler/unwrap-handler.js
var require_unwrap_handler = __commonJS((exports, module) => {
var { parseHeaders } = require_util(), { InvalidArgumentError } = require_errors(), kResume = Symbol("resume");
class UnwrapController {
#paused = !1;
#reason = null;
#aborted = !1;
#abort;
[kResume] = null;
constructor(abort) {
this.#abort = abort;
}
pause() {
this.#paused = !0;
}
resume() {
if (this.#paused)
this.#paused = !1, this[kResume]?.();
}
abort(reason) {
if (!this.#aborted)
this.#aborted = !0, this.#reason = reason, this.#abort(reason);
}
get aborted() {
return this.#aborted;
}
get reason() {
return this.#reason;
}
get paused() {
return this.#paused;
}
}
module.exports = class UnwrapHandler {
#handler;
#controller;
constructor(handler) {
this.#handler = handler;
}
static unwrap(handler) {
return !handler.onRequestStart ? handler : new UnwrapHandler(handler);
}
onConnect(abort, context) {
this.#controller = new UnwrapController(abort), this.#handler.onRequestStart?.(this.#controller, context);
}
onUpgrade(statusCode, rawHeaders, socket) {
this.#handler.onRequestUpgrade?.(this.#controller, statusCode, parseHeaders(rawHeaders), socket);
}
onHeaders(statusCode, rawHeaders, resume, statusMessage) {
return this.#controller[kResume] = resume, this.#handler.onResponseStart?.(this.#controller, statusCode, parseHeaders(rawHeaders), statusMessage), !this.#controller.paused;
}
onData(data) {
return this.#handler.onResponseData?.(this.#controller, data), !this.#controller.paused;
}
onComplete(rawTrailers) {
this.#handler.onResponseEnd?.(this.#controller, parseHeaders(rawTrailers));
}
onError(err) {
if (!this.#handler.onResponseError)
throw new InvalidArgumentError("invalid onError method");
this.#handler.onResponseError?.(this.#controller, err);
}
};
});
// undici/lib/dispatcher/dispatcher-base.js
var require_dispatcher_base = __commonJS((exports, module) => {
var Dispatcher = require_dispatcher(), UnwrapHandler = require_unwrap_handler(), {
ClientDestroyedError,
ClientClosedError,
InvalidArgumentError
} = require_errors(), { kDestroy, kClose, kClosed, kDestroyed, kDispatch } = require_symbols(), kOnDestroyed = Symbol("onDestroyed"), kOnClosed = Symbol("onClosed");
class DispatcherBase extends Dispatcher {
constructor() {
super();
this[kDestroyed] = !1, this[kOnDestroyed] = null, this[kClosed] = !1, this[kOnClosed] = [];
}
get destroyed() {
return this[kDestroyed];
}
get closed() {
return this[kClosed];
}
close(callback) {
if (callback === void 0)
return new Promise((resolve, reject) => {
this.close((err, data) => {
return err ? reject(err) : resolve(data);
});
});
if (typeof callback !== "function")
throw new InvalidArgumentError("invalid callback");
if (this[kDestroyed]) {
queueMicrotask(() => callback(new ClientDestroyedError, null));
return;
}
if (this[kClosed]) {
if (this[kOnClosed])
this[kOnClosed].push(callback);
else
queueMicrotask(() => callback(null, null));
return;
}
this[kClosed] = !0, this[kOnClosed].push(callback);
let onClosed = () => {
let callbacks = this[kOnClosed];
this[kOnClosed] = null;
for (let i = 0;i < callbacks.length; i++)
callbacks[i](null, null);
};
this[kClose]().then(() => this.destroy()).then(() => {
queueMicrotask(onClosed);
});
}
destroy(err, callback) {
if (typeof err === "function")
callback = err, err = null;
if (callback === void 0)
return new Promise((resolve, reject) => {
this.destroy(err, (err2, data) => {
return err2 ? reject(err2) : resolve(data);
});
});
if (typeof callback !== "function")
throw new InvalidArgumentError("invalid callback");
if (this[kDestroyed]) {
if (this[kOnDestroyed])
this[kOnDestroyed].push(callback);
else
queueMicrotask(() => callback(null, null));
return;
}
if (!err)
err = new ClientDestroyedError;
this[kDestroyed] = !0, this[kOnDestroyed] = this[kOnDestroyed] || [], this[kOnDestroyed].push(callback);
let onDestroyed = () => {
let callbacks = this[kOnDestroyed];
this[kOnDestroyed] = null;
for (let i = 0;i < callbacks.length; i++)
callbacks[i](null, null);
};
this[kDestroy](err).then(() => {
queueMicrotask(onDestroyed);
});
}
dispatch(opts, handler) {
if (!handler || typeof handler !== "object")
throw new InvalidArgumentError("handler must be an object");
handler = UnwrapHandler.unwrap(handler);
try {
if (!opts || typeof opts !== "object")
throw new InvalidArgumentError("opts must be an object.");
if (this[kDestroyed] || this[kOnDestroyed])
throw new ClientDestroyedError;
if (this[kClosed])
throw new ClientClosedError;
return this[kDispatch](opts, handler);
} catch (err) {
if (typeof handler.onError !== "function")
throw err;
return handler.onError(err), !1;
}
}
}
module.exports = DispatcherBase;
});
// undici/lib/dispatcher/fixed-queue.js
var require_fixed_queue = __commonJS((exports, module) => {
class FixedCircularBuffer {
constructor() {
this.bottom = 0, this.top = 0, this.list = new Array(2048).fill(void 0), this.next = null;
}
isEmpty() {
return this.top === this.bottom;
}
isFull() {
return (this.top + 1 & 2047) === this.bottom;
}
push(data) {
this.list[this.top] = data, this.top = this.top + 1 & 2047;
}
shift() {
let nextItem = this.list[this.bottom];
if (nextItem === void 0)
return null;
return this.list[this.bottom] = void 0, this.bottom = this.bottom + 1 & 2047, nextItem;
}
}
module.exports = class FixedQueue {
constructor() {
this.head = this.tail = new FixedCircularBuffer;
}
isEmpty() {
return this.head.isEmpty();
}
push(data) {
if (this.head.isFull())
this.head = this.head.next = new FixedCircularBuffer;
this.head.push(data);
}
shift() {
let tail = this.tail, next = tail.shift();
if (tail.isEmpty() && tail.next !== null)
this.tail = tail.next, tail.next = null;
return next;
}
};
});
// undici/lib/dispatcher/pool-stats.js
var require_pool_stats = __commonJS((exports, module) => {
var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols(), kPool = Symbol("pool");
class PoolStats {
constructor(pool) {
this[kPool] = pool;
}
get connected() {
return this[kPool][kConnected];
}
get free() {
return this[kPool][kFree];
}
get pending() {
return this[kPool][kPending];
}
get queued() {
return this[kPool][kQueued];
}
get running() {
return this[kPool][kRunning];
}
get size() {
return this[kPool][kSize];
}
}
module.exports = PoolStats;
});
// undici/lib/dispatcher/pool-base.js
var require_pool_base = __commonJS((exports, module) => {
var DispatcherBase = require_dispatcher_base(), FixedQueue = require_fixed_queue(), { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols(), PoolStats = require_pool_stats(), kClients = Symbol("clients"), kNeedDrain = Symbol("needDrain"), kQueue = Symbol("queue"), kClosedResolve = Symbol("closed resolve"), kOnDrain = Symbol("onDrain"), kOnConnect = Symbol("onConnect"), kOnDisconnect = Symbol("onDisconnect"), kOnConnectionError = Symbol("onConnectionError"), kGetDispatcher = Symbol("get dispatcher"), kAddClient = Symbol("add client"), kRemoveClient = Symbol("remove client"), kStats = Symbol("stats");
class PoolBase extends DispatcherBase {
constructor() {
super();
this[kQueue] = new FixedQueue, this[kClients] = [], this[kQueued] = 0;
let pool = this;
this[kOnDrain] = function onDrain(origin, targets) {
let queue = pool[kQueue], needDrain = !1;
while (!needDrain) {
let item = queue.shift();
if (!item)
break;
pool[kQueued]--, needDrain = !this.dispatch(item.opts, item.handler);
}
if (this[kNeedDrain] = needDrain, !this[kNeedDrain] && pool[kNeedDrain])
pool[kNeedDrain] = !1, pool.emit("drain", origin, [pool, ...targets]);
if (pool[kClosedResolve] && queue.isEmpty())
Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]);
}, this[kOnConnect] = (origin, targets) => {
pool.emit("connect", origin, [pool, ...targets]);
}, this[kOnDisconnect] = (origin, targets, err) => {
pool.emit("disconnect", origin, [pool, ...targets], err);
}, this[kOnConnectionError] = (origin, targets, err) => {
pool.emit("connectionError", origin, [pool, ...targets], err);
}, this[kStats] = new PoolStats(this);
}
get [kBusy]() {
return this[kNeedDrain];
}
get [kConnected]() {
return this[kClients].filter((client) => client[kConnected]).length;
}
get [kFree]() {
return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length;
}
get [kPending]() {
let ret = this[kQueued];
for (let { [kPending]: pending } of this[kClients])
ret += pending;
return ret;
}
get [kRunning]() {
let ret = 0;
for (let { [kRunning]: running } of this[kClients])
ret += running;
return ret;
}
get [kSize]() {
let ret = this[kQueued];
for (let { [kSize]: size } of this[kClients])
ret += size;
return ret;
}
get stats() {
return this[kStats];
}
async[kClose]() {
if (this[kQueue].isEmpty())
await Promise.all(this[kClients].map((c) => c.close()));
else
await new Promise((resolve) => {
this[kClosedResolve] = resolve;
});
}
async[kDestroy](err) {
while (!0) {
let item = this[kQueue].shift();
if (!item)
break;
item.handler.onError(err);
}
await Promise.all(this[kClients].map((c) => c.destroy(err)));
}
[kDispatch](opts, handler) {
let dispatcher = this[kGetDispatcher]();
if (!dispatcher)
this[kNeedDrain] = !0, this[kQueue].push({ opts, handler }), this[kQueued]++;
else if (!dispatcher.dispatch(opts, handler))
dispatcher[kNeedDrain] = !0, this[kNeedDrain] = !this[kGetDispatcher]();
return !this[kNeedDrain];
}
[kAddClient](client) {
if (client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]), this[kClients].push(client), this[kNeedDrain])
queueMicrotask(() => {
if (this[kNeedDrain])
this[kOnDrain](client[kUrl], [this, client]);
});
return this;
}
[kRemoveClient](client) {
client.close(() => {
let idx = this[kClients].indexOf(client);
if (idx !== -1)
this[kClients].splice(idx, 1);
}), this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== !0 && dispatcher.destroyed !== !0);
}
}
module.exports = {
PoolBase,
kClients,
kNeedDrain,
kAddClient,
kRemoveClient,
kGetDispatcher
};
});
// undici/lib/core/request.js
var require_request2 = __commonJS((exports, module) => {
var {
InvalidArgumentError,
NotSupportedError
} = require_errors(), assert = __require("node:assert"), {
isValidHTTPToken,
isValidHeaderValue,
isStream,
destroy,
isBuffer,
isFormDataLike,
isIterable,
isBlobLike,
serializePathWithQuery,
assertRequestHandler,
getServerName,
normalizedMethodRecords
} = require_util(), { channels } = require_diagnostics(), { headerNameLowerCasedRecord } = require_constants2(), invalidPathRegex = /[^\u0021-\u00ff]/, kHandler = Symbol("handler");
class Request {
constructor(origin, {
path,
method,
body,
headers,
query,
idempotent,
blocking,
upgrade,
headersTimeout,
bodyTimeout,
reset,
expectContinue,
servername,
throwOnError
}, handler) {
if (typeof path !== "string")
throw new InvalidArgumentError("path must be a string");
else if (path[0] !== "/" && !(path.startsWith("http://") || path.startsWith("https://")) && method !== "CONNECT")
throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
else if (invalidPathRegex.test(path))
throw new InvalidArgumentError("invalid request path");
if (typeof method !== "string")
throw new InvalidArgumentError("method must be a string");
else if (normalizedMethodRecords[method] === void 0 && !isValidHTTPToken(method))
throw new InvalidArgumentError("invalid request method");
if (upgrade && typeof upgrade !== "string")
throw new InvalidArgumentError("upgrade must be a string");
if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0))
throw new InvalidArgumentError("invalid headersTimeout");
if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0))
throw new InvalidArgumentError("invalid bodyTimeout");
if (reset != null && typeof reset !== "boolean")
throw new InvalidArgumentError("invalid reset");
if (expectContinue != null && typeof expectContinue !== "boolean")
throw new InvalidArgumentError("invalid expectContinue");
if (throwOnError != null)
throw new InvalidArgumentError("invalid throwOnError");
if (this.headersTimeout = headersTimeout, this.bodyTimeout = bodyTimeout, this.method = method, this.abort = null, body == null)
this.body = null;
else if (isStream(body)) {
this.body = body;
let rState = this.body._readableState;
if (!rState || !rState.autoDestroy)
this.endHandler = function autoDestroy() {
destroy(this);
}, this.body.on("end", this.endHandler);
this.errorHandler = (err) => {
if (this.abort)
this.abort(err);
else
this.error = err;
}, this.body.on("error", this.errorHandler);
} else if (isBuffer(body))
this.body = body.byteLength ? body : null;
else if (ArrayBuffer.isView(body))
this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null;
else if (body instanceof ArrayBuffer)
this.body = body.byteLength ? Buffer.from(body) : null;
else if (typeof body === "string")
this.body = body.length ? Buffer.from(body) : null;
else if (isFormDataLike(body) || isIterable(body) || isBlobLike(body))
this.body = body;
else
throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable");
if (this.completed = !1, this.aborted = !1, this.upgrade = upgrade || null, this.path = query ? serializePathWithQuery(path, query) : path, this.origin = origin, this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent, this.blocking = blocking ?? this.method !== "HEAD", this.reset = reset == null ? null : reset, this.host = null, this.contentLength = null, this.contentType = null, this.headers = [], this.expectContinue = expectContinue != null ? expectContinue : !1, Array.isArray(headers)) {
if (headers.length % 2 !== 0)
throw new InvalidArgumentError("headers array must be even");
for (let i = 0;i < headers.length; i += 2)
processHeader(this, headers[i], headers[i + 1]);
} else if (headers && typeof headers === "object")
if (headers[Symbol.iterator])
for (let header of headers) {
if (!Array.isArray(header) || header.length !== 2)
throw new InvalidArgumentError("headers must be in key-value pair format");
processHeader(this, header[0], header[1]);
}
else {
let keys = Object.keys(headers);
for (let i = 0;i < keys.length; ++i)
processHeader(this, keys[i], headers[keys[i]]);
}
else if (headers != null)
throw new InvalidArgumentError("headers must be an object or an array");
if (assertRequestHandler(handler, method, upgrade), this.servername = servername || getServerName(this.host) || null, this[kHandler] = handler, channels.create.hasSubscribers)
channels.create.publish({ request: this });
}
onBodySent(chunk) {
if (this[kHandler].onBodySent)
try {
return this[kHandler].onBodySent(chunk);
} catch (err) {
this.abort(err);
}
}
onRequestSent() {
if (channels.bodySent.hasSubscribers)
channels.bodySent.publish({ request: this });
if (this[kHandler].onRequestSent)
try {
return this[kHandler].onRequestSent();
} catch (err) {
this.abort(err);
}
}
onConnect(abort) {
if (assert(!this.aborted), assert(!this.completed), this.error)
abort(this.error);
else
return this.abort = abort, this[kHandler].onConnect(abort);
}
onResponseStarted() {
return this[kHandler].onResponseStarted?.();
}
onHeaders(statusCode, headers, resume, statusText) {
if (assert(!this.aborted), assert(!this.completed), channels.headers.hasSubscribers)
channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
try {
return this[kHandler].onHeaders(statusCode, headers, resume, statusText);
} catch (err) {
this.abort(err);
}
}
onData(chunk) {
assert(!this.aborted), assert(!this.completed);
try {
return this[kHandler].onData(chunk);
} catch (err) {
return this.abort(err), !1;
}
}
onUpgrade(statusCode, headers, socket) {
return assert(!this.aborted), assert(!this.completed), this[kHandler].onUpgrade(statusCode, headers, socket);
}
onComplete(trailers) {
if (this.onFinally(), assert(!this.aborted), assert(!this.completed), this.completed = !0, channels.trailers.hasSubscribers)
channels.trailers.publish({ request: this, trailers });
try {
return this[kHandler].onComplete(trailers);
} catch (err) {
this.onError(err);
}
}
onError(error) {
if (this.onFinally(), channels.error.hasSubscribers)
channels.error.publish({ request: this, error });
if (this.aborted)
return;
return this.aborted = !0, this[kHandler].onError(error);
}
onFinally() {
if (this.errorHandler)
this.body.off("error", this.errorHandler), this.errorHandler = null;
if (this.endHandler)
this.body.off("end", this.endHandler), this.endHandler = null;
}
addHeader(key, value) {
return processHeader(this, key, value), this;
}
}
function processHeader(request, key, val) {
if (val && (typeof val === "object" && !Array.isArray(val)))
throw new InvalidArgumentError(`invalid ${key} header`);
else if (val === void 0)
return;
let headerName = headerNameLowerCasedRecord[key];
if (headerName === void 0) {
if (headerName = key.toLowerCase(), headerNameLowerCasedRecord[headerName] === void 0 && !isValidHTTPToken(headerName))
throw new InvalidArgumentError("invalid header key");
}
if (Array.isArray(val)) {
let arr = [];
for (let i = 0;i < val.length; i++)
if (typeof val[i] === "string") {
if (!isValidHeaderValue(val[i]))
throw new InvalidArgumentError(`invalid ${key} header`);
arr.push(val[i]);
} else if (val[i] === null)
arr.push("");
else if (typeof val[i] === "object")
throw new InvalidArgumentError(`invalid ${key} header`);
else
arr.push(`${val[i]}`);
val = arr;
} else if (typeof val === "string") {
if (!isValidHeaderValue(val))
throw new InvalidArgumentError(`invalid ${key} header`);
} else if (val === null)
val = "";
else
val = `${val}`;
if (request.host === null && headerName === "host") {
if (typeof val !== "string")
throw new InvalidArgumentError("invalid host header");
request.host = val;
} else if (request.contentLength === null && headerName === "content-length") {
if (request.contentLength = parseInt(val, 10), !Number.isFinite(request.contentLength))
throw new InvalidArgumentError("invalid content-length header");
} else if (request.contentType === null && headerName === "content-type")
request.contentType = val, request.headers.push(key, val);
else if (headerName === "transfer-encoding" || headerName === "keep-alive" || headerName === "upgrade")
throw new InvalidArgumentError(`invalid ${headerName} header`);
else if (headerName === "connection") {
let value = typeof val === "string" ? val.toLowerCase() : null;
if (value !== "close" && value !== "keep-alive")
throw new InvalidArgumentError("invalid connection header");
if (value === "close")
request.reset = !0;
} else if (headerName === "expect")
throw new NotSupportedError("expect header not supported");
else
request.headers.push(key, val);
}
module.exports = Request;
});
// undici/lib/util/timers.js
var require_timers = __commonJS((exports, module) => {
var fastNow = 0, RESOLUTION_MS = 1000, TICK_MS = (RESOLUTION_MS >> 1) - 1, fastNowTimeout, kFastTimer = Symbol("kFastTimer"), fastTimers = [], NOT_IN_LIST = -2, TO_BE_CLEARED = -1, PENDING = 0, ACTIVE = 1;
function onTick() {
fastNow += TICK_MS;
let idx = 0, len = fastTimers.length;
while (idx < len) {
let timer = fastTimers[idx];
if (timer._state === PENDING)
timer._idleStart = fastNow - TICK_MS, timer._state = ACTIVE;
else if (timer._state === ACTIVE && fastNow >= timer._idleStart + timer._idleTimeout)
timer._state = TO_BE_CLEARED, timer._idleStart = -1, timer._onTimeout(timer._timerArg);
if (timer._state === TO_BE_CLEARED) {
if (timer._state = NOT_IN_LIST, --len !== 0)
fastTimers[idx] = fastTimers[len];
} else
++idx;
}
if (fastTimers.length = len, fastTimers.length !== 0)
refreshTimeout();
}
function refreshTimeout() {
if (fastNowTimeout)
fastNowTimeout.refresh();
else if (clearTimeout(fastNowTimeout), fastNowTimeout = setTimeout(onTick, TICK_MS), fastNowTimeout.unref)
fastNowTimeout.unref();
}
class FastTimer {
[kFastTimer] = !0;
_state = NOT_IN_LIST;
_idleTimeout = -1;
_idleStart = -1;
_onTimeout;
_timerArg;
constructor(callback, delay, arg) {
this._onTimeout = callback, this._idleTimeout = delay, this._timerArg = arg, this.refresh();
}
refresh() {
if (this._state === NOT_IN_LIST)
fastTimers.push(this);
if (!fastNowTimeout || fastTimers.length === 1)
refreshTimeout();
this._state = PENDING;
}
clear() {
this._state = TO_BE_CLEARED, this._idleStart = -1;
}
}
module.exports = {
setTimeout(callback, delay, arg) {
return delay <= RESOLUTION_MS ? setTimeout(callback, delay, arg) : new FastTimer(callback, delay, arg);
},
clearTimeout(timeout) {
if (timeout[kFastTimer])
timeout.clear();
else
clearTimeout(timeout);
},
setFastTimeout(callback, delay, arg) {
return new FastTimer(callback, delay, arg);
},
clearFastTimeout(timeout) {
timeout.clear();
},
now() {
return fastNow;
},
tick(delay = 0) {
fastNow += delay - RESOLUTION_MS + 1, onTick(), onTick();
},
reset() {
fastNow = 0, fastTimers.length = 0, clearTimeout(fastNowTimeout), fastNowTimeout = null;
},
kFastTimer
};
});
// undici/lib/core/connect.js
var require_connect = __commonJS((exports, module) => {
var net = __require("node:net"), assert = __require("node:assert"), util = require_util(), { InvalidArgumentError, ConnectTimeoutError } = require_errors(), timers = require_timers();
function noop() {
}
var tls, SessionCache;
if (global.FinalizationRegistry && !(process.env.NODE_V8_COVERAGE || process.env.UNDICI_NO_FG))
SessionCache = class WeakSessionCache {
constructor(maxCachedSessions) {
this._maxCachedSessions = maxCachedSessions, this._sessionCache = /* @__PURE__ */ new Map, this._sessionRegistry = new global.FinalizationRegistry((key) => {
if (this._sessionCache.size < this._maxCachedSessions)
return;
let ref = this._sessionCache.get(key);
if (ref !== void 0 && ref.deref() === void 0)
this._sessionCache.delete(key);
});
}
get(sessionKey) {
let ref = this._sessionCache.get(sessionKey);
return ref ? ref.deref() : null;
}
set(sessionKey, session) {
if (this._maxCachedSessions === 0)
return;
this._sessionCache.set(sessionKey, new WeakRef(session)), this._sessionRegistry.register(session, sessionKey);
}
};
else
SessionCache = class SimpleSessionCache {
constructor(maxCachedSessions) {
this._maxCachedSessions = maxCachedSessions, this._sessionCache = /* @__PURE__ */ new Map;
}
get(sessionKey) {
return this._sessionCache.get(sessionKey);
}
set(sessionKey, session) {
if (this._maxCachedSessions === 0)
return;
if (this._sessionCache.size >= this._maxCachedSessions) {
let { value: oldestKey } = this._sessionCache.keys().next();
this._sessionCache.delete(oldestKey);
}
this._sessionCache.set(sessionKey, session);
}
};
function buildConnector({ allowH2, 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");
let options = { path: socketPath, ...opts }, sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
return timeout = timeout == null ? 1e4 : timeout, allowH2 = allowH2 != null ? allowH2 : !1, function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
let socket;
if (protocol === "https:") {
if (!tls)
tls = __require("node:tls");
servername = servername || options.servername || util.getServerName(host) || null;
let sessionKey = servername || hostname;
assert(sessionKey);
let session = customSession || sessionCache.get(sessionKey) || null;
port = port || 443, socket = tls.connect({
highWaterMark: 16384,
...options,
servername,
session,
localAddress,
ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"],
socket: httpSocket,
port,
host: hostname
}), socket.on("session", function(session2) {
sessionCache.set(sessionKey, session2);
});
} else
assert(!httpSocket, "httpSocket can only be sent on TLS update"), port = port || 80, socket = net.connect({
highWaterMark: 65536,
...options,
localAddress,
port,
host: hostname
});
if (options.keepAlive == null || options.keepAlive) {
let keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 60000 : options.keepAliveInitialDelay;
socket.setKeepAlive(!0, keepAliveInitialDelay);
}
let clearConnectTimeout = setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port });
return socket.setNoDelay(!0).once(protocol === "https:" ? "secureConnect" : "connect", function() {
if (queueMicrotask(clearConnectTimeout), callback) {
let cb = callback;
callback = null, cb(null, this);
}
}).on("error", function(err) {
if (queueMicrotask(clearConnectTimeout), callback) {
let cb = callback;
callback = null, cb(err);
}
}), socket;
};
}
var setupConnectTimeout = process.platform === "win32" ? (socketWeakRef, opts) => {
if (!opts.timeout)
return noop;
let s1 = null, s2 = null, fastTimer = timers.setFastTimeout(() => {
s1 = setImmediate(() => {
s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts));
});
}, opts.timeout);
return () => {
timers.clearFastTimeout(fastTimer), clearImmediate(s1), clearImmediate(s2);
};
} : (socketWeakRef, opts) => {
if (!opts.timeout)
return noop;
let s1 = null, fastTimer = timers.setFastTimeout(() => {
s1 = setImmediate(() => {
onConnectTimeout(socketWeakRef.deref(), opts);
});
}, opts.timeout);
return () => {
timers.clearFastTimeout(fastTimer), clearImmediate(s1);
};
};
function onConnectTimeout(socket, opts) {
if (socket == null)
return;
let message = "Connect Timeout Error";
if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses))
message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(", ")},`;
else
message += ` (attempted address: ${opts.hostname}:${opts.port},`;
message += ` timeout: ${opts.timeout}ms)`, util.destroy(socket, new ConnectTimeoutError(message));
}
module.exports = buildConnector;
});
// undici/lib/llhttp/utils.js
var require_utils = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: !0 });
exports.enumToMap = void 0;
function enumToMap(obj, filter = [], exceptions = []) {
var _a, _b;
let emptyFilter = ((_a = filter === null || filter === void 0 ? void 0 : filter.length) !== null && _a !== void 0 ? _a : 0) === 0, emptyExceptions = ((_b = exceptions === null || exceptions === void 0 ? void 0 : exceptions.length) !== null && _b !== void 0 ? _b : 0) === 0;
return Object.fromEntries(Object.entries(obj).filter(([, value]) => {
return typeof value === "number" && (emptyFilter || filter.includes(value)) && (emptyExceptions || !exceptions.includes(value));
}));
}
exports.enumToMap = enumToMap;
});
// undici/lib/llhttp/constants.js
var require_constants4 = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: !0 });
exports.SPECIAL_HEADERS = exports.MINOR = exports.MAJOR = exports.HTAB_SP_VCHAR_OBS_TEXT = exports.QUOTED_STRING = exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS = exports.TOKEN = exports.HEX = exports.URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.NUM = exports.HEX_MAP = exports.NUM_MAP = exports.ALPHA = exports.STATUSES_HTTP = exports.H_METHOD_MAP = exports.METHOD_MAP = exports.METHODS_RTSP = exports.METHODS_ICE = exports.METHODS_HTTP = exports.HEADER_STATE = exports.FINISH = exports.STATUSES = exports.METHODS = exports.LENIENT_FLAGS = exports.FLAGS = exports.TYPE = exports.ERROR = void 0;
var utils_1 = require_utils();
exports.ERROR = {
OK: 0,
INTERNAL: 1,
STRICT: 2,
CR_EXPECTED: 25,
LF_EXPECTED: 3,
UNEXPECTED_CONTENT_LENGTH: 4,
UNEXPECTED_SPACE: 30,
CLOSED_CONNECTION: 5,
INVALID_METHOD: 6,
INVALID_URL: 7,
INVALID_CONSTANT: 8,
INVALID_VERSION: 9,
INVALID_HEADER_TOKEN: 10,
INVALID_CONTENT_LENGTH: 11,
INVALID_CHUNK_SIZE: 12,
INVALID_STATUS: 13,
INVALID_EOF_STATE: 14,
INVALID_TRANSFER_ENCODING: 15,
CB_MESSAGE_BEGIN: 16,
CB_HEADERS_COMPLETE: 17,
CB_MESSAGE_COMPLETE: 18,
CB_CHUNK_HEADER: 19,
CB_CHUNK_COMPLETE: 20,
PAUSED: 21,
PAUSED_UPGRADE: 22,
PAUSED_H2_UPGRADE: 23,
USER: 24,
CB_URL_COMPLETE: 26,
CB_STATUS_COMPLETE: 27,
CB_METHOD_COMPLETE: 32,
CB_VERSION_COMPLETE: 33,
CB_HEADER_FIELD_COMPLETE: 28,
CB_HEADER_VALUE_COMPLETE: 29,
CB_CHUNK_EXTENSION_NAME_COMPLETE: 34,
CB_CHUNK_EXTENSION_VALUE_COMPLETE: 35,
CB_RESET: 31
};
exports.TYPE = {
BOTH: 0,
REQUEST: 1,
RESPONSE: 2
};
exports.FLAGS = {
CONNECTION_KEEP_ALIVE: 1,
CONNECTION_CLOSE: 2,
CONNECTION_UPGRADE: 4,
CHUNKED: 8,
UPGRADE: 16,
CONTENT_LENGTH: 32,
SKIPBODY: 64,
TRAILING: 128,
TRANSFER_ENCODING: 512
};
exports.LENIENT_FLAGS = {
HEADERS: 1,
CHUNKED_LENGTH: 2,
KEEP_ALIVE: 4,
TRANSFER_ENCODING: 8,
VERSION: 16,
DATA_AFTER_CLOSE: 32,
OPTIONAL_LF_AFTER_CR: 64,
OPTIONAL_CRLF_AFTER_CHUNK: 128,
OPTIONAL_CR_BEFORE_LF: 256,
SPACES_AFTER_CHUNK_SIZE: 512
};
exports.METHODS = {
DELETE: 0,
GET: 1,
HEAD: 2,
POST: 3,
PUT: 4,
CONNECT: 5,
OPTIONS: 6,
TRACE: 7,
COPY: 8,
LOCK: 9,
MKCOL: 10,
MOVE: 11,
PROPFIND: 12,
PROPPATCH: 13,
SEARCH: 14,
UNLOCK: 15,
BIND: 16,
REBIND: 17,
UNBIND: 18,
ACL: 19,
REPORT: 20,
MKACTIVITY: 21,
CHECKOUT: 22,
MERGE: 23,
"M-SEARCH": 24,
NOTIFY: 25,
SUBSCRIBE: 26,
UNSUBSCRIBE: 27,
PATCH: 28,
PURGE: 29,
MKCALENDAR: 30,
LINK: 31,
UNLINK: 32,
SOURCE: 33,
PRI: 34,
DESCRIBE: 35,
ANNOUNCE: 36,
SETUP: 37,
PLAY: 38,
PAUSE: 39,
TEARDOWN: 40,
GET_PARAMETER: 41,
SET_PARAMETER: 42,
REDIRECT: 43,
RECORD: 44,
FLUSH: 45,
QUERY: 46
};
exports.STATUSES = {
CONTINUE: 100,
SWITCHING_PROTOCOLS: 101,
PROCESSING: 102,
EARLY_HINTS: 103,
RESPONSE_IS_STALE: 110,
REVALIDATION_FAILED: 111,
DISCONNECTED_OPERATION: 112,
HEURISTIC_EXPIRATION: 113,
MISCELLANEOUS_WARNING: 199,
OK: 200,
CREATED: 201,
ACCEPTED: 202,
NON_AUTHORITATIVE_INFORMATION: 203,
NO_CONTENT: 204,
RESET_CONTENT: 205,
PARTIAL_CONTENT: 206,
MULTI_STATUS: 207,
ALREADY_REPORTED: 208,
TRANSFORMATION_APPLIED: 214,
IM_USED: 226,
MISCELLANEOUS_PERSISTENT_WARNING: 299,
MULTIPLE_CHOICES: 300,
MOVED_PERMANENTLY: 301,
FOUND: 302,
SEE_OTHER: 303,
NOT_MODIFIED: 304,
USE_PROXY: 305,
SWITCH_PROXY: 306,
TEMPORARY_REDIRECT: 307,
PERMANENT_REDIRECT: 308,
BAD_REQUEST: 400,
UNAUTHORIZED: 401,
PAYMENT_REQUIRED: 402,
FORBIDDEN: 403,
NOT_FOUND: 404,
METHOD_NOT_ALLOWED: 405,
NOT_ACCEPTABLE: 406,
PROXY_AUTHENTICATION_REQUIRED: 407,
REQUEST_TIMEOUT: 408,
CONFLICT: 409,
GONE: 410,
LENGTH_REQUIRED: 411,
PRECONDITION_FAILED: 412,
PAYLOAD_TOO_LARGE: 413,
URI_TOO_LONG: 414,
UNSUPPORTED_MEDIA_TYPE: 415,
RANGE_NOT_SATISFIABLE: 416,
EXPECTATION_FAILED: 417,
IM_A_TEAPOT: 418,
PAGE_EXPIRED: 419,
ENHANCE_YOUR_CALM: 420,
MISDIRECTED_REQUEST: 421,
UNPROCESSABLE_ENTITY: 422,
LOCKED: 423,
FAILED_DEPENDENCY: 424,
TOO_EARLY: 425,
UPGRADE_REQUIRED: 426,
PRECONDITION_REQUIRED: 428,
TOO_MANY_REQUESTS: 429,
REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL: 430,
REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
LOGIN_TIMEOUT: 440,
NO_RESPONSE: 444,
RETRY_WITH: 449,
BLOCKED_BY_PARENTAL_CONTROL: 450,
UNAVAILABLE_FOR_LEGAL_REASONS: 451,
CLIENT_CLOSED_LOAD_BALANCED_REQUEST: 460,
INVALID_X_FORWARDED_FOR: 463,
REQUEST_HEADER_TOO_LARGE: 494,
SSL_CERTIFICATE_ERROR: 495,
SSL_CERTIFICATE_REQUIRED: 496,
HTTP_REQUEST_SENT_TO_HTTPS_PORT: 497,
INVALID_TOKEN: 498,
CLIENT_CLOSED_REQUEST: 499,
INTERNAL_SERVER_ERROR: 500,
NOT_IMPLEMENTED: 501,
BAD_GATEWAY: 502,
SERVICE_UNAVAILABLE: 503,
GATEWAY_TIMEOUT: 504,
HTTP_VERSION_NOT_SUPPORTED: 505,
VARIANT_ALSO_NEGOTIATES: 506,
INSUFFICIENT_STORAGE: 507,
LOOP_DETECTED: 508,
BANDWIDTH_LIMIT_EXCEEDED: 509,
NOT_EXTENDED: 510,
NETWORK_AUTHENTICATION_REQUIRED: 511,
WEB_SERVER_UNKNOWN_ERROR: 520,
WEB_SERVER_IS_DOWN: 521,
CONNECTION_TIMEOUT: 522,
ORIGIN_IS_UNREACHABLE: 523,
TIMEOUT_OCCURED: 524,
SSL_HANDSHAKE_FAILED: 525,
INVALID_SSL_CERTIFICATE: 526,
RAILGUN_ERROR: 527,
SITE_IS_OVERLOADED: 529,
SITE_IS_FROZEN: 530,
IDENTITY_PROVIDER_AUTHENTICATION_ERROR: 561,
NETWORK_READ_TIMEOUT: 598,
NETWORK_CONNECT_TIMEOUT: 599
};
exports.FINISH = {
SAFE: 0,
SAFE_WITH_CB: 1,
UNSAFE: 2
};
exports.HEADER_STATE = {
GENERAL: 0,
CONNECTION: 1,
CONTENT_LENGTH: 2,
TRANSFER_ENCODING: 3,
UPGRADE: 4,
CONNECTION_KEEP_ALIVE: 5,
CONNECTION_CLOSE: 6,
CONNECTION_UPGRADE: 7,
TRANSFER_ENCODING_CHUNKED: 8
};
exports.METHODS_HTTP = [
exports.METHODS.DELETE,
exports.METHODS.GET,
exports.METHODS.HEAD,
exports.METHODS.POST,
exports.METHODS.PUT,
exports.METHODS.CONNECT,
exports.METHODS.OPTIONS,
exports.METHODS.TRACE,
exports.METHODS.COPY,
exports.METHODS.LOCK,
exports.METHODS.MKCOL,
exports.METHODS.MOVE,
exports.METHODS.PROPFIND,
exports.METHODS.PROPPATCH,
exports.METHODS.SEARCH,
exports.METHODS.UNLOCK,
exports.METHODS.BIND,
exports.METHODS.REBIND,
exports.METHODS.UNBIND,
exports.METHODS.ACL,
exports.METHODS.REPORT,
exports.METHODS.MKACTIVITY,
exports.METHODS.CHECKOUT,
exports.METHODS.MERGE,
exports.METHODS["M-SEARCH"],
exports.METHODS.NOTIFY,
exports.METHODS.SUBSCRIBE,
exports.METHODS.UNSUBSCRIBE,
exports.METHODS.PATCH,
exports.METHODS.PURGE,
exports.METHODS.MKCALENDAR,
exports.METHODS.LINK,
exports.METHODS.UNLINK,
exports.METHODS.PRI,
exports.METHODS.SOURCE,
exports.METHODS.QUERY
];
exports.METHODS_ICE = [
exports.METHODS.SOURCE
];
exports.METHODS_RTSP = [
exports.METHODS.OPTIONS,
exports.METHODS.DESCRIBE,
exports.METHODS.ANNOUNCE,
exports.METHODS.SETUP,
exports.METHODS.PLAY,
exports.METHODS.PAUSE,
exports.METHODS.TEARDOWN,
exports.METHODS.GET_PARAMETER,
exports.METHODS.SET_PARAMETER,
exports.METHODS.REDIRECT,
exports.METHODS.RECORD,
exports.METHODS.FLUSH,
exports.METHODS.GET,
exports.METHODS.POST
];
exports.METHOD_MAP = utils_1.enumToMap(exports.METHODS);
exports.H_METHOD_MAP = Object.fromEntries(Object.entries(exports.METHODS).filter(([k]) => k.startsWith("H")));
exports.STATUSES_HTTP = [
exports.STATUSES.CONTINUE,
exports.STATUSES.SWITCHING_PROTOCOLS,
exports.STATUSES.PROCESSING,
exports.STATUSES.EARLY_HINTS,
exports.STATUSES.RESPONSE_IS_STALE,
exports.STATUSES.REVALIDATION_FAILED,
exports.STATUSES.DISCONNECTED_OPERATION,
exports.STATUSES.HEURISTIC_EXPIRATION,
exports.STATUSES.MISCELLANEOUS_WARNING,
exports.STATUSES.OK,
exports.STATUSES.CREATED,
exports.STATUSES.ACCEPTED,
exports.STATUSES.NON_AUTHORITATIVE_INFORMATION,
exports.STATUSES.NO_CONTENT,
exports.STATUSES.RESET_CONTENT,
exports.STATUSES.PARTIAL_CONTENT,
exports.STATUSES.MULTI_STATUS,
exports.STATUSES.ALREADY_REPORTED,
exports.STATUSES.TRANSFORMATION_APPLIED,
exports.STATUSES.IM_USED,
exports.STATUSES.MISCELLANEOUS_PERSISTENT_WARNING,
exports.STATUSES.MULTIPLE_CHOICES,
exports.STATUSES.MOVED_PERMANENTLY,
exports.STATUSES.FOUND,
exports.STATUSES.SEE_OTHER,
exports.STATUSES.NOT_MODIFIED,
exports.STATUSES.USE_PROXY,
exports.STATUSES.SWITCH_PROXY,
exports.STATUSES.TEMPORARY_REDIRECT,
exports.STATUSES.PERMANENT_REDIRECT,
exports.STATUSES.BAD_REQUEST,
exports.STATUSES.UNAUTHORIZED,
exports.STATUSES.PAYMENT_REQUIRED,
exports.STATUSES.FORBIDDEN,
exports.STATUSES.NOT_FOUND,
exports.STATUSES.METHOD_NOT_ALLOWED,
exports.STATUSES.NOT_ACCEPTABLE,
exports.STATUSES.PROXY_AUTHENTICATION_REQUIRED,
exports.STATUSES.REQUEST_TIMEOUT,
exports.STATUSES.CONFLICT,
exports.STATUSES.GONE,
exports.STATUSES.LENGTH_REQUIRED,
exports.STATUSES.PRECONDITION_FAILED,
exports.STATUSES.PAYLOAD_TOO_LARGE,
exports.STATUSES.URI_TOO_LONG,
exports.STATUSES.UNSUPPORTED_MEDIA_TYPE,
exports.STATUSES.RANGE_NOT_SATISFIABLE,
exports.STATUSES.EXPECTATION_FAILED,
exports.STATUSES.IM_A_TEAPOT,
exports.STATUSES.PAGE_EXPIRED,
exports.STATUSES.ENHANCE_YOUR_CALM,
exports.STATUSES.MISDIRECTED_REQUEST,
exports.STATUSES.UNPROCESSABLE_ENTITY,
exports.STATUSES.LOCKED,
exports.STATUSES.FAILED_DEPENDENCY,
exports.STATUSES.TOO_EARLY,
exports.STATUSES.UPGRADE_REQUIRED,
exports.STATUSES.PRECONDITION_REQUIRED,
exports.STATUSES.TOO_MANY_REQUESTS,
exports.STATUSES.REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL,
exports.STATUSES.REQUEST_HEADER_FIELDS_TOO_LARGE,
exports.STATUSES.LOGIN_TIMEOUT,
exports.STATUSES.NO_RESPONSE,
exports.STATUSES.RETRY_WITH,
exports.STATUSES.BLOCKED_BY_PARENTAL_CONTROL,
exports.STATUSES.UNAVAILABLE_FOR_LEGAL_REASONS,
exports.STATUSES.CLIENT_CLOSED_LOAD_BALANCED_REQUEST,
exports.STATUSES.INVALID_X_FORWARDED_FOR,
exports.STATUSES.REQUEST_HEADER_TOO_LARGE,
exports.STATUSES.SSL_CERTIFICATE_ERROR,
exports.STATUSES.SSL_CERTIFICATE_REQUIRED,
exports.STATUSES.HTTP_REQUEST_SENT_TO_HTTPS_PORT,
exports.STATUSES.INVALID_TOKEN,
exports.STATUSES.CLIENT_CLOSED_REQUEST,
exports.STATUSES.INTERNAL_SERVER_ERROR,
exports.STATUSES.NOT_IMPLEMENTED,
exports.STATUSES.BAD_GATEWAY,
exports.STATUSES.SERVICE_UNAVAILABLE,
exports.STATUSES.GATEWAY_TIMEOUT,
exports.STATUSES.HTTP_VERSION_NOT_SUPPORTED,
exports.STATUSES.VARIANT_ALSO_NEGOTIATES,
exports.STATUSES.INSUFFICIENT_STORAGE,
exports.STATUSES.LOOP_DETECTED,
exports.STATUSES.BANDWIDTH_LIMIT_EXCEEDED,
exports.STATUSES.NOT_EXTENDED,
exports.STATUSES.NETWORK_AUTHENTICATION_REQUIRED,
exports.STATUSES.WEB_SERVER_UNKNOWN_ERROR,
exports.STATUSES.WEB_SERVER_IS_DOWN,
exports.STATUSES.CONNECTION_TIMEOUT,
exports.STATUSES.ORIGIN_IS_UNREACHABLE,
exports.STATUSES.TIMEOUT_OCCURED,
exports.STATUSES.SSL_HANDSHAKE_FAILED,
exports.STATUSES.INVALID_SSL_CERTIFICATE,
exports.STATUSES.RAILGUN_ERROR,
exports.STATUSES.SITE_IS_OVERLOADED,
exports.STATUSES.SITE_IS_FROZEN,
exports.STATUSES.IDENTITY_PROVIDER_AUTHENTICATION_ERROR,
exports.STATUSES.NETWORK_READ_TIMEOUT,
exports.STATUSES.NETWORK_CONNECT_TIMEOUT
];
exports.ALPHA = [];
for (let i = 65;i <= 90; i++)
exports.ALPHA.push(String.fromCharCode(i)), exports.ALPHA.push(String.fromCharCode(i + 32));
exports.NUM_MAP = {
0: 0,
1: 1,
2: 2,
3: 3,
4: 4,
5: 5,
6: 6,
7: 7,
8: 8,
9: 9
};
exports.HEX_MAP = {
0: 0,
1: 1,
2: 2,
3: 3,
4: 4,
5: 5,
6: 6,
7: 7,
8: 8,
9: 9,
A: 10,
B: 11,
C: 12,
D: 13,
E: 14,
F: 15,
a: 10,
b: 11,
c: 12,
d: 13,
e: 14,
f: 15
};
exports.NUM = [
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9"
];
exports.ALPHANUM = exports.ALPHA.concat(exports.NUM);
exports.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"];
exports.USERINFO_CHARS = exports.ALPHANUM.concat(exports.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]);
exports.URL_CHAR = [
"!",
'"',
"$",
"%",
"&",
"'",
"(",
")",
"*",
"+",
",",
"-",
".",
"/",
":",
";",
"<",
"=",
">",
"@",
"[",
"\\",
"]",
"^",
"_",
"`",
"{",
"|",
"}",
"~"
].concat(exports.ALPHANUM);
exports.HEX = exports.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]);
exports.TOKEN = [
"!",
"#",
"$",
"%",
"&",
"'",
"*",
"+",
"-",
".",
"^",
"_",
"`",
"|",
"~"
].concat(exports.ALPHANUM);
exports.HEADER_CHARS = ["\t"];
for (let i = 32;i <= 255; i++)
if (i !== 127)
exports.HEADER_CHARS.push(i);
exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS.filter((c) => c !== 44);
exports.QUOTED_STRING = ["\t", " "];
for (let i = 33;i <= 255; i++)
if (i !== 34 && i !== 92)
exports.QUOTED_STRING.push(i);
exports.HTAB_SP_VCHAR_OBS_TEXT = ["\t", " "];
for (let i = 33;i <= 126; i++)
exports.HTAB_SP_VCHAR_OBS_TEXT.push(i);
for (let i = 128;i <= 255; i++)
exports.HTAB_SP_VCHAR_OBS_TEXT.push(i);
exports.MAJOR = exports.NUM_MAP;
exports.MINOR = exports.MAJOR;
exports.SPECIAL_HEADERS = {
connection: exports.HEADER_STATE.CONNECTION,
"content-length": exports.HEADER_STATE.CONTENT_LENGTH,
"proxy-connection": exports.HEADER_STATE.CONNECTION,
"transfer-encoding": exports.HEADER_STATE.TRANSFER_ENCODING,
upgrade: exports.HEADER_STATE.UPGRADE
};
});
// undici/lib/llhttp/llhttp-wasm.js
var require_llhttp_wasm = __commonJS((exports, module) => {
var { Buffer: Buffer2 } = __require("node:buffer"), wasmBuffer;
Object.defineProperty(module, "exports", {
get: () => {
return wasmBuffer ? wasmBuffer : wasmBuffer = Buffer2.from("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", "base64");
}
});
});
// undici/lib/llhttp/llhttp_simd-wasm.js
var require_llhttp_simd_wasm = __commonJS((exports, module) => {
var { Buffer: Buffer2 } = __require("node:buffer"), wasmBuffer;
Object.defineProperty(module, "exports", {
get: () => {
return wasmBuffer ? wasmBuffer : wasmBuffer = Buffer2.from("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", "base64");
}
});
});
// undici/lib/dispatcher/client-h1.js
var require_client_h1 = __commonJS((exports, module) => {
var assert = __require("node:assert"), util = require_util(), { channels } = require_diagnostics(), timers = require_timers(), {
RequestContentLengthMismatchError,
ResponseContentLengthMismatchError,
RequestAbortedError,
HeadersTimeoutError,
HeadersOverflowError,
SocketError,
InformationalError,
BodyTimeoutError,
HTTPParserError,
ResponseExceededMaxSizeError
} = require_errors(), {
kUrl,
kReset,
kClient,
kParser,
kBlocking,
kRunning,
kPending,
kSize,
kWriting,
kQueue,
kNoRef,
kKeepAliveDefaultTimeout,
kHostHeader,
kPendingIdx,
kRunningIdx,
kError,
kPipelining,
kSocket,
kKeepAliveTimeoutValue,
kMaxHeadersSize,
kKeepAliveMaxTimeout,
kKeepAliveTimeoutThreshold,
kHeadersTimeout,
kBodyTimeout,
kStrictContentLength,
kMaxRequests,
kCounter,
kMaxResponseSize,
kOnError,
kResume,
kHTTPContext,
kClosed
} = require_symbols(), constants = require_constants4(), EMPTY_BUF = Buffer.alloc(0), FastBuffer = Buffer[Symbol.species], removeAllListeners = util.removeAllListeners, extractBody;
async function lazyllhttp() {
let llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0, mod;
try {
mod = await WebAssembly.compile(require_llhttp_simd_wasm());
} catch (e) {
mod = await WebAssembly.compile(llhttpWasmData || require_llhttp_wasm());
}
return await WebAssembly.instantiate(mod, {
env: {
wasm_on_url: (p, at, len) => {
return 0;
},
wasm_on_status: (p, at, len) => {
assert(currentParser.ptr === p);
let start = at - currentBufferPtr + currentBufferRef.byteOffset;
return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len));
},
wasm_on_message_begin: (p) => {
return assert(currentParser.ptr === p), currentParser.onMessageBegin();
},
wasm_on_header_field: (p, at, len) => {
assert(currentParser.ptr === p);
let start = at - currentBufferPtr + currentBufferRef.byteOffset;
return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len));
},
wasm_on_header_value: (p, at, len) => {
assert(currentParser.ptr === p);
let start = at - currentBufferPtr + currentBufferRef.byteOffset;
return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len));
},
wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
return assert(currentParser.ptr === p), currentParser.onHeadersComplete(statusCode, upgrade === 1, shouldKeepAlive === 1);
},
wasm_on_body: (p, at, len) => {
assert(currentParser.ptr === p);
let start = at - currentBufferPtr + currentBufferRef.byteOffset;
return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len));
},
wasm_on_message_complete: (p) => {
return assert(currentParser.ptr === p), currentParser.onMessageComplete();
}
}
});
}
var llhttpInstance = null, llhttpPromise = lazyllhttp();
llhttpPromise.catch();
var currentParser = null, currentBufferRef = null, currentBufferSize = 0, currentBufferPtr = null, USE_NATIVE_TIMER = 0, USE_FAST_TIMER = 1, TIMEOUT_HEADERS = 2 | USE_FAST_TIMER, TIMEOUT_BODY = 4 | USE_FAST_TIMER, TIMEOUT_KEEP_ALIVE = 8 | USE_NATIVE_TIMER;
class Parser {
constructor(client, socket, { exports: exports2 }) {
this.llhttp = exports2, this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE), this.client = client, this.socket = socket, this.timeout = null, this.timeoutValue = null, this.timeoutType = null, this.statusCode = 0, this.statusText = "", this.upgrade = !1, this.headers = [], this.headersSize = 0, this.headersMaxSize = client[kMaxHeadersSize], this.shouldKeepAlive = !1, this.paused = !1, this.resume = this.resume.bind(this), this.bytesRead = 0, this.keepAlive = "", this.contentLength = "", this.connection = "", this.maxResponseSize = client[kMaxResponseSize];
}
setTimeout(delay, type) {
if (delay !== this.timeoutValue || type & USE_FAST_TIMER ^ this.timeoutType & USE_FAST_TIMER) {
if (this.timeout)
timers.clearTimeout(this.timeout), this.timeout = null;
if (delay)
if (type & USE_FAST_TIMER)
this.timeout = timers.setFastTimeout(onParserTimeout, delay, new WeakRef(this));
else
this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this)), this.timeout.unref();
this.timeoutValue = delay;
} else if (this.timeout) {
if (this.timeout.refresh)
this.timeout.refresh();
}
this.timeoutType = type;
}
resume() {
if (this.socket.destroyed || !this.paused)
return;
if (assert(this.ptr != null), assert(currentParser === null), this.llhttp.llhttp_resume(this.ptr), assert(this.timeoutType === TIMEOUT_BODY), this.timeout) {
if (this.timeout.refresh)
this.timeout.refresh();
}
this.paused = !1, this.execute(this.socket.read() || EMPTY_BUF), this.readMore();
}
readMore() {
while (!this.paused && this.ptr) {
let chunk = this.socket.read();
if (chunk === null)
break;
this.execute(chunk);
}
}
execute(chunk) {
assert(currentParser === null), assert(this.ptr != null), assert(!this.paused);
let { socket, llhttp } = this;
if (chunk.length > currentBufferSize) {
if (currentBufferPtr)
llhttp.free(currentBufferPtr);
currentBufferSize = Math.ceil(chunk.length / 4096) * 4096, currentBufferPtr = llhttp.malloc(currentBufferSize);
}
new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(chunk);
try {
let ret;
try {
currentBufferRef = chunk, currentParser = this, ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, chunk.length);
} catch (err) {
throw err;
} finally {
currentParser = null, currentBufferRef = null;
}
if (ret !== constants.ERROR.OK) {
let data = chunk.subarray(llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr);
if (ret === constants.ERROR.PAUSED_UPGRADE)
this.onUpgrade(data);
else if (ret === constants.ERROR.PAUSED)
this.paused = !0, socket.unshift(data);
else {
let ptr = llhttp.llhttp_get_error_reason(this.ptr), message = "";
if (ptr) {
let len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0);
message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")";
}
throw new HTTPParserError(message, constants.ERROR[ret], data);
}
}
} catch (err) {
util.destroy(socket, err);
}
}
destroy() {
assert(currentParser === null), assert(this.ptr != null), this.llhttp.llhttp_free(this.ptr), this.ptr = null, this.timeout && timers.clearTimeout(this.timeout), this.timeout = null, this.timeoutValue = null, this.timeoutType = null, this.paused = !1;
}
onStatus(buf) {
return this.statusText = buf.toString(), 0;
}
onMessageBegin() {
let { socket, client } = this;
if (socket.destroyed)
return -1;
let request = client[kQueue][client[kRunningIdx]];
if (!request)
return -1;
return request.onResponseStarted(), 0;
}
onHeaderField(buf) {
let len = this.headers.length;
if ((len & 1) === 0)
this.headers.push(buf);
else
this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
return this.trackHeader(buf.length), 0;
}
onHeaderValue(buf) {
let len = this.headers.length;
if ((len & 1) === 1)
this.headers.push(buf), len += 1;
else
this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
let key = this.headers[len - 2];
if (key.length === 10) {
let headerName = util.bufferToLowerCasedHeaderName(key);
if (headerName === "keep-alive")
this.keepAlive += buf.toString();
else if (headerName === "connection")
this.connection += buf.toString();
} else if (key.length === 14 && util.bufferToLowerCasedHeaderName(key) === "content-length")
this.contentLength += buf.toString();
return this.trackHeader(buf.length), 0;
}
trackHeader(len) {
if (this.headersSize += len, this.headersSize >= this.headersMaxSize)
util.destroy(this.socket, new HeadersOverflowError);
}
onUpgrade(head) {
let { upgrade, client, socket, headers, statusCode } = this;
assert(upgrade), assert(client[kSocket] === socket), assert(!socket.destroyed), assert(!this.paused), assert((headers.length & 1) === 0);
let request = client[kQueue][client[kRunningIdx]];
assert(request), assert(request.upgrade || request.method === "CONNECT"), this.statusCode = 0, this.statusText = "", this.shouldKeepAlive = !1, this.headers = [], this.headersSize = 0, socket.unshift(head), socket[kParser].destroy(), socket[kParser] = null, socket[kClient] = null, socket[kError] = null, removeAllListeners(socket), client[kSocket] = null, client[kHTTPContext] = null, client[kQueue][client[kRunningIdx]++] = null, client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade"));
try {
request.onUpgrade(statusCode, headers, socket);
} catch (err) {
util.destroy(socket, err);
}
client[kResume]();
}
onHeadersComplete(statusCode, upgrade, shouldKeepAlive) {
let { client, socket, headers, statusText } = this;
if (socket.destroyed)
return -1;
let request = client[kQueue][client[kRunningIdx]];
if (!request)
return -1;
if (assert(!this.upgrade), assert(this.statusCode < 200), statusCode === 100)
return util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket))), -1;
if (upgrade && !request.upgrade)
return util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket))), -1;
if (assert(this.timeoutType === TIMEOUT_HEADERS), this.statusCode = statusCode, this.shouldKeepAlive = shouldKeepAlive || request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive", this.statusCode >= 200) {
let bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout];
this.setTimeout(bodyTimeout, TIMEOUT_BODY);
} else if (this.timeout) {
if (this.timeout.refresh)
this.timeout.refresh();
}
if (request.method === "CONNECT")
return assert(client[kRunning] === 1), this.upgrade = !0, 2;
if (upgrade)
return assert(client[kRunning] === 1), this.upgrade = !0, 2;
if (assert((this.headers.length & 1) === 0), this.headers = [], this.headersSize = 0, this.shouldKeepAlive && client[kPipelining]) {
let keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null;
if (keepAliveTimeout != null) {
let timeout = Math.min(keepAliveTimeout - client[kKeepAliveTimeoutThreshold], client[kKeepAliveMaxTimeout]);
if (timeout <= 0)
socket[kReset] = !0;
else
client[kKeepAliveTimeoutValue] = timeout;
} else
client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout];
} else
socket[kReset] = !0;
let pause = request.onHeaders(statusCode, headers, this.resume, statusText) === !1;
if (request.aborted)
return -1;
if (request.method === "HEAD")
return 1;
if (statusCode < 200)
return 1;
if (socket[kBlocking])
socket[kBlocking] = !1, client[kResume]();
return pause ? constants.ERROR.PAUSED : 0;
}
onBody(buf) {
let { client, socket, statusCode, maxResponseSize } = this;
if (socket.destroyed)
return -1;
let request = client[kQueue][client[kRunningIdx]];
if (assert(request), assert(this.timeoutType === TIMEOUT_BODY), this.timeout) {
if (this.timeout.refresh)
this.timeout.refresh();
}
if (assert(statusCode >= 200), maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize)
return util.destroy(socket, new ResponseExceededMaxSizeError), -1;
if (this.bytesRead += buf.length, request.onData(buf) === !1)
return constants.ERROR.PAUSED;
return 0;
}
onMessageComplete() {
let { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this;
if (socket.destroyed && (!statusCode || shouldKeepAlive))
return -1;
if (upgrade)
return 0;
assert(statusCode >= 100), assert((this.headers.length & 1) === 0);
let request = client[kQueue][client[kRunningIdx]];
if (assert(request), this.statusCode = 0, this.statusText = "", this.bytesRead = 0, this.contentLength = "", this.keepAlive = "", this.connection = "", this.headers = [], this.headersSize = 0, statusCode < 200)
return 0;
if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10))
return util.destroy(socket, new ResponseContentLengthMismatchError), -1;
if (request.onComplete(headers), client[kQueue][client[kRunningIdx]++] = null, socket[kWriting])
return assert(client[kRunning] === 0), util.destroy(socket, new InformationalError("reset")), constants.ERROR.PAUSED;
else if (!shouldKeepAlive)
return util.destroy(socket, new InformationalError("reset")), constants.ERROR.PAUSED;
else if (socket[kReset] && client[kRunning] === 0)
return util.destroy(socket, new InformationalError("reset")), constants.ERROR.PAUSED;
else if (client[kPipelining] == null || client[kPipelining] === 1)
setImmediate(() => client[kResume]());
else
client[kResume]();
return 0;
}
}
function onParserTimeout(parser) {
let { socket, timeoutType, client, paused } = parser.deref();
if (timeoutType === TIMEOUT_HEADERS) {
if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1)
assert(!paused, "cannot be paused while waiting for headers"), util.destroy(socket, new HeadersTimeoutError);
} else if (timeoutType === TIMEOUT_BODY) {
if (!paused)
util.destroy(socket, new BodyTimeoutError);
} else if (timeoutType === TIMEOUT_KEEP_ALIVE)
assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]), util.destroy(socket, new InformationalError("socket idle timeout"));
}
async function connectH1(client, socket) {
if (client[kSocket] = socket, !llhttpInstance) {
let noop = () => {
};
socket.on("error", noop), llhttpInstance = await llhttpPromise, llhttpPromise = null, socket.off("error", noop);
}
if (socket.errored)
throw socket.errored;
if (socket.destroyed)
throw new SocketError("destroyed");
return socket[kNoRef] = !1, socket[kWriting] = !1, socket[kReset] = !1, socket[kBlocking] = !1, socket[kParser] = new Parser(client, socket, llhttpInstance), util.addListener(socket, "error", onHttpSocketError), util.addListener(socket, "readable", onHttpSocketReadable), util.addListener(socket, "end", onHttpSocketEnd), util.addListener(socket, "close", onHttpSocketClose), socket[kClosed] = !1, socket.on("close", onSocketClose), {
version: "h1",
defaultPipelining: 1,
write(request) {
return writeH1(client, request);
},
resume() {
resumeH1(client);
},
destroy(err, callback) {
if (socket[kClosed])
queueMicrotask(callback);
else
socket.on("close", callback), socket.destroy(err);
},
get destroyed() {
return socket.destroyed;
},
busy(request) {
if (socket[kWriting] || socket[kReset] || socket[kBlocking])
return !0;
if (request) {
if (client[kRunning] > 0 && !request.idempotent)
return !0;
if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT"))
return !0;
if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 && (util.isStream(request.body) || util.isAsyncIterable(request.body) || util.isFormDataLike(request.body)))
return !0;
}
return !1;
}
};
}
function onHttpSocketError(err) {
assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
let parser = this[kParser];
if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) {
parser.onMessageComplete();
return;
}
this[kError] = err, this[kClient][kOnError](err);
}
function onHttpSocketReadable() {
this[kParser]?.readMore();
}
function onHttpSocketEnd() {
let parser = this[kParser];
if (parser.statusCode && !parser.shouldKeepAlive) {
parser.onMessageComplete();
return;
}
util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
}
function onHttpSocketClose() {
let parser = this[kParser];
if (parser) {
if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive)
parser.onMessageComplete();
this[kParser].destroy(), this[kParser] = null;
}
let err = this[kError] || new SocketError("closed", util.getSocketInfo(this)), client = this[kClient];
if (client[kSocket] = null, client[kHTTPContext] = null, client.destroyed) {
assert(client[kPending] === 0);
let requests = client[kQueue].splice(client[kRunningIdx]);
for (let i = 0;i < requests.length; i++) {
let request = requests[i];
util.errorRequest(client, request, err);
}
} else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") {
let request = client[kQueue][client[kRunningIdx]];
client[kQueue][client[kRunningIdx]++] = null, util.errorRequest(client, request, err);
}
client[kPendingIdx] = client[kRunningIdx], assert(client[kRunning] === 0), client.emit("disconnect", client[kUrl], [client], err), client[kResume]();
}
function onSocketClose() {
this[kClosed] = !0;
}
function resumeH1(client) {
let socket = client[kSocket];
if (socket && !socket.destroyed) {
if (client[kSize] === 0) {
if (!socket[kNoRef] && socket.unref)
socket.unref(), socket[kNoRef] = !0;
} else if (socket[kNoRef] && socket.ref)
socket.ref(), socket[kNoRef] = !1;
if (client[kSize] === 0) {
if (socket[kParser].timeoutType !== TIMEOUT_KEEP_ALIVE)
socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_KEEP_ALIVE);
} else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
let request = client[kQueue][client[kRunningIdx]], headersTimeout = request.headersTimeout != null ? request.headersTimeout : client[kHeadersTimeout];
socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS);
}
}
}
}
function shouldSendContentLength(method) {
return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
}
function writeH1(client, request) {
let { method, path, host, upgrade, blocking, reset } = request, { body, headers, contentLength } = request, expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
if (util.isFormDataLike(body)) {
if (!extractBody)
extractBody = require_body().extractBody;
let [bodyStream, contentType] = extractBody(body);
if (request.contentType == null)
headers.push("content-type", contentType);
body = bodyStream.stream, contentLength = bodyStream.length;
} else if (util.isBlobLike(body) && request.contentType == null && body.type)
headers.push("content-type", body.type);
if (body && typeof body.read === "function")
body.read(0);
let bodyLength = util.bodyLength(body);
if (contentLength = bodyLength ?? contentLength, contentLength === null)
contentLength = request.contentLength;
if (contentLength === 0 && !expectsPayload)
contentLength = null;
if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) {
if (client[kStrictContentLength])
return util.errorRequest(client, request, new RequestContentLengthMismatchError), !1;
process.emitWarning(new RequestContentLengthMismatchError);
}
let socket = client[kSocket], abort = (err) => {
if (request.aborted || request.completed)
return;
util.errorRequest(client, request, err || new RequestAbortedError), util.destroy(body), util.destroy(socket, new InformationalError("aborted"));
};
try {
request.onConnect(abort);
} catch (err) {
util.errorRequest(client, request, err);
}
if (request.aborted)
return !1;
if (method === "HEAD")
socket[kReset] = !0;
if (upgrade || method === "CONNECT")
socket[kReset] = !0;
if (reset != null)
socket[kReset] = reset;
if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests])
socket[kReset] = !0;
if (blocking)
socket[kBlocking] = !0;
let header = `${method} ${path} HTTP/1.1\r
`;
if (typeof host === "string")
header += `host: ${host}\r
`;
else
header += client[kHostHeader];
if (upgrade)
header += `connection: upgrade\r
upgrade: ${upgrade}\r
`;
else if (client[kPipelining] && !socket[kReset])
header += `connection: keep-alive\r
`;
else
header += `connection: close\r
`;
if (Array.isArray(headers))
for (let n = 0;n < headers.length; n += 2) {
let key = headers[n + 0], val = headers[n + 1];
if (Array.isArray(val))
for (let i = 0;i < val.length; i++)
header += `${key}: ${val[i]}\r
`;
else
header += `${key}: ${val}\r
`;
}
if (channels.sendHeaders.hasSubscribers)
channels.sendHeaders.publish({ request, headers: header, socket });
if (!body || bodyLength === 0)
writeBuffer(abort, null, client, request, socket, contentLength, header, expectsPayload);
else if (util.isBuffer(body))
writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload);
else if (util.isBlobLike(body))
if (typeof body.stream === "function")
writeIterable(abort, body.stream(), client, request, socket, contentLength, header, expectsPayload);
else
writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload);
else if (util.isStream(body))
writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload);
else if (util.isIterable(body))
writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload);
else
assert(!1);
return !0;
}
function writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload) {
assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
let finished = !1, writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header }), onData = function(chunk) {
if (finished)
return;
try {
if (!writer.write(chunk) && this.pause)
this.pause();
} catch (err) {
util.destroy(this, err);
}
}, onDrain = function() {
if (finished)
return;
if (body.resume)
body.resume();
}, onClose = function() {
if (queueMicrotask(() => {
body.removeListener("error", onFinished);
}), !finished) {
let err = new RequestAbortedError;
queueMicrotask(() => onFinished(err));
}
}, onFinished = function(err) {
if (finished)
return;
if (finished = !0, assert(socket.destroyed || socket[kWriting] && client[kRunning] <= 1), socket.off("drain", onDrain).off("error", onFinished), body.removeListener("data", onData).removeListener("end", onFinished).removeListener("close", onClose), !err)
try {
writer.end();
} catch (er) {
err = er;
}
if (writer.destroy(err), err && (err.code !== "UND_ERR_INFO" || err.message !== "reset"))
util.destroy(body, err);
else
util.destroy(body);
};
if (body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onClose), body.resume)
body.resume();
if (socket.on("drain", onDrain).on("error", onFinished), body.errorEmitted ?? body.errored)
setImmediate(() => onFinished(body.errored));
else if (body.endEmitted ?? body.readableEnded)
setImmediate(() => onFinished(null));
if (body.closeEmitted ?? body.closed)
setImmediate(onClose);
}
function writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload) {
try {
if (!body)
if (contentLength === 0)
socket.write(`${header}content-length: 0\r
\r
`, "latin1");
else
assert(contentLength === null, "no body must not have content length"), socket.write(`${header}\r
`, "latin1");
else if (util.isBuffer(body)) {
if (assert(contentLength === body.byteLength, "buffer body must have content length"), socket.cork(), socket.write(`${header}content-length: ${contentLength}\r
\r
`, "latin1"), socket.write(body), socket.uncork(), request.onBodySent(body), !expectsPayload && request.reset !== !1)
socket[kReset] = !0;
}
request.onRequestSent(), client[kResume]();
} catch (err) {
abort(err);
}
}
async function writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload) {
assert(contentLength === body.size, "blob body must have content length");
try {
if (contentLength != null && contentLength !== body.size)
throw new RequestContentLengthMismatchError;
let buffer = Buffer.from(await body.arrayBuffer());
if (socket.cork(), socket.write(`${header}content-length: ${contentLength}\r
\r
`, "latin1"), socket.write(buffer), socket.uncork(), request.onBodySent(buffer), request.onRequestSent(), !expectsPayload && request.reset !== !1)
socket[kReset] = !0;
client[kResume]();
} catch (err) {
abort(err);
}
}
async function writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload) {
assert(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
let callback = null;
function onDrain() {
if (callback) {
let cb = callback;
callback = null, cb();
}
}
let waitForDrain = () => new Promise((resolve, reject) => {
if (assert(callback === null), socket[kError])
reject(socket[kError]);
else
callback = resolve;
});
socket.on("close", onDrain).on("drain", onDrain);
let writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header });
try {
for await (let chunk of body) {
if (socket[kError])
throw socket[kError];
if (!writer.write(chunk))
await waitForDrain();
}
writer.end();
} catch (err) {
writer.destroy(err);
} finally {
socket.off("close", onDrain).off("drain", onDrain);
}
}
class AsyncWriter {
constructor({ abort, socket, request, contentLength, client, expectsPayload, header }) {
this.socket = socket, this.request = request, this.contentLength = contentLength, this.client = client, this.bytesWritten = 0, this.expectsPayload = expectsPayload, this.header = header, this.abort = abort, socket[kWriting] = !0;
}
write(chunk) {
let { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this;
if (socket[kError])
throw socket[kError];
if (socket.destroyed)
return !1;
let len = Buffer.byteLength(chunk);
if (!len)
return !0;
if (contentLength !== null && bytesWritten + len > contentLength) {
if (client[kStrictContentLength])
throw new RequestContentLengthMismatchError;
process.emitWarning(new RequestContentLengthMismatchError);
}
if (socket.cork(), bytesWritten === 0) {
if (!expectsPayload && request.reset !== !1)
socket[kReset] = !0;
if (contentLength === null)
socket.write(`${header}transfer-encoding: chunked\r
`, "latin1");
else
socket.write(`${header}content-length: ${contentLength}\r
\r
`, "latin1");
}
if (contentLength === null)
socket.write(`\r
${len.toString(16)}\r
`, "latin1");
this.bytesWritten += len;
let ret = socket.write(chunk);
if (socket.uncork(), request.onBodySent(chunk), !ret) {
if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
if (socket[kParser].timeout.refresh)
socket[kParser].timeout.refresh();
}
}
return ret;
}
end() {
let { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this;
if (request.onRequestSent(), socket[kWriting] = !1, socket[kError])
throw socket[kError];
if (socket.destroyed)
return;
if (bytesWritten === 0)
if (expectsPayload)
socket.write(`${header}content-length: 0\r
\r
`, "latin1");
else
socket.write(`${header}\r
`, "latin1");
else if (contentLength === null)
socket.write(`\r
0\r
\r
`, "latin1");
if (contentLength !== null && bytesWritten !== contentLength)
if (client[kStrictContentLength])
throw new RequestContentLengthMismatchError;
else
process.emitWarning(new RequestContentLengthMismatchError);
if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
if (socket[kParser].timeout.refresh)
socket[kParser].timeout.refresh();
}
client[kResume]();
}
destroy(err) {
let { socket, client, abort } = this;
if (socket[kWriting] = !1, err)
assert(client[kRunning] <= 1, "pipeline should only contain this request"), abort(err);
}
}
module.exports = connectH1;
});
// undici/lib/dispatcher/client-h2.js
var require_client_h2 = __commonJS((exports, module) => {
var assert = __require("node:assert"), { pipeline } = __require("node:stream"), util = require_util(), {
RequestContentLengthMismatchError,
RequestAbortedError,
SocketError,
InformationalError
} = require_errors(), {
kUrl,
kReset,
kClient,
kRunning,
kPending,
kQueue,
kPendingIdx,
kRunningIdx,
kError,
kSocket,
kStrictContentLength,
kOnError,
kMaxConcurrentStreams,
kHTTP2Session,
kResume,
kSize,
kHTTPContext,
kClosed,
kBodyTimeout
} = require_symbols(), { channels } = require_diagnostics(), kOpenStreams = Symbol("open streams"), extractBody, http2;
try {
http2 = __require("node:http2");
} catch {
http2 = { constants: {} };
}
var {
constants: {
HTTP2_HEADER_AUTHORITY,
HTTP2_HEADER_METHOD,
HTTP2_HEADER_PATH,
HTTP2_HEADER_SCHEME,
HTTP2_HEADER_CONTENT_LENGTH,
HTTP2_HEADER_EXPECT,
HTTP2_HEADER_STATUS
}
} = http2;
function parseH2Headers(headers) {
let result = [];
for (let [name, value] of Object.entries(headers))
if (Array.isArray(value))
for (let subvalue of value)
result.push(Buffer.from(name), Buffer.from(subvalue));
else
result.push(Buffer.from(name), Buffer.from(value));
return result;
}
async function connectH2(client, socket) {
client[kSocket] = socket;
let session = http2.connect(client[kUrl], {
createConnection: () => socket,
peerMaxConcurrentStreams: client[kMaxConcurrentStreams],
settings: {
enablePush: !1
}
});
return session[kOpenStreams] = 0, session[kClient] = client, session[kSocket] = socket, session[kHTTP2Session] = null, util.addListener(session, "error", onHttp2SessionError), util.addListener(session, "frameError", onHttp2FrameError), util.addListener(session, "end", onHttp2SessionEnd), util.addListener(session, "goaway", onHttp2SessionGoAway), util.addListener(session, "close", onHttp2SessionClose), session.unref(), client[kHTTP2Session] = session, socket[kHTTP2Session] = session, util.addListener(socket, "error", onHttp2SocketError), util.addListener(socket, "end", onHttp2SocketEnd), util.addListener(socket, "close", onHttp2SocketClose), socket[kClosed] = !1, socket.on("close", onSocketClose), {
version: "h2",
defaultPipelining: 1 / 0,
write(request) {
return writeH2(client, request);
},
resume() {
resumeH2(client);
},
destroy(err, callback) {
if (socket[kClosed])
queueMicrotask(callback);
else
socket.destroy(err).on("close", callback);
},
get destroyed() {
return socket.destroyed;
},
busy() {
return !1;
}
};
}
function resumeH2(client) {
let socket = client[kSocket];
if (socket?.destroyed === !1)
if (client[kSize] === 0 || client[kMaxConcurrentStreams] === 0)
socket.unref(), client[kHTTP2Session].unref();
else
socket.ref(), client[kHTTP2Session].ref();
}
function onHttp2SessionError(err) {
assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"), this[kSocket][kError] = err, this[kClient][kOnError](err);
}
function onHttp2FrameError(type, code, id) {
if (id === 0) {
let err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
this[kSocket][kError] = err, this[kClient][kOnError](err);
}
}
function onHttp2SessionEnd() {
let err = new SocketError("other side closed", util.getSocketInfo(this[kSocket]));
this.destroy(err), util.destroy(this[kSocket], err);
}
function onHttp2SessionGoAway(errorCode) {
let err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${errorCode}`, util.getSocketInfo(this[kSocket])), client = this[kClient];
if (client[kSocket] = null, client[kHTTPContext] = null, this.close(), this[kHTTP2Session] = null, util.destroy(this[kSocket], err), client[kRunningIdx] < client[kQueue].length) {
let request = client[kQueue][client[kRunningIdx]];
client[kQueue][client[kRunningIdx]++] = null, util.errorRequest(client, request, err), client[kPendingIdx] = client[kRunningIdx];
}
assert(client[kRunning] === 0), client.emit("disconnect", client[kUrl], [client], err), client[kResume]();
}
function onHttp2SessionClose() {
let { [kClient]: client } = this, { [kSocket]: socket } = client, err = this[kSocket][kError] || this[kError] || new SocketError("closed", util.getSocketInfo(socket));
if (client[kSocket] = null, client[kHTTPContext] = null, client.destroyed) {
assert(client[kPending] === 0);
let requests = client[kQueue].splice(client[kRunningIdx]);
for (let i = 0;i < requests.length; i++) {
let request = requests[i];
util.errorRequest(client, request, err);
}
}
}
function onHttp2SocketClose() {
let err = this[kError] || new SocketError("closed", util.getSocketInfo(this)), client = this[kHTTP2Session][kClient];
if (client[kSocket] = null, client[kHTTPContext] = null, this[kHTTP2Session] !== null)
this[kHTTP2Session].destroy(err);
client[kPendingIdx] = client[kRunningIdx], assert(client[kRunning] === 0), client.emit("disconnect", client[kUrl], [client], err), client[kResume]();
}
function onHttp2SocketError(err) {
assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"), this[kError] = err, this[kClient][kOnError](err);
}
function onHttp2SocketEnd() {
util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
}
function onSocketClose() {
this[kClosed] = !0;
}
function shouldSendContentLength(method) {
return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
}
function writeH2(client, request) {
let requestTimeout = request.bodyTimeout ?? client[kBodyTimeout], session = client[kHTTP2Session], { method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request, { body } = request;
if (upgrade)
return util.errorRequest(client, request, new Error("Upgrade not supported for H2")), !1;
let headers = {};
for (let n = 0;n < reqHeaders.length; n += 2) {
let key = reqHeaders[n + 0], val = reqHeaders[n + 1];
if (Array.isArray(val))
for (let i = 0;i < val.length; i++)
if (headers[key])
headers[key] += `,${val[i]}`;
else
headers[key] = val[i];
else
headers[key] = val;
}
let stream = null, { hostname, port } = client[kUrl];
headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ""}`, headers[HTTP2_HEADER_METHOD] = method;
let abort = (err) => {
if (request.aborted || request.completed)
return;
if (err = err || new RequestAbortedError, util.errorRequest(client, request, err), stream != null)
stream.removeAllListeners("data"), stream.close(), client[kOnError](err), client[kResume]();
util.destroy(body, err);
};
try {
request.onConnect(abort);
} catch (err) {
util.errorRequest(client, request, err);
}
if (request.aborted)
return !1;
if (method === "CONNECT") {
if (session.ref(), stream = session.request(headers, { endStream: !1, signal }), !stream.pending)
request.onUpgrade(null, null, stream), ++session[kOpenStreams], client[kQueue][client[kRunningIdx]++] = null;
else
stream.once("ready", () => {
request.onUpgrade(null, null, stream), ++session[kOpenStreams], client[kQueue][client[kRunningIdx]++] = null;
});
return stream.once("close", () => {
if (session[kOpenStreams] -= 1, session[kOpenStreams] === 0)
session.unref();
}), stream.setTimeout(requestTimeout), !0;
}
headers[HTTP2_HEADER_PATH] = path, headers[HTTP2_HEADER_SCHEME] = "https";
let expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
if (body && typeof body.read === "function")
body.read(0);
let contentLength = util.bodyLength(body);
if (util.isFormDataLike(body)) {
extractBody ??= require_body().extractBody;
let [bodyStream, contentType] = extractBody(body);
headers["content-type"] = contentType, body = bodyStream.stream, contentLength = bodyStream.length;
}
if (contentLength == null)
contentLength = request.contentLength;
if (contentLength === 0 || !expectsPayload)
contentLength = null;
if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) {
if (client[kStrictContentLength])
return util.errorRequest(client, request, new RequestContentLengthMismatchError), !1;
process.emitWarning(new RequestContentLengthMismatchError);
}
if (contentLength != null)
assert(body, "no body must not have content length"), headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`;
if (session.ref(), channels.sendHeaders.hasSubscribers) {
let header = "";
for (let key in headers)
header += `${key}: ${headers[key]}\r
`;
channels.sendHeaders.publish({ request, headers: header, socket: session[kSocket] });
}
let shouldEndStream = method === "GET" || method === "HEAD" || body === null;
if (expectContinue)
headers[HTTP2_HEADER_EXPECT] = "100-continue", stream = session.request(headers, { endStream: shouldEndStream, signal }), stream.once("continue", writeBodyH2);
else
stream = session.request(headers, {
endStream: shouldEndStream,
signal
}), writeBodyH2();
return ++session[kOpenStreams], stream.setTimeout(requestTimeout), stream.once("response", (headers2) => {
let { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
if (request.onResponseStarted(), request.aborted) {
stream.removeAllListeners("data");
return;
}
if (request.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), "") === !1)
stream.pause();
}), stream.on("data", (chunk) => {
if (request.onData(chunk) === !1)
stream.pause();
}), stream.once("end", (err) => {
if (stream.removeAllListeners("data"), stream.state?.state == null || stream.state.state < 6) {
if (!request.aborted && !request.completed)
request.onComplete({});
client[kQueue][client[kRunningIdx]++] = null, client[kResume]();
} else {
if (--session[kOpenStreams], session[kOpenStreams] === 0)
session.unref();
abort(err ?? new InformationalError("HTTP/2: stream half-closed (remote)")), client[kQueue][client[kRunningIdx]++] = null, client[kPendingIdx] = client[kRunningIdx], client[kResume]();
}
}), stream.once("close", () => {
if (stream.removeAllListeners("data"), session[kOpenStreams] -= 1, session[kOpenStreams] === 0)
session.unref();
}), stream.once("error", function(err) {
stream.removeAllListeners("data"), abort(err);
}), stream.once("frameError", (type, code) => {
stream.removeAllListeners("data"), abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`));
}), stream.on("aborted", () => {
stream.removeAllListeners("data");
}), stream.on("timeout", () => {
let err = new InformationalError(`HTTP/2: "stream timeout after ${requestTimeout}"`);
if (stream.removeAllListeners("data"), session[kOpenStreams] -= 1, session[kOpenStreams] === 0)
session.unref();
abort(err);
}), stream.once("trailers", (trailers) => {
if (request.aborted || request.completed)
return;
request.onComplete(trailers);
}), !0;
function writeBodyH2() {
if (!body || contentLength === 0)
writeBuffer(abort, stream, null, client, request, client[kSocket], contentLength, expectsPayload);
else if (util.isBuffer(body))
writeBuffer(abort, stream, body, client, request, client[kSocket], contentLength, expectsPayload);
else if (util.isBlobLike(body))
if (typeof body.stream === "function")
writeIterable(abort, stream, body.stream(), client, request, client[kSocket], contentLength, expectsPayload);
else
writeBlob(abort, stream, body, client, request, client[kSocket], contentLength, expectsPayload);
else if (util.isStream(body))
writeStream(abort, client[kSocket], expectsPayload, stream, body, client, request, contentLength);
else if (util.isIterable(body))
writeIterable(abort, stream, body, client, request, client[kSocket], contentLength, expectsPayload);
else
assert(!1);
}
}
function writeBuffer(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
try {
if (body != null && util.isBuffer(body))
assert(contentLength === body.byteLength, "buffer body must have content length"), h2stream.cork(), h2stream.write(body), h2stream.uncork(), h2stream.end(), request.onBodySent(body);
if (!expectsPayload)
socket[kReset] = !0;
request.onRequestSent(), client[kResume]();
} catch (error) {
abort(error);
}
}
function writeStream(abort, socket, expectsPayload, h2stream, body, client, request, contentLength) {
assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
let pipe = pipeline(body, h2stream, (err) => {
if (err)
util.destroy(pipe, err), abort(err);
else {
if (util.removeAllListeners(pipe), request.onRequestSent(), !expectsPayload)
socket[kReset] = !0;
client[kResume]();
}
});
util.addListener(pipe, "data", onPipeData);
function onPipeData(chunk) {
request.onBodySent(chunk);
}
}
async function writeBlob(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
assert(contentLength === body.size, "blob body must have content length");
try {
if (contentLength != null && contentLength !== body.size)
throw new RequestContentLengthMismatchError;
let buffer = Buffer.from(await body.arrayBuffer());
if (h2stream.cork(), h2stream.write(buffer), h2stream.uncork(), h2stream.end(), request.onBodySent(buffer), request.onRequestSent(), !expectsPayload)
socket[kReset] = !0;
client[kResume]();
} catch (err) {
abort(err);
}
}
async function writeIterable(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
assert(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
let callback = null;
function onDrain() {
if (callback) {
let cb = callback;
callback = null, cb();
}
}
let waitForDrain = () => new Promise((resolve, reject) => {
if (assert(callback === null), socket[kError])
reject(socket[kError]);
else
callback = resolve;
});
h2stream.on("close", onDrain).on("drain", onDrain);
try {
for await (let chunk of body) {
if (socket[kError])
throw socket[kError];
let res = h2stream.write(chunk);
if (request.onBodySent(chunk), !res)
await waitForDrain();
}
if (h2stream.end(), request.onRequestSent(), !expectsPayload)
socket[kReset] = !0;
client[kResume]();
} catch (err) {
abort(err);
} finally {
h2stream.off("close", onDrain).off("drain", onDrain);
}
}
module.exports = connectH2;
});
// undici/lib/dispatcher/client.js
var require_client = __commonJS((exports, module) => {
var assert = __require("node:assert"), net = __require("node:net"), http = __require("node:http"), util = require_util(), { channels } = require_diagnostics(), Request = require_request2(), DispatcherBase = require_dispatcher_base(), {
InvalidArgumentError,
InformationalError,
ClientDestroyedError
} = require_errors(), buildConnector = require_connect(), {
kUrl,
kServerName,
kClient,
kBusy,
kConnect,
kResuming,
kRunning,
kPending,
kSize,
kQueue,
kConnected,
kConnecting,
kNeedDrain,
kKeepAliveDefaultTimeout,
kHostHeader,
kPendingIdx,
kRunningIdx,
kError,
kPipelining,
kKeepAliveTimeoutValue,
kMaxHeadersSize,
kKeepAliveMaxTimeout,
kKeepAliveTimeoutThreshold,
kHeadersTimeout,
kBodyTimeout,
kStrictContentLength,
kConnector,
kMaxRequests,
kCounter,
kClose,
kDestroy,
kDispatch,
kLocalAddress,
kMaxResponseSize,
kOnError,
kHTTPContext,
kMaxConcurrentStreams,
kResume
} = require_symbols(), connectH1 = require_client_h1(), connectH2 = require_client_h2(), kClosedResolve = Symbol("kClosedResolve"), getDefaultNodeMaxHeaderSize = http && http.maxHeaderSize && Number.isInteger(http.maxHeaderSize) && http.maxHeaderSize > 0 ? () => http.maxHeaderSize : () => {
throw new InvalidArgumentError("http module not available or http.maxHeaderSize invalid");
}, noop = () => {
};
function getPipelining(client) {
return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1;
}
class Client extends DispatcherBase {
constructor(url, {
maxHeaderSize,
headersTimeout,
socketTimeout,
requestTimeout,
connectTimeout,
bodyTimeout,
idleTimeout,
keepAlive,
keepAliveTimeout,
maxKeepAliveTimeout,
keepAliveMaxTimeout,
keepAliveTimeoutThreshold,
socketPath,
pipelining,
tls,
strictContentLength,
maxCachedSessions,
connect: connect2,
maxRequestsPerClient,
localAddress,
maxResponseSize,
autoSelectFamily,
autoSelectFamilyAttemptTimeout,
maxConcurrentStreams,
allowH2
} = {}) {
if (keepAlive !== void 0)
throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead");
if (socketTimeout !== void 0)
throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead");
if (requestTimeout !== void 0)
throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead");
if (idleTimeout !== void 0)
throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead");
if (maxKeepAliveTimeout !== void 0)
throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead");
if (maxHeaderSize != null) {
if (!Number.isInteger(maxHeaderSize) || maxHeaderSize < 1)
throw new InvalidArgumentError("invalid maxHeaderSize");
} else
maxHeaderSize = getDefaultNodeMaxHeaderSize();
if (socketPath != null && typeof socketPath !== "string")
throw new InvalidArgumentError("invalid socketPath");
if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0))
throw new InvalidArgumentError("invalid connectTimeout");
if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0))
throw new InvalidArgumentError("invalid keepAliveTimeout");
if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0))
throw new InvalidArgumentError("invalid keepAliveMaxTimeout");
if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold))
throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold");
if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0))
throw new InvalidArgumentError("headersTimeout must be a positive integer or zero");
if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0))
throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero");
if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object")
throw new InvalidArgumentError("connect must be a function or an object");
if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0))
throw new InvalidArgumentError("maxRequestsPerClient must be a positive number");
if (localAddress != null && (typeof localAddress !== "string" || net.isIP(localAddress) === 0))
throw new InvalidArgumentError("localAddress must be valid string IP address");
if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1))
throw new InvalidArgumentError("maxResponseSize must be a positive number");
if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1))
throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number");
if (allowH2 != null && typeof allowH2 !== "boolean")
throw new InvalidArgumentError("allowH2 must be a valid boolean value");
if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1))
throw new InvalidArgumentError("maxConcurrentStreams must be a positive integer, greater than 0");
super();
if (typeof connect2 !== "function")
connect2 = buildConnector({
...tls,
maxCachedSessions,
allowH2,
socketPath,
timeout: connectTimeout,
...autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
...connect2
});
this[kUrl] = util.parseOrigin(url), this[kConnector] = connect2, this[kPipelining] = pipelining != null ? pipelining : 1, this[kMaxHeadersSize] = maxHeaderSize, this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4000 : keepAliveTimeout, this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 600000 : keepAliveMaxTimeout, this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 2000 : keepAliveTimeoutThreshold, this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout], this[kServerName] = null, this[kLocalAddress] = localAddress != null ? localAddress : null, this[kResuming] = 0, this[kNeedDrain] = 0, this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r
`, this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 300000, this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 300000, this[kStrictContentLength] = strictContentLength == null ? !0 : strictContentLength, this[kMaxRequests] = maxRequestsPerClient, this[kClosedResolve] = null, this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1, this[kMaxConcurrentStreams] = maxConcurrentStreams != null ? maxConcurrentStreams : 100, this[kHTTPContext] = null, this[kQueue] = [], this[kRunningIdx] = 0, this[kPendingIdx] = 0, this[kResume] = (sync) => resume(this, sync), this[kOnError] = (err) => onError(this, err);
}
get pipelining() {
return this[kPipelining];
}
set pipelining(value) {
this[kPipelining] = value, this[kResume](!0);
}
get [kPending]() {
return this[kQueue].length - this[kPendingIdx];
}
get [kRunning]() {
return this[kPendingIdx] - this[kRunningIdx];
}
get [kSize]() {
return this[kQueue].length - this[kRunningIdx];
}
get [kConnected]() {
return !!this[kHTTPContext] && !this[kConnecting] && !this[kHTTPContext].destroyed;
}
get [kBusy]() {
return Boolean(this[kHTTPContext]?.busy(null) || this[kSize] >= (getPipelining(this) || 1) || this[kPending] > 0);
}
[kConnect](cb) {
connect(this), this.once("connect", cb);
}
[kDispatch](opts, handler) {
let origin = opts.origin || this[kUrl].origin, request = new Request(origin, opts, handler);
if (this[kQueue].push(request), this[kResuming])
;
else if (util.bodyLength(request.body) == null && util.isIterable(request.body))
this[kResuming] = 1, queueMicrotask(() => resume(this));
else
this[kResume](!0);
if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy])
this[kNeedDrain] = 2;
return this[kNeedDrain] < 2;
}
async[kClose]() {
return new Promise((resolve) => {
if (this[kSize])
this[kClosedResolve] = resolve;
else
resolve(null);
});
}
async[kDestroy](err) {
return new Promise((resolve) => {
let requests = this[kQueue].splice(this[kPendingIdx]);
for (let i = 0;i < requests.length; i++) {
let request = requests[i];
util.errorRequest(this, request, err);
}
let callback = () => {
if (this[kClosedResolve])
this[kClosedResolve](), this[kClosedResolve] = null;
resolve(null);
};
if (this[kHTTPContext])
this[kHTTPContext].destroy(err, callback), this[kHTTPContext] = null;
else
queueMicrotask(callback);
this[kResume]();
});
}
}
function onError(client, err) {
if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") {
assert(client[kPendingIdx] === client[kRunningIdx]);
let requests = client[kQueue].splice(client[kRunningIdx]);
for (let i = 0;i < requests.length; i++) {
let request = requests[i];
util.errorRequest(client, request, err);
}
assert(client[kSize] === 0);
}
}
async function connect(client) {
assert(!client[kConnecting]), assert(!client[kHTTPContext]);
let { host, hostname, protocol, port } = client[kUrl];
if (hostname[0] === "[") {
let idx = hostname.indexOf("]");
assert(idx !== -1);
let ip = hostname.substring(1, idx);
assert(net.isIPv6(ip)), hostname = ip;
}
if (client[kConnecting] = !0, channels.beforeConnect.hasSubscribers)
channels.beforeConnect.publish({
connectParams: {
host,
hostname,
protocol,
port,
version: client[kHTTPContext]?.version,
servername: client[kServerName],
localAddress: client[kLocalAddress]
},
connector: client[kConnector]
});
try {
let socket = await new Promise((resolve, reject) => {
client[kConnector]({
host,
hostname,
protocol,
port,
servername: client[kServerName],
localAddress: client[kLocalAddress]
}, (err, socket2) => {
if (err)
reject(err);
else
resolve(socket2);
});
});
if (client.destroyed) {
util.destroy(socket.on("error", noop), new ClientDestroyedError);
return;
}
assert(socket);
try {
client[kHTTPContext] = socket.alpnProtocol === "h2" ? await connectH2(client, socket) : await connectH1(client, socket);
} catch (err) {
throw socket.destroy().on("error", noop), err;
}
if (client[kConnecting] = !1, socket[kCounter] = 0, socket[kMaxRequests] = client[kMaxRequests], socket[kClient] = client, socket[kError] = null, channels.connected.hasSubscribers)
channels.connected.publish({
connectParams: {
host,
hostname,
protocol,
port,
version: client[kHTTPContext]?.version,
servername: client[kServerName],
localAddress: client[kLocalAddress]
},
connector: client[kConnector],
socket
});
client.emit("connect", client[kUrl], [client]);
} catch (err) {
if (client.destroyed)
return;
if (client[kConnecting] = !1, channels.connectError.hasSubscribers)
channels.connectError.publish({
connectParams: {
host,
hostname,
protocol,
port,
version: client[kHTTPContext]?.version,
servername: client[kServerName],
localAddress: client[kLocalAddress]
},
connector: client[kConnector],
error: err
});
if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
assert(client[kRunning] === 0);
while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
let request = client[kQueue][client[kPendingIdx]++];
util.errorRequest(client, request, err);
}
} else
onError(client, err);
client.emit("connectionError", client[kUrl], [client], err);
}
client[kResume]();
}
function emitDrain(client) {
client[kNeedDrain] = 0, client.emit("drain", client[kUrl], [client]);
}
function resume(client, sync) {
if (client[kResuming] === 2)
return;
if (client[kResuming] = 2, _resume(client, sync), client[kResuming] = 0, client[kRunningIdx] > 256)
client[kQueue].splice(0, client[kRunningIdx]), client[kPendingIdx] -= client[kRunningIdx], client[kRunningIdx] = 0;
}
function _resume(client, sync) {
while (!0) {
if (client.destroyed) {
assert(client[kPending] === 0);
return;
}
if (client[kClosedResolve] && !client[kSize]) {
client[kClosedResolve](), client[kClosedResolve] = null;
return;
}
if (client[kHTTPContext])
client[kHTTPContext].resume();
if (client[kBusy])
client[kNeedDrain] = 2;
else if (client[kNeedDrain] === 2) {
if (sync)
client[kNeedDrain] = 1, queueMicrotask(() => emitDrain(client));
else
emitDrain(client);
continue;
}
if (client[kPending] === 0)
return;
if (client[kRunning] >= (getPipelining(client) || 1))
return;
let request = client[kQueue][client[kPendingIdx]];
if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) {
if (client[kRunning] > 0)
return;
client[kServerName] = request.servername, client[kHTTPContext]?.destroy(new InformationalError("servername changed"), () => {
client[kHTTPContext] = null, resume(client);
});
}
if (client[kConnecting])
return;
if (!client[kHTTPContext]) {
connect(client);
return;
}
if (client[kHTTPContext].destroyed)
return;
if (client[kHTTPContext].busy(request))
return;
if (!request.aborted && client[kHTTPContext].write(request))
client[kPendingIdx]++;
else
client[kQueue].splice(client[kPendingIdx], 1);
}
}
module.exports = Client;
});
// undici/lib/dispatcher/pool.js
var require_pool = __commonJS((exports, module) => {
var {
PoolBase,
kClients,
kNeedDrain,
kAddClient,
kGetDispatcher
} = require_pool_base(), Client = require_client(), {
InvalidArgumentError
} = require_errors(), util = require_util(), { kUrl } = require_symbols(), buildConnector = require_connect(), kOptions = Symbol("options"), kConnections = Symbol("connections"), kFactory = Symbol("factory");
function defaultFactory(origin, opts) {
return new Client(origin, opts);
}
class Pool extends PoolBase {
constructor(origin, {
connections,
factory = defaultFactory,
connect,
connectTimeout,
tls,
maxCachedSessions,
socketPath,
autoSelectFamily,
autoSelectFamilyAttemptTimeout,
allowH2,
...options
} = {}) {
if (connections != null && (!Number.isFinite(connections) || connections < 0))
throw new InvalidArgumentError("invalid connections");
if (typeof factory !== "function")
throw new InvalidArgumentError("factory must be a function.");
if (connect != null && typeof connect !== "function" && typeof connect !== "object")
throw new InvalidArgumentError("connect must be a function or an object");
super();
if (typeof connect !== "function")
connect = buildConnector({
...tls,
maxCachedSessions,
allowH2,
socketPath,
timeout: connectTimeout,
...autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
...connect
});
this[kConnections] = connections || null, this[kUrl] = util.parseOrigin(origin), this[kOptions] = { ...util.deepClone(options), connect, allowH2 }, this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0, this[kFactory] = factory;
}
[kGetDispatcher]() {
for (let client of this[kClients])
if (!client[kNeedDrain])
return client;
if (!this[kConnections] || this[kClients].length < this[kConnections]) {
let dispatcher = this[kFactory](this[kUrl], this[kOptions]);
return this[kAddClient](dispatcher), dispatcher;
}
}
}
module.exports = Pool;
});
// undici/lib/dispatcher/agent.js
var require_agent = __commonJS((exports, module) => {
var { InvalidArgumentError } = require_errors(), { kClients, kRunning, kClose, kDestroy, kDispatch } = require_symbols(), DispatcherBase = require_dispatcher_base(), Pool = require_pool(), Client = require_client(), util = require_util(), kOnConnect = Symbol("onConnect"), kOnDisconnect = Symbol("onDisconnect"), kOnConnectionError = Symbol("onConnectionError"), kOnDrain = Symbol("onDrain"), kFactory = Symbol("factory"), kOptions = Symbol("options");
function defaultFactory(origin, opts) {
return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
}
class Agent extends DispatcherBase {
constructor({ factory = defaultFactory, connect, ...options } = {}) {
if (typeof factory !== "function")
throw new InvalidArgumentError("factory must be a function.");
if (connect != null && typeof connect !== "function" && typeof connect !== "object")
throw new InvalidArgumentError("connect must be a function or an object");
super();
if (connect && typeof connect !== "function")
connect = { ...connect };
this[kOptions] = { ...util.deepClone(options), connect }, this[kFactory] = factory, this[kClients] = /* @__PURE__ */ new Map, this[kOnDrain] = (origin, targets) => {
this.emit("drain", origin, [this, ...targets]);
}, this[kOnConnect] = (origin, targets) => {
this.emit("connect", origin, [this, ...targets]);
}, this[kOnDisconnect] = (origin, targets, err) => {
this.emit("disconnect", origin, [this, ...targets], err);
}, this[kOnConnectionError] = (origin, targets, err) => {
this.emit("connectionError", origin, [this, ...targets], err);
};
}
get [kRunning]() {
let ret = 0;
for (let client of this[kClients].values())
ret += client[kRunning];
return ret;
}
[kDispatch](opts, handler) {
let key;
if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL))
key = String(opts.origin);
else
throw new InvalidArgumentError("opts.origin must be a non-empty string or URL.");
let dispatcher = this[kClients].get(key);
if (!dispatcher)
dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]), this[kClients].set(key, dispatcher);
return dispatcher.dispatch(opts, handler);
}
async[kClose]() {
let closePromises = [];
for (let client of this[kClients].values())
closePromises.push(client.close());
this[kClients].clear(), await Promise.all(closePromises);
}
async[kDestroy](err) {
let destroyPromises = [];
for (let client of this[kClients].values())
destroyPromises.push(client.destroy(err));
this[kClients].clear(), await Promise.all(destroyPromises);
}
}
module.exports = Agent;
});
// undici/lib/global.js
var require_global2 = __commonJS((exports, module) => {
var globalDispatcher = Symbol.for("undici.globalDispatcher.1"), { InvalidArgumentError } = require_errors(), Agent = require_agent();
if (getGlobalDispatcher() === void 0)
setGlobalDispatcher(new Agent);
function setGlobalDispatcher(agent) {
if (!agent || typeof agent.dispatch !== "function")
throw new InvalidArgumentError("Argument agent must implement Agent");
Object.defineProperty(globalThis, globalDispatcher, {
value: agent,
writable: !0,
enumerable: !1,
configurable: !1
});
}
function getGlobalDispatcher() {
return globalThis[globalDispatcher];
}
module.exports = {
setGlobalDispatcher,
getGlobalDispatcher
};
});
// undici/lib/web/fetch/index.js
var require_fetch = __commonJS((exports, module) => {
var {
makeNetworkError,
makeAppropriateNetworkError,
filterResponse,
makeResponse,
fromInnerResponse,
getResponseState
} = require_response(), { HeadersList } = require_headers(), { Request, cloneRequest, getRequestDispatcher, getRequestState } = require_request(), zlib = __require("node:zlib"), {
bytesMatch,
makePolicyContainer,
clonePolicyContainer,
requestBadPort,
TAOCheck,
appendRequestOriginHeader,
responseLocationURL,
requestCurrentURL,
setRequestReferrerPolicyOnRedirect,
tryUpgradeRequestToAPotentiallyTrustworthyURL,
createOpaqueTimingInfo,
appendFetchMetadata,
corsCheck,
crossOriginResourcePolicyCheck,
determineRequestsReferrer,
coarsenedSharedCurrentTime,
createDeferredPromise,
sameOrigin,
isCancelled,
isAborted,
isErrorLike,
fullyReadBody,
readableStreamClose,
isomorphicEncode,
urlIsLocal,
urlIsHttpHttpsScheme,
urlHasHttpsScheme,
clampAndCoarsenConnectionTimingInfo,
simpleRangeHeaderValue,
buildContentRange,
createInflate,
extractMimeType
} = require_util2(), assert = __require("node:assert"), { safelyExtractBody, extractBody } = require_body(), {
redirectStatusSet,
nullBodyStatus,
safeMethodsSet,
requestBodyHeader,
subresourceSet
} = require_constants(), EE = __require("node:events"), { Readable, pipeline, finished, isErrored, isReadable } = __require("node:stream"), { addAbortListener, bufferToLowerCasedHeaderName } = require_util(), { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = require_data_url(), { getGlobalDispatcher } = require_global2(), { webidl } = require_webidl(), { STATUS_CODES } = __require("node:http"), GET_OR_HEAD = ["GET", "HEAD"], defaultUserAgent = typeof __UNDICI_IS_NODE__ !== "undefined" || typeof esbuildDetection !== "undefined" ? "node" : "undici", resolveObjectURL;
class Fetch extends EE {
constructor(dispatcher) {
super();
this.dispatcher = dispatcher, this.connection = null, this.dump = !1, this.state = "ongoing";
}
terminate(reason) {
if (this.state !== "ongoing")
return;
this.state = "terminated", this.connection?.destroy(reason), this.emit("terminated", reason);
}
abort(error) {
if (this.state !== "ongoing")
return;
if (this.state = "aborted", !error)
error = new DOMException("The operation was aborted.", "AbortError");
this.serializedAbortReason = error, this.connection?.destroy(error), this.emit("terminated", error);
}
}
function handleFetchDone(response) {
finalizeAndReportTiming(response, "fetch");
}
function fetch(input, init = void 0) {
webidl.argumentLengthCheck(arguments, 1, "globalThis.fetch");
let p = createDeferredPromise(), requestObject;
try {
requestObject = new Request(input, init);
} catch (e) {
return p.reject(e), p.promise;
}
let request = getRequestState(requestObject);
if (requestObject.signal.aborted)
return abortFetch(p, request, null, requestObject.signal.reason), p.promise;
if (request.client.globalObject?.constructor?.name === "ServiceWorkerGlobalScope")
request.serviceWorkers = "none";
let responseObject = null, locallyAborted = !1, controller = null;
return addAbortListener(requestObject.signal, () => {
locallyAborted = !0, assert(controller != null), controller.abort(requestObject.signal.reason);
let realResponse = responseObject?.deref();
abortFetch(p, request, realResponse, requestObject.signal.reason);
}), controller = fetching({
request,
processResponseEndOfBody: handleFetchDone,
processResponse: (response) => {
if (locallyAborted)
return;
if (response.aborted) {
abortFetch(p, request, responseObject, controller.serializedAbortReason);
return;
}
if (response.type === "error") {
p.reject(new TypeError("fetch failed", { cause: response.error }));
return;
}
responseObject = new WeakRef(fromInnerResponse(response, "immutable")), p.resolve(responseObject.deref()), p = null;
},
dispatcher: getRequestDispatcher(requestObject)
}), p.promise;
}
function finalizeAndReportTiming(response, initiatorType = "other") {
if (response.type === "error" && response.aborted)
return;
if (!response.urlList?.length)
return;
let originalURL = response.urlList[0], timingInfo = response.timingInfo, cacheState = response.cacheState;
if (!urlIsHttpHttpsScheme(originalURL))
return;
if (timingInfo === null)
return;
if (!response.timingAllowPassed)
timingInfo = createOpaqueTimingInfo({
startTime: timingInfo.startTime
}), cacheState = "";
timingInfo.endTime = coarsenedSharedCurrentTime(), response.timingInfo = timingInfo, markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis, cacheState);
}
var markResourceTiming = performance.markResourceTiming;
function abortFetch(p, request, responseObject, error) {
if (p)
p.reject(error);
if (request.body?.stream != null && isReadable(request.body.stream))
request.body.stream.cancel(error).catch((err) => {
if (err.code === "ERR_INVALID_STATE")
return;
throw err;
});
if (responseObject == null)
return;
let response = getResponseState(responseObject);
if (response.body?.stream != null && isReadable(response.body.stream))
response.body.stream.cancel(error).catch((err) => {
if (err.code === "ERR_INVALID_STATE")
return;
throw err;
});
}
function fetching({
request,
processRequestBodyChunkLength,
processRequestEndOfBody,
processResponse,
processResponseEndOfBody,
processResponseConsumeBody,
useParallelQueue = !1,
dispatcher = getGlobalDispatcher()
}) {
assert(dispatcher);
let taskDestination = null, crossOriginIsolatedCapability = !1;
if (request.client != null)
taskDestination = request.client.globalObject, crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability;
let currentTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability), timingInfo = createOpaqueTimingInfo({
startTime: currentTime
}), fetchParams = {
controller: new Fetch(dispatcher),
request,
timingInfo,
processRequestBodyChunkLength,
processRequestEndOfBody,
processResponse,
processResponseConsumeBody,
processResponseEndOfBody,
taskDestination,
crossOriginIsolatedCapability
};
if (assert(!request.body || request.body.stream), request.window === "client")
request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window";
if (request.origin === "client")
request.origin = request.client.origin;
if (request.policyContainer === "client")
if (request.client != null)
request.policyContainer = clonePolicyContainer(request.client.policyContainer);
else
request.policyContainer = makePolicyContainer();
if (!request.headersList.contains("accept", !0))
request.headersList.append("accept", "*/*", !0);
if (!request.headersList.contains("accept-language", !0))
request.headersList.append("accept-language", "*", !0);
if (request.priority === null)
;
if (subresourceSet.has(request.destination))
;
return mainFetch(fetchParams).catch((err) => {
fetchParams.controller.terminate(err);
}), fetchParams.controller;
}
async function mainFetch(fetchParams, recursive = !1) {
let request = fetchParams.request, response = null;
if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request)))
response = makeNetworkError("local URLs only");
if (tryUpgradeRequestToAPotentiallyTrustworthyURL(request), requestBadPort(request) === "blocked")
response = makeNetworkError("bad port");
if (request.referrerPolicy === "")
request.referrerPolicy = request.policyContainer.referrerPolicy;
if (request.referrer !== "no-referrer")
request.referrer = determineRequestsReferrer(request);
if (response === null) {
let currentURL = requestCurrentURL(request);
if (sameOrigin(currentURL, request.url) && request.responseTainting === "basic" || currentURL.protocol === "data:" || (request.mode === "navigate" || request.mode === "websocket"))
request.responseTainting = "basic", response = await schemeFetch(fetchParams);
else if (request.mode === "same-origin")
response = makeNetworkError('request mode cannot be "same-origin"');
else if (request.mode === "no-cors")
if (request.redirect !== "follow")
response = makeNetworkError('redirect mode cannot be "follow" for "no-cors" request');
else
request.responseTainting = "opaque", response = await schemeFetch(fetchParams);
else if (!urlIsHttpHttpsScheme(requestCurrentURL(request)))
response = makeNetworkError("URL scheme must be a HTTP(S) scheme");
else
request.responseTainting = "cors", response = await httpFetch(fetchParams);
}
if (recursive)
return response;
if (response.status !== 0 && !response.internalResponse) {
if (request.responseTainting === "cors")
;
if (request.responseTainting === "basic")
response = filterResponse(response, "basic");
else if (request.responseTainting === "cors")
response = filterResponse(response, "cors");
else if (request.responseTainting === "opaque")
response = filterResponse(response, "opaque");
else
assert(!1);
}
let internalResponse = response.status === 0 ? response : response.internalResponse;
if (internalResponse.urlList.length === 0)
internalResponse.urlList.push(...request.urlList);
if (!request.timingAllowFailed)
response.timingAllowPassed = !0;
if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request.headers.contains("range", !0))
response = internalResponse = makeNetworkError();
if (response.status !== 0 && (request.method === "HEAD" || request.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status)))
internalResponse.body = null, fetchParams.controller.dump = !0;
if (request.integrity) {
let processBodyError = (reason) => fetchFinale(fetchParams, makeNetworkError(reason));
if (request.responseTainting === "opaque" || response.body == null) {
processBodyError(response.error);
return;
}
let processBody = (bytes) => {
if (!bytesMatch(bytes, request.integrity)) {
processBodyError("integrity mismatch");
return;
}
response.body = safelyExtractBody(bytes)[0], fetchFinale(fetchParams, response);
};
await fullyReadBody(response.body, processBody, processBodyError);
} else
fetchFinale(fetchParams, response);
}
function schemeFetch(fetchParams) {
if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0)
return Promise.resolve(makeAppropriateNetworkError(fetchParams));
let { request } = fetchParams, { protocol: scheme } = requestCurrentURL(request);
switch (scheme) {
case "about:":
return Promise.resolve(makeNetworkError("about scheme is not supported"));
case "blob:": {
if (!resolveObjectURL)
resolveObjectURL = __require("node:buffer").resolveObjectURL;
let blobURLEntry = requestCurrentURL(request);
if (blobURLEntry.search.length !== 0)
return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource."));
let blob = resolveObjectURL(blobURLEntry.toString());
if (request.method !== "GET" || !webidl.is.Blob(blob))
return Promise.resolve(makeNetworkError("invalid method"));
let response = makeResponse(), fullLength = blob.size, serializedFullLength = isomorphicEncode(`${fullLength}`), type = blob.type;
if (!request.headersList.contains("range", !0)) {
let bodyWithType = extractBody(blob);
response.statusText = "OK", response.body = bodyWithType[0], response.headersList.set("content-length", serializedFullLength, !0), response.headersList.set("content-type", type, !0);
} else {
response.rangeRequested = !0;
let rangeHeader = request.headersList.get("range", !0), rangeValue = simpleRangeHeaderValue(rangeHeader, !0);
if (rangeValue === "failure")
return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
let { rangeStartValue: rangeStart, rangeEndValue: rangeEnd } = rangeValue;
if (rangeStart === null)
rangeStart = fullLength - rangeEnd, rangeEnd = rangeStart + rangeEnd - 1;
else {
if (rangeStart >= fullLength)
return Promise.resolve(makeNetworkError("Range start is greater than the blob's size."));
if (rangeEnd === null || rangeEnd >= fullLength)
rangeEnd = fullLength - 1;
}
let slicedBlob = blob.slice(rangeStart, rangeEnd, type), slicedBodyWithType = extractBody(slicedBlob);
response.body = slicedBodyWithType[0];
let serializedSlicedLength = isomorphicEncode(`${slicedBlob.size}`), contentRange = buildContentRange(rangeStart, rangeEnd, fullLength);
response.status = 206, response.statusText = "Partial Content", response.headersList.set("content-length", serializedSlicedLength, !0), response.headersList.set("content-type", type, !0), response.headersList.set("content-range", contentRange, !0);
}
return Promise.resolve(response);
}
case "data:": {
let currentURL = requestCurrentURL(request), dataURLStruct = dataURLProcessor(currentURL);
if (dataURLStruct === "failure")
return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
let mimeType = serializeAMimeType(dataURLStruct.mimeType);
return Promise.resolve(makeResponse({
statusText: "OK",
headersList: [
["content-type", { name: "Content-Type", value: mimeType }]
],
body: safelyExtractBody(dataURLStruct.body)[0]
}));
}
case "file:":
return Promise.resolve(makeNetworkError("not implemented... yet..."));
case "http:":
case "https:":
return httpFetch(fetchParams).catch((err) => makeNetworkError(err));
default:
return Promise.resolve(makeNetworkError("unknown scheme"));
}
}
function finalizeResponse(fetchParams, response) {
if (fetchParams.request.done = !0, fetchParams.processResponseDone != null)
queueMicrotask(() => fetchParams.processResponseDone(response));
}
function fetchFinale(fetchParams, response) {
let timingInfo = fetchParams.timingInfo, processResponseEndOfBody = () => {
let unsafeEndTime = Date.now();
if (fetchParams.request.destination === "document")
fetchParams.controller.fullTimingInfo = timingInfo;
fetchParams.controller.reportTimingSteps = () => {
if (fetchParams.request.url.protocol !== "https:")
return;
timingInfo.endTime = unsafeEndTime;
let { cacheState, bodyInfo } = response;
if (!response.timingAllowPassed)
timingInfo = createOpaqueTimingInfo(timingInfo), cacheState = "";
let responseStatus = 0;
if (fetchParams.request.mode !== "navigator" || !response.hasCrossOriginRedirects) {
responseStatus = response.status;
let mimeType = extractMimeType(response.headersList);
if (mimeType !== "failure")
bodyInfo.contentType = minimizeSupportedMimeType(mimeType);
}
if (fetchParams.request.initiatorType != null)
markResourceTiming(timingInfo, fetchParams.request.url.href, fetchParams.request.initiatorType, globalThis, cacheState, bodyInfo, responseStatus);
};
let processResponseEndOfBodyTask = () => {
if (fetchParams.request.done = !0, fetchParams.processResponseEndOfBody != null)
queueMicrotask(() => fetchParams.processResponseEndOfBody(response));
if (fetchParams.request.initiatorType != null)
fetchParams.controller.reportTimingSteps();
};
queueMicrotask(() => processResponseEndOfBodyTask());
};
if (fetchParams.processResponse != null)
queueMicrotask(() => {
fetchParams.processResponse(response), fetchParams.processResponse = null;
});
let internalResponse = response.type === "error" ? response : response.internalResponse ?? response;
if (internalResponse.body == null)
processResponseEndOfBody();
else
finished(internalResponse.body.stream, () => {
processResponseEndOfBody();
});
}
async function httpFetch(fetchParams) {
let request = fetchParams.request, response = null, actualResponse = null, timingInfo = fetchParams.timingInfo;
if (request.serviceWorkers === "all")
;
if (response === null) {
if (request.redirect === "follow")
request.serviceWorkers = "none";
if (actualResponse = response = await httpNetworkOrCacheFetch(fetchParams), request.responseTainting === "cors" && corsCheck(request, response) === "failure")
return makeNetworkError("cors failure");
if (TAOCheck(request, response) === "failure")
request.timingAllowFailed = !0;
}
if ((request.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck(request.origin, request.client, request.destination, actualResponse) === "blocked")
return makeNetworkError("blocked");
if (redirectStatusSet.has(actualResponse.status)) {
if (request.redirect !== "manual")
fetchParams.controller.connection.destroy(void 0, !1);
if (request.redirect === "error")
response = makeNetworkError("unexpected redirect");
else if (request.redirect === "manual")
response = actualResponse;
else if (request.redirect === "follow")
response = await httpRedirectFetch(fetchParams, response);
else
assert(!1);
}
return response.timingInfo = timingInfo, response;
}
function httpRedirectFetch(fetchParams, response) {
let request = fetchParams.request, actualResponse = response.internalResponse ? response.internalResponse : response, locationURL;
try {
if (locationURL = responseLocationURL(actualResponse, requestCurrentURL(request).hash), locationURL == null)
return response;
} catch (err) {
return Promise.resolve(makeNetworkError(err));
}
if (!urlIsHttpHttpsScheme(locationURL))
return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme"));
if (request.redirectCount === 20)
return Promise.resolve(makeNetworkError("redirect count exceeded"));
if (request.redirectCount += 1, request.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request, locationURL))
return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"'));
if (request.responseTainting === "cors" && (locationURL.username || locationURL.password))
return Promise.resolve(makeNetworkError('URL cannot contain credentials for request mode "cors"'));
if (actualResponse.status !== 303 && request.body != null && request.body.source == null)
return Promise.resolve(makeNetworkError());
if ([301, 302].includes(actualResponse.status) && request.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request.method)) {
request.method = "GET", request.body = null;
for (let headerName of requestBodyHeader)
request.headersList.delete(headerName);
}
if (!sameOrigin(requestCurrentURL(request), locationURL))
request.headersList.delete("authorization", !0), request.headersList.delete("proxy-authorization", !0), request.headersList.delete("cookie", !0), request.headersList.delete("host", !0);
if (request.body != null)
assert(request.body.source != null), request.body = safelyExtractBody(request.body.source)[0];
let timingInfo = fetchParams.timingInfo;
if (timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability), timingInfo.redirectStartTime === 0)
timingInfo.redirectStartTime = timingInfo.startTime;
return request.urlList.push(locationURL), setRequestReferrerPolicyOnRedirect(request, actualResponse), mainFetch(fetchParams, !0);
}
async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = !1, isNewConnectionFetch = !1) {
let request = fetchParams.request, httpFetchParams = null, httpRequest = null, response = null, httpCache = null, revalidatingFlag = !1;
if (request.window === "no-window" && request.redirect === "error")
httpFetchParams = fetchParams, httpRequest = request;
else
httpRequest = cloneRequest(request), httpFetchParams = { ...fetchParams }, httpFetchParams.request = httpRequest;
let includeCredentials = request.credentials === "include" || request.credentials === "same-origin" && request.responseTainting === "basic", contentLength = httpRequest.body ? httpRequest.body.length : null, contentLengthHeaderValue = null;
if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method))
contentLengthHeaderValue = "0";
if (contentLength != null)
contentLengthHeaderValue = isomorphicEncode(`${contentLength}`);
if (contentLengthHeaderValue != null)
httpRequest.headersList.append("content-length", contentLengthHeaderValue, !0);
if (contentLength != null && httpRequest.keepalive)
;
if (webidl.is.URL(httpRequest.referrer))
httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href), !0);
if (appendRequestOriginHeader(httpRequest), appendFetchMetadata(httpRequest), !httpRequest.headersList.contains("user-agent", !0))
httpRequest.headersList.append("user-agent", defaultUserAgent, !0);
if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since", !0) || httpRequest.headersList.contains("if-none-match", !0) || httpRequest.headersList.contains("if-unmodified-since", !0) || httpRequest.headersList.contains("if-match", !0) || httpRequest.headersList.contains("if-range", !0)))
httpRequest.cache = "no-store";
if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control", !0))
httpRequest.headersList.append("cache-control", "max-age=0", !0);
if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") {
if (!httpRequest.headersList.contains("pragma", !0))
httpRequest.headersList.append("pragma", "no-cache", !0);
if (!httpRequest.headersList.contains("cache-control", !0))
httpRequest.headersList.append("cache-control", "no-cache", !0);
}
if (httpRequest.headersList.contains("range", !0))
httpRequest.headersList.append("accept-encoding", "identity", !0);
if (!httpRequest.headersList.contains("accept-encoding", !0))
if (urlHasHttpsScheme(requestCurrentURL(httpRequest)))
httpRequest.headersList.append("accept-encoding", "br, gzip, deflate", !0);
else
httpRequest.headersList.append("accept-encoding", "gzip, deflate", !0);
if (httpRequest.headersList.delete("host", !0), httpCache == null)
httpRequest.cache = "no-store";
if (httpRequest.cache !== "no-store" && httpRequest.cache !== "reload")
;
if (response == null) {
if (httpRequest.cache === "only-if-cached")
return makeNetworkError("only if cached");
let forwardResponse = await httpNetworkFetch(httpFetchParams, includeCredentials, isNewConnectionFetch);
if (!safeMethodsSet.has(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399)
;
if (revalidatingFlag && forwardResponse.status === 304)
;
if (response == null)
response = forwardResponse;
}
if (response.urlList = [...httpRequest.urlList], httpRequest.headersList.contains("range", !0))
response.rangeRequested = !0;
if (response.requestIncludesCredentials = includeCredentials, response.status === 407) {
if (request.window === "no-window")
return makeNetworkError();
if (isCancelled(fetchParams))
return makeAppropriateNetworkError(fetchParams);
return makeNetworkError("proxy authentication required");
}
if (response.status === 421 && !isNewConnectionFetch && (request.body == null || request.body.source != null)) {
if (isCancelled(fetchParams))
return makeAppropriateNetworkError(fetchParams);
fetchParams.controller.connection.destroy(), response = await httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch, !0);
}
return response;
}
async function httpNetworkFetch(fetchParams, includeCredentials = !1, forceNewConnection = !1) {
assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed), fetchParams.controller.connection = {
abort: null,
destroyed: !1,
destroy(err, abort = !0) {
if (!this.destroyed) {
if (this.destroyed = !0, abort)
this.abort?.(err ?? new DOMException("The operation was aborted.", "AbortError"));
}
}
};
let request = fetchParams.request, response = null, timingInfo = fetchParams.timingInfo;
if (!0)
request.cache = "no-store";
let newConnection = forceNewConnection ? "yes" : "no";
if (request.mode === "websocket")
;
let requestBody = null;
if (request.body == null && fetchParams.processRequestEndOfBody)
queueMicrotask(() => fetchParams.processRequestEndOfBody());
else if (request.body != null) {
let processBodyChunk = async function* (bytes) {
if (isCancelled(fetchParams))
return;
yield bytes, fetchParams.processRequestBodyChunkLength?.(bytes.byteLength);
}, processEndOfBody = () => {
if (isCancelled(fetchParams))
return;
if (fetchParams.processRequestEndOfBody)
fetchParams.processRequestEndOfBody();
}, processBodyError = (e) => {
if (isCancelled(fetchParams))
return;
if (e.name === "AbortError")
fetchParams.controller.abort();
else
fetchParams.controller.terminate(e);
};
requestBody = async function* () {
try {
for await (let bytes of request.body.stream)
yield* processBodyChunk(bytes);
processEndOfBody();
} catch (err) {
processBodyError(err);
}
}();
}
try {
let { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody });
if (socket)
response = makeResponse({ status, statusText, headersList, socket });
else {
let iterator = body[Symbol.asyncIterator]();
fetchParams.controller.next = () => iterator.next(), response = makeResponse({ status, statusText, headersList });
}
} catch (err) {
if (err.name === "AbortError")
return fetchParams.controller.connection.destroy(), makeAppropriateNetworkError(fetchParams, err);
return makeNetworkError(err);
}
let pullAlgorithm = () => {
return fetchParams.controller.resume();
}, cancelAlgorithm = (reason) => {
if (!isCancelled(fetchParams))
fetchParams.controller.abort(reason);
}, stream = new ReadableStream({
async start(controller) {
fetchParams.controller.controller = controller;
},
async pull(controller) {
await pullAlgorithm(controller);
},
async cancel(reason) {
await cancelAlgorithm(reason);
},
type: "bytes"
});
if (response.body = { stream, source: null, length: null }, !fetchParams.controller.resume)
fetchParams.controller.on("terminated", onAborted);
fetchParams.controller.resume = async () => {
while (!0) {
let bytes, isFailure;
try {
let { done, value } = await fetchParams.controller.next();
if (isAborted(fetchParams))
break;
bytes = done ? void 0 : value;
} catch (err) {
if (fetchParams.controller.ended && !timingInfo.encodedBodySize)
bytes = void 0;
else
bytes = err, isFailure = !0;
}
if (bytes === void 0) {
readableStreamClose(fetchParams.controller.controller), finalizeResponse(fetchParams, response);
return;
}
if (timingInfo.decodedBodySize += bytes?.byteLength ?? 0, isFailure) {
fetchParams.controller.terminate(bytes);
return;
}
let buffer = new Uint8Array(bytes);
if (buffer.byteLength)
fetchParams.controller.controller.enqueue(buffer);
if (isErrored(stream)) {
fetchParams.controller.terminate();
return;
}
if (fetchParams.controller.controller.desiredSize <= 0)
return;
}
};
function onAborted(reason) {
if (isAborted(fetchParams)) {
if (response.aborted = !0, isReadable(stream))
fetchParams.controller.controller.error(fetchParams.controller.serializedAbortReason);
} else if (isReadable(stream))
fetchParams.controller.controller.error(new TypeError("terminated", {
cause: isErrorLike(reason) ? reason : void 0
}));
fetchParams.controller.connection.destroy();
}
return response;
function dispatch({ body }) {
let url = requestCurrentURL(request), agent = fetchParams.controller.dispatcher;
return new Promise((resolve, reject) => agent.dispatch({
path: url.pathname + url.search,
origin: url.origin,
method: request.method,
body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body,
headers: request.headersList.entries,
maxRedirections: 0,
upgrade: request.mode === "websocket" ? "websocket" : void 0
}, {
body: null,
abort: null,
onConnect(abort) {
let { connection } = fetchParams.controller;
if (timingInfo.finalConnectionTimingInfo = clampAndCoarsenConnectionTimingInfo(void 0, timingInfo.postRedirectStartTime, fetchParams.crossOriginIsolatedCapability), connection.destroyed)
abort(new DOMException("The operation was aborted.", "AbortError"));
else
fetchParams.controller.on("terminated", abort), this.abort = connection.abort = abort;
timingInfo.finalNetworkRequestStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
},
onResponseStarted() {
timingInfo.finalNetworkResponseStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
},
onHeaders(status, rawHeaders, resume, statusText) {
if (status < 200)
return;
let codings = [], location = "", headersList = new HeadersList;
for (let i = 0;i < rawHeaders.length; i += 2)
headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), !0);
let contentEncoding = headersList.get("content-encoding", !0);
if (contentEncoding)
codings = contentEncoding.toLowerCase().split(",").map((x) => x.trim());
location = headersList.get("location", !0), this.body = new Readable({ read: resume });
let decoders = [], willFollow = location && request.redirect === "follow" && redirectStatusSet.has(status);
if (codings.length !== 0 && request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow)
for (let i = codings.length - 1;i >= 0; --i) {
let coding = codings[i];
if (coding === "x-gzip" || coding === "gzip")
decoders.push(zlib.createGunzip({
flush: zlib.constants.Z_SYNC_FLUSH,
finishFlush: zlib.constants.Z_SYNC_FLUSH
}));
else if (coding === "deflate")
decoders.push(createInflate({
flush: zlib.constants.Z_SYNC_FLUSH,
finishFlush: zlib.constants.Z_SYNC_FLUSH
}));
else if (coding === "br")
decoders.push(zlib.createBrotliDecompress({
flush: zlib.constants.BROTLI_OPERATION_FLUSH,
finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH
}));
else {
decoders.length = 0;
break;
}
}
let onError = this.onError.bind(this);
return resolve({
status,
statusText,
headersList,
body: decoders.length ? pipeline(this.body, ...decoders, (err) => {
if (err)
this.onError(err);
}).on("error", onError) : this.body.on("error", onError)
}), !0;
},
onData(chunk) {
if (fetchParams.controller.dump)
return;
let bytes = chunk;
return timingInfo.encodedBodySize += bytes.byteLength, this.body.push(bytes);
},
onComplete() {
if (this.abort)
fetchParams.controller.off("terminated", this.abort);
fetchParams.controller.ended = !0, this.body.push(null);
},
onError(error) {
if (this.abort)
fetchParams.controller.off("terminated", this.abort);
this.body?.destroy(error), fetchParams.controller.terminate(error), reject(error);
},
onUpgrade(status, rawHeaders, socket) {
if (status !== 101)
return;
let headersList = new HeadersList;
for (let i = 0;i < rawHeaders.length; i += 2)
headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), !0);
return resolve({
status,
statusText: STATUS_CODES[status],
headersList,
socket
}), !0;
}
}));
}
}
module.exports = {
fetch,
Fetch,
fetching,
finalizeAndReportTiming
};
});
// undici/lib/web/websocket/frame.js
var require_frame = __commonJS((exports, module) => {
var { maxUnsigned16Bit, opcodes } = require_constants3(), crypto, buffer = null, bufIdx = 8192;
try {
crypto = __require("node:crypto");
} catch {
crypto = {
randomFillSync: function randomFillSync(buffer2, _offset, _size) {
for (let i = 0;i < buffer2.length; ++i)
buffer2[i] = Math.random() * 255 | 0;
return buffer2;
}
};
}
function generateMask() {
if (bufIdx === 8192)
bufIdx = 0, crypto.randomFillSync(buffer ??= Buffer.allocUnsafeSlow(8192), 0, 8192);
return [buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++]];
}
class WebsocketFrameSend {
constructor(data) {
this.frameData = data;
}
createFrame(opcode) {
let frameData = this.frameData, maskKey = generateMask(), bodyLength = frameData?.byteLength ?? 0, payloadLength = bodyLength, offset = 6;
if (bodyLength > maxUnsigned16Bit)
offset += 8, payloadLength = 127;
else if (bodyLength > 125)
offset += 2, payloadLength = 126;
let buffer2 = Buffer.allocUnsafe(bodyLength + offset);
buffer2[0] = buffer2[1] = 0, buffer2[0] |= 128, buffer2[0] = (buffer2[0] & 240) + opcode;
/*! ws. MIT License. Einar Otto Stangvik <[email protected]> */
if (buffer2[offset - 4] = maskKey[0], buffer2[offset - 3] = maskKey[1], buffer2[offset - 2] = maskKey[2], buffer2[offset - 1] = maskKey[3], buffer2[1] = payloadLength, payloadLength === 126)
buffer2.writeUInt16BE(bodyLength, 2);
else if (payloadLength === 127)
buffer2[2] = buffer2[3] = 0, buffer2.writeUIntBE(bodyLength, 4, 6);
buffer2[1] |= 128;
for (let i = 0;i < bodyLength; ++i)
buffer2[offset + i] = frameData[i] ^ maskKey[i & 3];
return buffer2;
}
static createFastTextFrame(buffer2) {
let maskKey = generateMask(), bodyLength = buffer2.length;
for (let i = 0;i < bodyLength; ++i)
buffer2[i] ^= maskKey[i & 3];
let payloadLength = bodyLength, offset = 6;
if (bodyLength > maxUnsigned16Bit)
offset += 8, payloadLength = 127;
else if (bodyLength > 125)
offset += 2, payloadLength = 126;
let head = Buffer.allocUnsafeSlow(offset);
if (head[0] = 128 | opcodes.TEXT, head[1] = payloadLength | 128, head[offset - 4] = maskKey[0], head[offset - 3] = maskKey[1], head[offset - 2] = maskKey[2], head[offset - 1] = maskKey[3], payloadLength === 126)
head.writeUInt16BE(bodyLength, 2);
else if (payloadLength === 127)
head[2] = head[3] = 0, head.writeUIntBE(bodyLength, 4, 6);
return [head, buffer2];
}
}
module.exports = {
WebsocketFrameSend
};
});
// undici/lib/web/websocket/connection.js
var require_connection = __commonJS((exports, module) => {
var { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = require_constants3(), { parseExtensions, isClosed, isClosing, isEstablished, validateCloseCodeAndReason } = require_util3(), { channels } = require_diagnostics(), { makeRequest } = require_request(), { fetching } = require_fetch(), { Headers, getHeadersList } = require_headers(), { getDecodeSplit } = require_util2(), { WebsocketFrameSend } = require_frame(), assert = __require("node:assert"), crypto;
try {
crypto = __require("node:crypto");
} catch {
}
function establishWebSocketConnection(url, protocols, client, handler, options) {
let requestURL = url;
requestURL.protocol = url.protocol === "ws:" ? "http:" : "https:";
let request = makeRequest({
urlList: [requestURL],
client,
serviceWorkers: "none",
referrer: "no-referrer",
mode: "websocket",
credentials: "include",
cache: "no-store",
redirect: "error"
});
if (options.headers) {
let headersList = getHeadersList(new Headers(options.headers));
request.headersList = headersList;
}
let keyValue = crypto.randomBytes(16).toString("base64");
request.headersList.append("sec-websocket-key", keyValue, !0), request.headersList.append("sec-websocket-version", "13", !0);
for (let protocol of protocols)
request.headersList.append("sec-websocket-protocol", protocol, !0);
let permessageDeflate = "permessage-deflate; client_max_window_bits";
return request.headersList.append("sec-websocket-extensions", permessageDeflate, !0), fetching({
request,
useParallelQueue: !0,
dispatcher: options.dispatcher,
processResponse(response) {
if (response.type === "error")
handler.readyState = states.CLOSED;
if (response.type === "error" || response.status !== 101) {
failWebsocketConnection(handler, 1002, "Received network error or non-101 status code.");
return;
}
if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) {
failWebsocketConnection(handler, 1002, "Server did not respond with sent protocols.");
return;
}
if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") {
failWebsocketConnection(handler, 1002, 'Server did not set Upgrade header to "websocket".');
return;
}
if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") {
failWebsocketConnection(handler, 1002, 'Server did not set Connection header to "upgrade".');
return;
}
let secWSAccept = response.headersList.get("Sec-WebSocket-Accept"), digest = crypto.createHash("sha1").update(keyValue + uid).digest("base64");
if (secWSAccept !== digest) {
failWebsocketConnection(handler, 1002, "Incorrect hash received in Sec-WebSocket-Accept header.");
return;
}
let secExtension = response.headersList.get("Sec-WebSocket-Extensions"), extensions;
if (secExtension !== null) {
if (extensions = parseExtensions(secExtension), !extensions.has("permessage-deflate")) {
failWebsocketConnection(handler, 1002, "Sec-WebSocket-Extensions header does not match.");
return;
}
}
let secProtocol = response.headersList.get("Sec-WebSocket-Protocol");
if (secProtocol !== null) {
if (!getDecodeSplit("sec-websocket-protocol", request.headersList).includes(secProtocol)) {
failWebsocketConnection(handler, 1002, "Protocol was not set in the opening handshake.");
return;
}
}
if (response.socket.on("data", handler.onSocketData), response.socket.on("close", handler.onSocketClose), response.socket.on("error", handler.onSocketError), channels.open.hasSubscribers)
channels.open.publish({
address: response.socket.address(),
protocol: secProtocol,
extensions: secExtension
});
handler.wasEverConnected = !0, handler.onConnectionEstablished(response, extensions);
}
});
}
function closeWebSocketConnection(object, code, reason, validate = !1) {
if (code ??= null, reason ??= "", validate)
validateCloseCodeAndReason(code, reason);
if (isClosed(object.readyState) || isClosing(object.readyState))
;
else if (!isEstablished(object.readyState))
failWebsocketConnection(object), object.readyState = states.CLOSING;
else if (!object.closeState.has(sentCloseFrameState.SENT) && !object.closeState.has(sentCloseFrameState.RECEIVED)) {
let frame = new WebsocketFrameSend;
if (reason.length !== 0 && code === null)
code = 1000;
if (assert(code === null || Number.isInteger(code)), code === null && reason.length === 0)
frame.frameData = emptyBuffer;
else if (code !== null && reason === null)
frame.frameData = Buffer.allocUnsafe(2), frame.frameData.writeUInt16BE(code, 0);
else if (code !== null && reason !== null)
frame.frameData = Buffer.allocUnsafe(2 + Buffer.byteLength(reason)), frame.frameData.writeUInt16BE(code, 0), frame.frameData.write(reason, 2, "utf-8");
else
frame.frameData = emptyBuffer;
object.socket.write(frame.createFrame(opcodes.CLOSE)), object.closeState.add(sentCloseFrameState.SENT), object.readyState = states.CLOSING;
} else
object.readyState = states.CLOSING;
}
function failWebsocketConnection(handler, code, reason) {
if (isEstablished(handler.readyState))
closeWebSocketConnection(handler, code, reason, !1);
if (handler.controller.abort(), handler.socket?.destroyed === !1)
handler.socket.destroy();
handler.onFail(code, reason);
}
module.exports = {
establishWebSocketConnection,
failWebsocketConnection,
closeWebSocketConnection
};
});
// undici/lib/web/websocket/permessage-deflate.js
var require_permessage_deflate = __commonJS((exports, module) => {
var { createInflateRaw, Z_DEFAULT_WINDOWBITS } = __require("node:zlib"), { isValidClientWindowBits } = require_util3(), tail = Buffer.from([0, 0, 255, 255]), kBuffer = Symbol("kBuffer"), kLength = Symbol("kLength");
class PerMessageDeflate {
#inflate;
#options = {};
constructor(extensions) {
this.#options.serverNoContextTakeover = extensions.has("server_no_context_takeover"), this.#options.serverMaxWindowBits = extensions.get("server_max_window_bits");
}
decompress(chunk, fin, callback) {
if (!this.#inflate) {
let windowBits = Z_DEFAULT_WINDOWBITS;
if (this.#options.serverMaxWindowBits) {
if (!isValidClientWindowBits(this.#options.serverMaxWindowBits)) {
callback(new Error("Invalid server_max_window_bits"));
return;
}
windowBits = Number.parseInt(this.#options.serverMaxWindowBits);
}
this.#inflate = createInflateRaw({ windowBits }), this.#inflate[kBuffer] = [], this.#inflate[kLength] = 0, this.#inflate.on("data", (data) => {
this.#inflate[kBuffer].push(data), this.#inflate[kLength] += data.length;
}), this.#inflate.on("error", (err) => {
this.#inflate = null, callback(err);
});
}
if (this.#inflate.write(chunk), fin)
this.#inflate.write(tail);
this.#inflate.flush(() => {
let full = Buffer.concat(this.#inflate[kBuffer], this.#inflate[kLength]);
this.#inflate[kBuffer].length = 0, this.#inflate[kLength] = 0, callback(null, full);
});
}
}
module.exports = { PerMessageDeflate };
});
// undici/lib/web/websocket/receiver.js
var require_receiver = __commonJS((exports, module) => {
var { Writable } = __require("node:stream"), assert = __require("node:assert"), { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require_constants3(), { channels } = require_diagnostics(), {
isValidStatusCode,
isValidOpcode,
websocketMessageReceived,
utf8Decode,
isControlFrame,
isTextBinaryFrame,
isContinuationFrame
} = require_util3(), { failWebsocketConnection } = require_connection(), { WebsocketFrameSend } = require_frame(), { PerMessageDeflate } = require_permessage_deflate();
class ByteParser extends Writable {
#buffers = [];
#fragmentsBytes = 0;
#byteOffset = 0;
#loop = !1;
#state = parserStates.INFO;
#info = {};
#fragments = [];
#extensions;
#handler;
constructor(handler, extensions) {
super();
if (this.#handler = handler, this.#extensions = extensions == null ? /* @__PURE__ */ new Map : extensions, this.#extensions.has("permessage-deflate"))
this.#extensions.set("permessage-deflate", new PerMessageDeflate(extensions));
}
_write(chunk, _, callback) {
this.#buffers.push(chunk), this.#byteOffset += chunk.length, this.#loop = !0, this.run(callback);
}
run(callback) {
while (this.#loop)
if (this.#state === parserStates.INFO) {
if (this.#byteOffset < 2)
return callback();
let buffer = this.consume(2), fin = (buffer[0] & 128) !== 0, opcode = buffer[0] & 15, masked = (buffer[1] & 128) === 128, fragmented = !fin && opcode !== opcodes.CONTINUATION, payloadLength = buffer[1] & 127, rsv1 = buffer[0] & 64, rsv2 = buffer[0] & 32, rsv3 = buffer[0] & 16;
if (!isValidOpcode(opcode))
return failWebsocketConnection(this.#handler, 1002, "Invalid opcode received"), callback();
if (masked)
return failWebsocketConnection(this.#handler, 1002, "Frame cannot be masked"), callback();
if (rsv1 !== 0 && !this.#extensions.has("permessage-deflate")) {
failWebsocketConnection(this.#handler, 1002, "Expected RSV1 to be clear.");
return;
}
if (rsv2 !== 0 || rsv3 !== 0) {
failWebsocketConnection(this.#handler, 1002, "RSV1, RSV2, RSV3 must be clear");
return;
}
if (fragmented && !isTextBinaryFrame(opcode)) {
failWebsocketConnection(this.#handler, 1002, "Invalid frame type was fragmented.");
return;
}
if (isTextBinaryFrame(opcode) && this.#fragments.length > 0) {
failWebsocketConnection(this.#handler, 1002, "Expected continuation frame");
return;
}
if (this.#info.fragmented && fragmented) {
failWebsocketConnection(this.#handler, 1002, "Fragmented frame exceeded 125 bytes.");
return;
}
if ((payloadLength > 125 || fragmented) && isControlFrame(opcode)) {
failWebsocketConnection(this.#handler, 1002, "Control frame either too large or fragmented");
return;
}
if (isContinuationFrame(opcode) && this.#fragments.length === 0 && !this.#info.compressed) {
failWebsocketConnection(this.#handler, 1002, "Unexpected continuation frame");
return;
}
if (payloadLength <= 125)
this.#info.payloadLength = payloadLength, this.#state = parserStates.READ_DATA;
else if (payloadLength === 126)
this.#state = parserStates.PAYLOADLENGTH_16;
else if (payloadLength === 127)
this.#state = parserStates.PAYLOADLENGTH_64;
if (isTextBinaryFrame(opcode))
this.#info.binaryType = opcode, this.#info.compressed = rsv1 !== 0;
this.#info.opcode = opcode, this.#info.masked = masked, this.#info.fin = fin, this.#info.fragmented = fragmented;
} else if (this.#state === parserStates.PAYLOADLENGTH_16) {
if (this.#byteOffset < 2)
return callback();
let buffer = this.consume(2);
this.#info.payloadLength = buffer.readUInt16BE(0), this.#state = parserStates.READ_DATA;
} else if (this.#state === parserStates.PAYLOADLENGTH_64) {
if (this.#byteOffset < 8)
return callback();
let buffer = this.consume(8), upper = buffer.readUInt32BE(0);
if (upper > 2147483647) {
failWebsocketConnection(this.#handler, 1009, "Received payload length > 2^31 bytes.");
return;
}
let lower = buffer.readUInt32BE(4);
this.#info.payloadLength = (upper << 8) + lower, this.#state = parserStates.READ_DATA;
} else if (this.#state === parserStates.READ_DATA) {
if (this.#byteOffset < this.#info.payloadLength)
return callback();
let body = this.consume(this.#info.payloadLength);
if (isControlFrame(this.#info.opcode))
this.#loop = this.parseControlFrame(body), this.#state = parserStates.INFO;
else if (!this.#info.compressed) {
if (this.writeFragments(body), !this.#info.fragmented && this.#info.fin)
websocketMessageReceived(this.#handler, this.#info.binaryType, this.consumeFragments());
this.#state = parserStates.INFO;
} else {
this.#extensions.get("permessage-deflate").decompress(body, this.#info.fin, (error, data) => {
if (error) {
failWebsocketConnection(this.#handler, 1007, error.message);
return;
}
if (this.writeFragments(data), !this.#info.fin) {
this.#state = parserStates.INFO, this.#loop = !0, this.run(callback);
return;
}
websocketMessageReceived(this.#handler, this.#info.binaryType, this.consumeFragments()), this.#loop = !0, this.#state = parserStates.INFO, this.run(callback);
}), this.#loop = !1;
break;
}
}
}
consume(n) {
if (n > this.#byteOffset)
throw new Error("Called consume() before buffers satiated.");
else if (n === 0)
return emptyBuffer;
this.#byteOffset -= n;
let first = this.#buffers[0];
if (first.length > n)
return this.#buffers[0] = first.subarray(n, first.length), first.subarray(0, n);
else if (first.length === n)
return this.#buffers.shift();
else {
let offset = 0, buffer = Buffer.allocUnsafeSlow(n);
while (offset !== n) {
let next = this.#buffers[0], length = next.length;
if (length + offset === n) {
buffer.set(this.#buffers.shift(), offset);
break;
} else if (length + offset > n) {
buffer.set(next.subarray(0, n - offset), offset), this.#buffers[0] = next.subarray(n - offset);
break;
} else
buffer.set(this.#buffers.shift(), offset), offset += length;
}
return buffer;
}
}
writeFragments(fragment) {
this.#fragmentsBytes += fragment.length, this.#fragments.push(fragment);
}
consumeFragments() {
let fragments = this.#fragments;
if (fragments.length === 1)
return this.#fragmentsBytes = 0, fragments.shift();
let offset = 0, output = Buffer.allocUnsafeSlow(this.#fragmentsBytes);
for (let i = 0;i < fragments.length; ++i) {
let buffer = fragments[i];
output.set(buffer, offset), offset += buffer.length;
}
return this.#fragments = [], this.#fragmentsBytes = 0, output;
}
parseCloseBody(data) {
assert(data.length !== 1);
let code;
if (data.length >= 2)
code = data.readUInt16BE(0);
if (code !== void 0 && !isValidStatusCode(code))
return { code: 1002, reason: "Invalid status code", error: !0 };
let reason = data.subarray(2);
if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191)
reason = reason.subarray(3);
try {
reason = utf8Decode(reason);
} catch {
return { code: 1007, reason: "Invalid UTF-8", error: !0 };
}
return { code, reason, error: !1 };
}
parseControlFrame(body) {
let { opcode, payloadLength } = this.#info;
if (opcode === opcodes.CLOSE) {
if (payloadLength === 1)
return failWebsocketConnection(this.#handler, 1002, "Received close frame with a 1-byte body."), !1;
if (this.#info.closeInfo = this.parseCloseBody(body), this.#info.closeInfo.error) {
let { code, reason } = this.#info.closeInfo;
return failWebsocketConnection(this.#handler, code, reason), !1;
}
if (!this.#handler.closeState.has(sentCloseFrameState.SENT) && !this.#handler.closeState.has(sentCloseFrameState.RECEIVED)) {
let body2 = emptyBuffer;
if (this.#info.closeInfo.code)
body2 = Buffer.allocUnsafe(2), body2.writeUInt16BE(this.#info.closeInfo.code, 0);
let closeFrame = new WebsocketFrameSend(body2);
this.#handler.socket.write(closeFrame.createFrame(opcodes.CLOSE)), this.#handler.closeState.add(sentCloseFrameState.SENT);
}
return this.#handler.readyState = states.CLOSING, this.#handler.closeState.add(sentCloseFrameState.RECEIVED), !1;
} else if (opcode === opcodes.PING) {
if (!this.#handler.closeState.has(sentCloseFrameState.RECEIVED)) {
let frame = new WebsocketFrameSend(body);
if (this.#handler.socket.write(frame.createFrame(opcodes.PONG)), channels.ping.hasSubscribers)
channels.ping.publish({
payload: body
});
}
} else if (opcode === opcodes.PONG) {
if (channels.pong.hasSubscribers)
channels.pong.publish({
payload: body
});
}
return !0;
}
get closingInfo() {
return this.#info.closeInfo;
}
}
module.exports = {
ByteParser
};
});
// undici/lib/web/websocket/stream/websocketerror.js
var require_websocketerror = __commonJS((exports, module) => {
var { webidl } = require_webidl(), { validateCloseCodeAndReason } = require_util3(), { kConstruct } = require_symbols(), { kEnumerableProperty } = require_util();
class WebSocketError extends DOMException {
#closeCode;
#reason;
constructor(message = "", init = void 0) {
message = webidl.converters.DOMString(message, "WebSocketError", "message");
super(message, "WebSocketError");
if (init === kConstruct)
return;
else if (init !== null)
init = webidl.converters.WebSocketCloseInfo(init);
let code = init.closeCode ?? null, reason = init.reason ?? "";
if (validateCloseCodeAndReason(code, reason), reason.length !== 0 && code === null)
code = 1000;
this.#closeCode = code, this.#reason = reason;
}
get closeCode() {
return this.#closeCode;
}
get reason() {
return this.#reason;
}
static createUnvalidatedWebSocketError(message, code, reason) {
let error = new WebSocketError(message, kConstruct);
return error.#closeCode = code, error.#reason = reason, error;
}
}
var { createUnvalidatedWebSocketError } = WebSocketError;
delete WebSocketError.createUnvalidatedWebSocketError;
Object.defineProperties(WebSocketError.prototype, {
closeCode: kEnumerableProperty,
reason: kEnumerableProperty,
[Symbol.toStringTag]: {
value: "WebSocketError",
writable: !1,
enumerable: !1,
configurable: !0
}
});
webidl.is.WebSocketError = webidl.util.MakeTypeAssertion(WebSocketError);
module.exports = { WebSocketError, createUnvalidatedWebSocketError };
});
// undici/lib/web/websocket/stream/websocketstream.js
var require_websocketstream = __commonJS((exports, module) => {
var { createDeferredPromise, environmentSettingsObject } = require_util2(), { states, opcodes, sentCloseFrameState } = require_constants3(), { webidl } = require_webidl(), { getURLRecord, isValidSubprotocol, isEstablished, utf8Decode } = require_util3(), { establishWebSocketConnection, failWebsocketConnection, closeWebSocketConnection } = require_connection(), { types } = __require("node:util"), { channels } = require_diagnostics(), { WebsocketFrameSend } = require_frame(), { ByteParser } = require_receiver(), { WebSocketError, createUnvalidatedWebSocketError } = require_websocketerror(), { utf8DecodeBytes } = require_util2(), { kEnumerableProperty } = require_util(), emittedExperimentalWarning = !1;
class WebSocketStream {
#url;
#openedPromise;
#closedPromise;
#readableStream;
#readableStreamController;
#writableStream;
#handshakeAborted = !1;
#handler = {
onConnectionEstablished: (response, extensions) => this.#onConnectionEstablished(response, extensions),
onFail: (_code, _reason) => {
},
onMessage: (opcode, data) => this.#onMessage(opcode, data),
onParserError: (err) => failWebsocketConnection(this.#handler, null, err.message),
onParserDrain: () => this.#handler.socket.resume(),
onSocketData: (chunk) => {
if (!this.#parser.write(chunk))
this.#handler.socket.pause();
},
onSocketError: (err) => {
if (this.#handler.readyState = states.CLOSING, channels.socketError.hasSubscribers)
channels.socketError.publish(err);
this.#handler.socket.destroy();
},
onSocketClose: () => this.#onSocketClose(),
readyState: states.CONNECTING,
socket: null,
closeState: /* @__PURE__ */ new Set,
controller: null,
wasEverConnected: !1
};
#parser;
constructor(url, options = void 0) {
if (!emittedExperimentalWarning)
process.emitWarning("WebSocketStream is experimental! Expect it to change at any time.", {
code: "UNDICI-WSS"
}), emittedExperimentalWarning = !0;
if (webidl.argumentLengthCheck(arguments, 1, "WebSocket"), url = webidl.converters.USVString(url), options !== null)
options = webidl.converters.WebSocketStreamOptions(options);
let baseURL = environmentSettingsObject.settingsObject.baseUrl, urlRecord = getURLRecord(url, baseURL), protocols = options.protocols;
if (protocols.length !== new Set(protocols.map((p) => p.toLowerCase())).size)
throw new DOMException("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
if (protocols.length > 0 && !protocols.every((p) => isValidSubprotocol(p)))
throw new DOMException("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
if (this.#url = urlRecord.toString(), this.#openedPromise = createDeferredPromise(), this.#closedPromise = createDeferredPromise(), options.signal != null) {
let signal = options.signal;
if (signal.aborted) {
this.#openedPromise.reject(signal.reason), this.#closedPromise.reject(signal.reason);
return;
}
signal.addEventListener("abort", () => {
if (!isEstablished(this.#handler.readyState))
failWebsocketConnection(this.#handler), this.#handler.readyState = states.CLOSING, this.#openedPromise.reject(signal.reason), this.#closedPromise.reject(signal.reason), this.#handshakeAborted = !0;
}, { once: !0 });
}
let client = environmentSettingsObject.settingsObject;
this.#handler.controller = establishWebSocketConnection(urlRecord, protocols, client, this.#handler, options);
}
get url() {
return this.#url.toString();
}
get opened() {
return this.#openedPromise.promise;
}
get closed() {
return this.#closedPromise.promise;
}
close(closeInfo = void 0) {
if (closeInfo !== null)
closeInfo = webidl.converters.WebSocketCloseInfo(closeInfo);
let code = closeInfo.closeCode ?? null, reason = closeInfo.reason;
closeWebSocketConnection(this.#handler, code, reason, !0);
}
#write(chunk) {
let promise = createDeferredPromise(), data = null, opcode = null;
if (ArrayBuffer.isView(chunk) || types.isArrayBuffer(chunk))
data = new Uint8Array(ArrayBuffer.isView(chunk) ? new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength) : chunk), opcode = opcodes.BINARY;
else {
let string;
try {
string = webidl.converters.DOMString(chunk);
} catch (e) {
promise.reject(e);
return;
}
data = (/* @__PURE__ */ new TextEncoder()).encode(string), opcode = opcodes.TEXT;
}
if (!this.#handler.closeState.has(sentCloseFrameState.SENT) && !this.#handler.closeState.has(sentCloseFrameState.RECEIVED)) {
let frame = new WebsocketFrameSend(data);
this.#handler.socket.write(frame.createFrame(opcode), () => {
promise.resolve(void 0);
});
}
return promise;
}
#onConnectionEstablished(response, parsedExtensions) {
this.#handler.socket = response.socket;
let parser = new ByteParser(this.#handler, parsedExtensions);
parser.on("drain", () => this.#handler.onParserDrain()), parser.on("error", (err) => this.#handler.onParserError(err)), this.#parser = parser, this.#handler.readyState = states.OPEN;
let extensions = parsedExtensions ?? "", protocol = response.headersList.get("sec-websocket-protocol") ?? "", readable = new ReadableStream({
start: (controller) => {
this.#readableStreamController = controller;
},
pull(controller) {
let chunk;
while (controller.desiredSize > 0 && (chunk = response.socket.read()) !== null)
controller.enqueue(chunk);
},
cancel: (reason) => this.#cancel(reason)
}), writable = new WritableStream({
write: (chunk) => this.#write(chunk),
close: () => closeWebSocketConnection(this.#handler, null, null),
abort: (reason) => this.#closeUsingReason(reason)
});
this.#readableStream = readable, this.#writableStream = writable, this.#openedPromise.resolve({
extensions,
protocol,
readable,
writable
});
}
#onMessage(type, data) {
if (this.#handler.readyState !== states.OPEN)
return;
let chunk;
if (type === opcodes.TEXT)
try {
chunk = utf8Decode(data);
} catch {
failWebsocketConnection(this.#handler, "Received invalid UTF-8 in text frame.");
return;
}
else if (type === opcodes.BINARY)
chunk = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
this.#readableStreamController.enqueue(chunk);
}
#onSocketClose() {
let wasClean = this.#handler.closeState.has(sentCloseFrameState.SENT) && this.#handler.closeState.has(sentCloseFrameState.RECEIVED);
if (this.#handler.readyState = states.CLOSED, this.#handshakeAborted)
return;
if (!this.#handler.wasEverConnected)
this.#openedPromise.reject(new WebSocketError("Socket never opened"));
let result = this.#parser.closingInfo, code = result?.code ?? 1005;
if (!this.#handler.closeState.has(sentCloseFrameState.SENT) && !this.#handler.closeState.has(sentCloseFrameState.RECEIVED))
code = 1006;
let reason = result?.reason == null ? "" : utf8DecodeBytes(Buffer.from(result.reason));
if (wasClean) {
if (this.#readableStream.cancel().catch(() => {
}), !this.#writableStream.locked)
this.#writableStream.abort(new DOMException("A closed WebSocketStream cannot be written to", "InvalidStateError"));
this.#closedPromise.resolve({
closeCode: code,
reason
});
} else {
let error = createUnvalidatedWebSocketError("unclean close", code, reason);
this.#readableStreamController.error(error), this.#writableStream.abort(error), this.#closedPromise.reject(error);
}
}
#closeUsingReason(reason) {
let code = null, reasonString = "";
if (webidl.is.WebSocketError(reason))
code = reason.closeCode, reasonString = reason.reason;
closeWebSocketConnection(this.#handler, code, reasonString);
}
#cancel(reason) {
this.#closeUsingReason(reason);
}
}
Object.defineProperties(WebSocketStream.prototype, {
url: kEnumerableProperty,
opened: kEnumerableProperty,
closed: kEnumerableProperty,
close: kEnumerableProperty,
[Symbol.toStringTag]: {
value: "WebSocketStream",
writable: !1,
enumerable: !1,
configurable: !0
}
});
webidl.converters.WebSocketStreamOptions = webidl.dictionaryConverter([
{
key: "protocols",
converter: webidl.sequenceConverter(webidl.converters.USVString),
defaultValue: () => []
},
{
key: "signal",
converter: webidl.nullableConverter(webidl.converters.AbortSignal),
defaultValue: () => null
}
]);
webidl.converters.WebSocketCloseInfo = webidl.dictionaryConverter([
{
key: "closeCode",
converter: (V) => webidl.converters["unsigned short"](V, { enforceRange: !0 })
},
{
key: "reason",
converter: webidl.converters.USVString,
defaultValue: () => ""
}
]);
module.exports = { WebSocketStream };
});
export default require_websocketstream();
@guest271314
Copy link
Author

undici-wss.js

// bun build undici/lib/web/websocket/stream/websocketstream.js --target=node --packages=external --format=esm --minify --outfile=websocketstream-undici-bundle.js
// deno -A --unsafely-ignore-certificate-errors -q --unstable-node-globals undici-wss.js
// NODE_TLS_REJECT_UNAUTHORIZED=0 node --no-warnings undici-wss.js

const { default: { WebSocketStream } } = await import(
  "./websocketstream-undici-bundle.js"
);

var abortable = new AbortController();
var {
  signal,
} = abortable;
var wss = new WebSocketStream("wss://0.0.0.0:8000", {
  // signal: AbortSignal.timeout(5000),
});
console.log(wss);
wss.closed.catch((e) => {
  console.log(e);
});

var {
  readable,
  writable,
} = await wss.opened.catch(console.error);
var writer = writable.getWriter();

// .pipeThrough(new TextDecoderStream())
var socket = readable.pipeTo(
  new WritableStream({
    start(c) {
      console.log("Start");
    },
    async write(value) {
      console.log(decoder.decode(value));
    },
    close() {
      console.log("WritableStream closed");
    },
    abort(reason) {
      console.log({
        reason,
      });
    },
  }),
  { highWaterMark: Infinity,
    signal
  },
);

socket.then(() => console.log("WebSocketStream complete")).catch(console.warn);

var encoder = new TextEncoder();
var decoder = new TextDecoder();
var encode = (text) => encoder.encode(text);
await writer.ready;
await writer.write(encode("a"));
await writer.ready;
await writer.write(encode("b"));
// Node.js only sends back "AB" without delay between writes
// Deno sends back each write without delay
// Bun doesn't work
// await new Promise((r) => setTimeout(r, 100));
await writer.ready;
await writer.write(encode("c"));
await writer.ready;
await writer.write(encode("d"));
// await new Promise((r) => setTimeout(r, 100));
await writer.ready;
await writer.write(encode("e"));
await writer.ready;
await writer.write(encode("f"));
// await new Promise((r) => setTimeout(r, 100));
await writer.ready;
await writer.write(encode("g"));
// abortable.abort("reason");

deno -A --unsafely-ignore-certificate-errors -q --unstable-node-globals undici-wss.js
DANGER: TLS certificate validation is disabled for all hostnames
WebSocketStream {}
Start
A
B
C
D
E
F
G

NODE_TLS_REJECT_UNAUTHORIZED=0 node --no-warnings undici-wss.js
WebSocketStream {}
Start
A
B

bun undici-wss.js
WebSocketStream {
  url: [Getter],
  opened: [Getter],
  closed: [Getter],
  close: [Function: close],
}
Warning: WebSocketStream is experimental! Expect it to change at any time.
 code: "UNDICI-WSS"

      at new WebSocketStream (/home/user/Downloads/websocketstream-undici-bundle.js:8689:17)
      at /home/user/Downloads/undici-ws.js:13:11

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment