%PDF-
%PDF-
Mini Shell
Mini Shell
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
// lib/core/symbols.js
var require_symbols = __commonJS({
"lib/core/symbols.js"(exports2, module2) {
module2.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"),
kHeadersList: Symbol("headers list"),
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"),
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"),
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"),
kInterceptors: Symbol("dispatch interceptors"),
kMaxResponseSize: Symbol("max response size"),
kHTTP2Session: Symbol("http2Session"),
kHTTP2SessionState: Symbol("http2Session state"),
kHTTP2BuildRequest: Symbol("http2 build request"),
kHTTP1BuildRequest: Symbol("http1 build request"),
kHTTP2CopyHeaders: Symbol("http2 copy headers"),
kHTTPConnVersion: Symbol("http connection version"),
kRetryHandlerDefaultRetry: Symbol("retry agent default retry"),
kConstruct: Symbol("constructable")
};
}
});
// lib/fetch/symbols.js
var require_symbols2 = __commonJS({
"lib/fetch/symbols.js"(exports2, module2) {
"use strict";
module2.exports = {
kUrl: Symbol("url"),
kHeaders: Symbol("headers"),
kSignal: Symbol("signal"),
kState: Symbol("state"),
kGuard: Symbol("guard"),
kRealm: Symbol("realm")
};
}
});
// lib/core/errors.js
var require_errors = __commonJS({
"lib/core/errors.js"(exports2, module2) {
"use strict";
var UndiciError = class extends Error {
static {
__name(this, "UndiciError");
}
constructor(message) {
super(message);
this.name = "UndiciError";
this.code = "UND_ERR";
}
};
var ConnectTimeoutError = class extends UndiciError {
static {
__name(this, "ConnectTimeoutError");
}
constructor(message) {
super(message);
this.name = "ConnectTimeoutError";
this.message = message || "Connect Timeout Error";
this.code = "UND_ERR_CONNECT_TIMEOUT";
}
};
var HeadersTimeoutError = class extends UndiciError {
static {
__name(this, "HeadersTimeoutError");
}
constructor(message) {
super(message);
this.name = "HeadersTimeoutError";
this.message = message || "Headers Timeout Error";
this.code = "UND_ERR_HEADERS_TIMEOUT";
}
};
var HeadersOverflowError = class extends UndiciError {
static {
__name(this, "HeadersOverflowError");
}
constructor(message) {
super(message);
this.name = "HeadersOverflowError";
this.message = message || "Headers Overflow Error";
this.code = "UND_ERR_HEADERS_OVERFLOW";
}
};
var BodyTimeoutError = class extends UndiciError {
static {
__name(this, "BodyTimeoutError");
}
constructor(message) {
super(message);
this.name = "BodyTimeoutError";
this.message = message || "Body Timeout Error";
this.code = "UND_ERR_BODY_TIMEOUT";
}
};
var ResponseStatusCodeError = class extends UndiciError {
static {
__name(this, "ResponseStatusCodeError");
}
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;
}
};
var InvalidArgumentError = class extends UndiciError {
static {
__name(this, "InvalidArgumentError");
}
constructor(message) {
super(message);
this.name = "InvalidArgumentError";
this.message = message || "Invalid Argument Error";
this.code = "UND_ERR_INVALID_ARG";
}
};
var InvalidReturnValueError = class extends UndiciError {
static {
__name(this, "InvalidReturnValueError");
}
constructor(message) {
super(message);
this.name = "InvalidReturnValueError";
this.message = message || "Invalid Return Value Error";
this.code = "UND_ERR_INVALID_RETURN_VALUE";
}
};
var AbortError = class extends UndiciError {
static {
__name(this, "AbortError");
}
constructor(message) {
super(message);
this.name = "AbortError";
this.message = message || "The operation was aborted";
}
};
var RequestAbortedError = class extends AbortError {
static {
__name(this, "RequestAbortedError");
}
constructor(message) {
super(message);
this.name = "AbortError";
this.message = message || "Request aborted";
this.code = "UND_ERR_ABORTED";
}
};
var InformationalError = class extends UndiciError {
static {
__name(this, "InformationalError");
}
constructor(message) {
super(message);
this.name = "InformationalError";
this.message = message || "Request information";
this.code = "UND_ERR_INFO";
}
};
var RequestContentLengthMismatchError = class extends UndiciError {
static {
__name(this, "RequestContentLengthMismatchError");
}
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";
}
};
var ResponseContentLengthMismatchError = class extends UndiciError {
static {
__name(this, "ResponseContentLengthMismatchError");
}
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";
}
};
var ClientDestroyedError = class extends UndiciError {
static {
__name(this, "ClientDestroyedError");
}
constructor(message) {
super(message);
this.name = "ClientDestroyedError";
this.message = message || "The client is destroyed";
this.code = "UND_ERR_DESTROYED";
}
};
var ClientClosedError = class extends UndiciError {
static {
__name(this, "ClientClosedError");
}
constructor(message) {
super(message);
this.name = "ClientClosedError";
this.message = message || "The client is closed";
this.code = "UND_ERR_CLOSED";
}
};
var SocketError = class extends UndiciError {
static {
__name(this, "SocketError");
}
constructor(message, socket) {
super(message);
this.name = "SocketError";
this.message = message || "Socket error";
this.code = "UND_ERR_SOCKET";
this.socket = socket;
}
};
var NotSupportedError = class extends UndiciError {
static {
__name(this, "NotSupportedError");
}
constructor(message) {
super(message);
this.name = "NotSupportedError";
this.message = message || "Not supported error";
this.code = "UND_ERR_NOT_SUPPORTED";
}
};
var BalancedPoolMissingUpstreamError = class extends UndiciError {
static {
__name(this, "BalancedPoolMissingUpstreamError");
}
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";
}
};
var HTTPParserError = class extends Error {
static {
__name(this, "HTTPParserError");
}
constructor(message, code, data) {
super(message);
this.name = "HTTPParserError";
this.code = code ? `HPE_${code}` : void 0;
this.data = data ? data.toString() : void 0;
}
};
var ResponseExceededMaxSizeError = class extends UndiciError {
static {
__name(this, "ResponseExceededMaxSizeError");
}
constructor(message) {
super(message);
this.name = "ResponseExceededMaxSizeError";
this.message = message || "Response content exceeded max size";
this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE";
}
};
var RequestRetryError = class extends UndiciError {
static {
__name(this, "RequestRetryError");
}
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;
}
};
module2.exports = {
AbortError,
HTTPParserError,
UndiciError,
HeadersTimeoutError,
HeadersOverflowError,
BodyTimeoutError,
RequestContentLengthMismatchError,
ConnectTimeoutError,
ResponseStatusCodeError,
InvalidArgumentError,
InvalidReturnValueError,
RequestAbortedError,
ClientDestroyedError,
ClientClosedError,
InformationalError,
SocketError,
NotSupportedError,
ResponseContentLengthMismatchError,
BalancedPoolMissingUpstreamError,
ResponseExceededMaxSizeError,
RequestRetryError
};
}
});
// lib/core/constants.js
var require_constants = __commonJS({
"lib/core/constants.js"(exports2, module2) {
"use strict";
var headerNameLowerCasedRecord = {};
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"
];
for (let i = 0; i < wellknownHeaderNames.length; ++i) {
const key = wellknownHeaderNames[i];
const lowerCasedKey = key.toLowerCase();
headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey;
}
Object.setPrototypeOf(headerNameLowerCasedRecord, null);
module2.exports = {
wellknownHeaderNames,
headerNameLowerCasedRecord
};
}
});
// lib/core/tree.js
var require_tree = __commonJS({
"lib/core/tree.js"(exports2, module2) {
"use strict";
var {
wellknownHeaderNames,
headerNameLowerCasedRecord
} = require_constants();
var TstNode = class _TstNode {
static {
__name(this, "TstNode");
}
/** @type {any} */
value = null;
/** @type {null | TstNode} */
left = null;
/** @type {null | TstNode} */
middle = null;
/** @type {null | TstNode} */
right = null;
/** @type {number} */
code;
/**
* @param {Uint8Array} key
* @param {any} value
* @param {number} index
*/
constructor(key, value, index) {
if (index === void 0 || index >= key.length) {
throw new TypeError("Unreachable");
}
this.code = key[index];
if (key.length !== ++index) {
this.middle = new _TstNode(key, value, index);
} else {
this.value = value;
}
}
/**
* @param {Uint8Array} key
* @param {any} value
* @param {number} index
*/
add(key, value, index) {
if (index === void 0 || index >= key.length) {
throw new TypeError("Unreachable");
}
const code = key[index];
if (this.code === code) {
if (key.length === ++index) {
this.value = value;
} else if (this.middle !== null) {
this.middle.add(key, value, index);
} else {
this.middle = new _TstNode(key, value, index);
}
} else if (this.code < code) {
if (this.left !== null) {
this.left.add(key, value, index);
} else {
this.left = new _TstNode(key, value, index);
}
} else if (this.right !== null) {
this.right.add(key, value, index);
} else {
this.right = new _TstNode(key, value, index);
}
}
/**
* @param {Uint8Array} key
* @return {TstNode | null}
*/
search(key) {
const keylength = key.length;
let index = 0;
let node = this;
while (node !== null && index < keylength) {
let code = key[index];
if (code >= 65 && code <= 90) {
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;
}
};
var TernarySearchTree = class {
static {
__name(this, "TernarySearchTree");
}
/** @type {TstNode | null} */
node = null;
/**
* @param {Uint8Array} key
* @param {any} value
* */
insert(key, value) {
if (this.node === null) {
this.node = new TstNode(key, value, 0);
} else {
this.node.add(key, value, 0);
}
}
/**
* @param {Uint8Array} key
*/
lookup(key) {
return this.node?.search(key)?.value ?? null;
}
};
var tree = new TernarySearchTree();
for (let i = 0; i < wellknownHeaderNames.length; ++i) {
const key = headerNameLowerCasedRecord[wellknownHeaderNames[i]];
tree.insert(Buffer.from(key), key);
}
module2.exports = {
TernarySearchTree,
tree
};
}
});
// lib/core/util.js
var require_util = __commonJS({
"lib/core/util.js"(exports2, module2) {
"use strict";
var assert = require("node:assert");
var { kDestroyed, kBodyUsed } = require_symbols();
var { IncomingMessage } = require("node:http");
var stream = require("node:stream");
var net = require("node:net");
var { InvalidArgumentError } = require_errors();
var { Blob: Blob2 } = require("node:buffer");
var nodeUtil = require("node:util");
var { stringify } = require("node:querystring");
var { headerNameLowerCasedRecord } = require_constants();
var { tree } = require_tree();
var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v));
function nop() {
}
__name(nop, "nop");
function isStream(obj) {
return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function";
}
__name(isStream, "isStream");
function isBlobLike(object) {
return Blob2 && object instanceof Blob2 || object && typeof object === "object" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]);
}
__name(isBlobLike, "isBlobLike");
function buildURL(url, queryParams) {
if (url.includes("?") || url.includes("#")) {
throw new Error('Query params cannot be passed when url already contains "?" or "#".');
}
const stringified = stringify(queryParams);
if (stringified) {
url += "?" + stringified;
}
return url;
}
__name(buildURL, "buildURL");
function parseURL(url) {
if (typeof url === "string") {
url = new URL(url);
if (!/^https?:/.test(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 (!/^https?:/.test(url.origin || url.protocol)) {
throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
}
if (!(url instanceof URL)) {
if (url.port != null && url.port !== "" && !Number.isFinite(parseInt(url.port))) {
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.");
}
const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
let origin = url.origin != null ? url.origin : `${url.protocol}//${url.hostname}:${port}`;
let path = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
if (origin.endsWith("/")) {
origin = origin.substring(0, origin.length - 1);
}
if (path && !path.startsWith("/")) {
path = `/${path}`;
}
url = new URL(origin + path);
}
return url;
}
__name(parseURL, "parseURL");
function parseOrigin(url) {
url = parseURL(url);
if (url.pathname !== "/" || url.search || url.hash) {
throw new InvalidArgumentError("invalid url");
}
return url;
}
__name(parseOrigin, "parseOrigin");
function getHostname(host) {
if (host[0] === "[") {
const idx2 = host.indexOf("]");
assert(idx2 !== -1);
return host.substring(1, idx2);
}
const idx = host.indexOf(":");
if (idx === -1)
return host;
return host.substring(0, idx);
}
__name(getHostname, "getHostname");
function getServerName(host) {
if (!host) {
return null;
}
assert.strictEqual(typeof host, "string");
const servername = getHostname(host);
if (net.isIP(servername)) {
return "";
}
return servername;
}
__name(getServerName, "getServerName");
function deepClone(obj) {
return JSON.parse(JSON.stringify(obj));
}
__name(deepClone, "deepClone");
function isAsyncIterable(obj) {
return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function");
}
__name(isAsyncIterable, "isAsyncIterable");
function isIterable(obj) {
return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function"));
}
__name(isIterable, "isIterable");
function bodyLength(body) {
if (body == null) {
return 0;
} else if (isStream(body)) {
const state = body._readableState;
return state && state.objectMode === false && state.ended === true && 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;
}
__name(bodyLength, "bodyLength");
function isDestroyed(stream2) {
return !stream2 || !!(stream2.destroyed || stream2[kDestroyed]);
}
__name(isDestroyed, "isDestroyed");
function isReadableAborted(stream2) {
const state = stream2?._readableState;
return isDestroyed(stream2) && state && !state.endEmitted;
}
__name(isReadableAborted, "isReadableAborted");
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) {
process.nextTick((stream3, err2) => {
stream3.emit("error", err2);
}, stream2, err);
}
if (stream2.destroyed !== true) {
stream2[kDestroyed] = true;
}
}
__name(destroy, "destroy");
var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/;
function parseKeepAliveTimeout(val) {
const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR);
return m ? parseInt(m[1], 10) * 1e3 : null;
}
__name(parseKeepAliveTimeout, "parseKeepAliveTimeout");
function headerNameToString(value) {
return typeof value === "string" ? headerNameLowerCasedRecord[value] ?? value.toLowerCase() : tree.lookup(value) ?? value.toString("latin1").toLowerCase();
}
__name(headerNameToString, "headerNameToString");
function bufferToLowerCasedHeaderName(value) {
return tree.lookup(value) ?? value.toString("latin1").toLowerCase();
}
__name(bufferToLowerCasedHeaderName, "bufferToLowerCasedHeaderName");
function parseHeaders(headers, obj) {
if (!Array.isArray(headers))
return headers;
if (obj === void 0)
obj = {};
for (let i = 0; i < headers.length; i += 2) {
const key = headerNameToString(headers[i]);
let val = obj[key];
if (val) {
if (typeof val === "string") {
val = [val];
obj[key] = val;
}
val.push(headers[i + 1].toString("utf8"));
} else {
const 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;
}
__name(parseHeaders, "parseHeaders");
function parseRawHeaders(headers) {
const ret = [];
let hasContentLength = false;
let contentDispositionIdx = -1;
for (let n = 0; n < headers.length; n += 2) {
const key = headers[n + 0].toString();
const val = headers[n + 1].toString("utf8");
if (key.length === 14 && (key === "content-length" || key.toLowerCase() === "content-length")) {
ret.push(key, val);
hasContentLength = true;
} else if (key.length === 19 && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) {
contentDispositionIdx = ret.push(key, val) - 1;
} else {
ret.push(key, val);
}
}
if (hasContentLength && contentDispositionIdx !== -1) {
ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1");
}
return ret;
}
__name(parseRawHeaders, "parseRawHeaders");
function isBuffer(buffer) {
return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
}
__name(isBuffer, "isBuffer");
function validateHandler(handler, method, upgrade) {
if (!handler || typeof handler !== "object") {
throw new InvalidArgumentError("handler must be an object");
}
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");
}
}
}
__name(validateHandler, "validateHandler");
function isDisturbed(body) {
return !!(body && (stream.isDisturbed(body) || body[kBodyUsed]));
}
__name(isDisturbed, "isDisturbed");
function isErrored(body) {
return !!(body && stream.isErrored(body));
}
__name(isErrored, "isErrored");
function isReadable(body) {
return !!(body && stream.isReadable(body));
}
__name(isReadable, "isReadable");
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
};
}
__name(getSocketInfo, "getSocketInfo");
function ReadableStreamFrom(iterable) {
let iterator;
return new ReadableStream(
{
async start() {
iterator = iterable[Symbol.asyncIterator]();
},
async pull(controller) {
const { done, value } = await iterator.next();
if (done) {
queueMicrotask(() => {
controller.close();
controller.byobRequest?.respond(0);
});
} else {
const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
if (buf.byteLength) {
controller.enqueue(new Uint8Array(buf));
}
}
return controller.desiredSize > 0;
},
async cancel(reason) {
await iterator.return();
},
type: "bytes"
}
);
}
__name(ReadableStreamFrom, "ReadableStreamFrom");
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";
}
__name(isFormDataLike, "isFormDataLike");
function addAbortListener(signal, listener) {
if ("addEventListener" in signal) {
signal.addEventListener("abort", listener, { once: true });
return () => signal.removeEventListener("abort", listener);
}
signal.addListener("abort", listener);
return () => signal.removeListener("abort", listener);
}
__name(addAbortListener, "addAbortListener");
var hasToWellFormed = !!String.prototype.toWellFormed;
function toUSVString(val) {
if (hasToWellFormed) {
return `${val}`.toWellFormed();
} else if (nodeUtil.toUSVString) {
return nodeUtil.toUSVString(val);
}
return `${val}`;
}
__name(toUSVString, "toUSVString");
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 false;
default:
return c >= 33 && c <= 126;
}
}
__name(isTokenCharCode, "isTokenCharCode");
function isValidHTTPToken(characters) {
if (characters.length === 0) {
return false;
}
for (let i = 0; i < characters.length; ++i) {
if (!isTokenCharCode(characters.charCodeAt(i))) {
return false;
}
}
return true;
}
__name(isValidHTTPToken, "isValidHTTPToken");
function parseRangeHeader(range) {
if (range == null || range === "")
return { start: 0, end: null, size: null };
const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null;
return m ? {
start: parseInt(m[1]),
end: m[2] ? parseInt(m[2]) : null,
size: m[3] ? parseInt(m[3]) : null
} : null;
}
__name(parseRangeHeader, "parseRangeHeader");
var kEnumerableProperty = /* @__PURE__ */ Object.create(null);
kEnumerableProperty.enumerable = true;
module2.exports = {
kEnumerableProperty,
nop,
isDisturbed,
isErrored,
isReadable,
toUSVString,
isReadableAborted,
isBlobLike,
parseOrigin,
parseURL,
getServerName,
isStream,
isIterable,
isAsyncIterable,
isDestroyed,
headerNameToString,
bufferToLowerCasedHeaderName,
parseRawHeaders,
parseHeaders,
parseKeepAliveTimeout,
destroy,
bodyLength,
deepClone,
ReadableStreamFrom,
isBuffer,
validateHandler,
getSocketInfo,
isFormDataLike,
buildURL,
addAbortListener,
isValidHTTPToken,
isTokenCharCode,
parseRangeHeader,
nodeMajor,
nodeMinor,
nodeHasAutoSelectFamily: nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 13,
safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"]
};
}
});
// lib/fetch/constants.js
var require_constants2 = __commonJS({
"lib/fetch/constants.js"(exports2, module2) {
"use strict";
var corsSafeListedMethods = ["GET", "HEAD", "POST"];
var corsSafeListedMethodsSet = new Set(corsSafeListedMethods);
var nullBodyStatus = [101, 204, 205, 304];
var redirectStatus = [301, 302, 303, 307, 308];
var redirectStatusSet = new Set(redirectStatus);
var 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",
"5060",
"5061",
"6000",
"6566",
"6665",
"6666",
"6667",
"6668",
"6669",
"6697",
"10080"
];
var badPortsSet = new Set(badPorts);
var referrerPolicy = [
"",
"no-referrer",
"no-referrer-when-downgrade",
"same-origin",
"origin",
"strict-origin",
"origin-when-cross-origin",
"strict-origin-when-cross-origin",
"unsafe-url"
];
var referrerPolicySet = new Set(referrerPolicy);
var requestRedirect = ["follow", "manual", "error"];
var safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"];
var safeMethodsSet = new Set(safeMethods);
var requestMode = ["navigate", "same-origin", "no-cors", "cors"];
var requestCredentials = ["omit", "same-origin", "include"];
var requestCache = [
"default",
"no-store",
"reload",
"no-cache",
"force-cache",
"only-if-cached"
];
var requestBodyHeader = [
"content-encoding",
"content-language",
"content-location",
"content-type",
// See https://github.com/nodejs/undici/issues/2021
// 'Content-Length' is a forbidden header name, which is typically
// removed in the Headers implementation. However, undici doesn't
// filter out headers, so we add it here.
"content-length"
];
var requestDuplex = [
"half"
];
var forbiddenMethods = ["CONNECT", "TRACE", "TRACK"];
var forbiddenMethodsSet = new Set(forbiddenMethods);
var subresource = [
"audio",
"audioworklet",
"font",
"image",
"manifest",
"paintworklet",
"script",
"style",
"track",
"video",
"xslt",
""
];
var subresourceSet = new Set(subresource);
module2.exports = {
subresource,
forbiddenMethods,
requestBodyHeader,
referrerPolicy,
requestRedirect,
requestMode,
requestCredentials,
requestCache,
redirectStatus,
corsSafeListedMethods,
nullBodyStatus,
safeMethods,
badPorts,
requestDuplex,
subresourceSet,
badPortsSet,
redirectStatusSet,
corsSafeListedMethodsSet,
safeMethodsSet,
forbiddenMethodsSet,
referrerPolicySet
};
}
});
// lib/fetch/global.js
var require_global = __commonJS({
"lib/fetch/global.js"(exports2, module2) {
"use strict";
var globalOrigin = Symbol.for("undici.globalOrigin.1");
function getGlobalOrigin() {
return globalThis[globalOrigin];
}
__name(getGlobalOrigin, "getGlobalOrigin");
function setGlobalOrigin(newOrigin) {
if (newOrigin === void 0) {
Object.defineProperty(globalThis, globalOrigin, {
value: void 0,
writable: true,
enumerable: false,
configurable: false
});
return;
}
const 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: true,
enumerable: false,
configurable: false
});
}
__name(setGlobalOrigin, "setGlobalOrigin");
module2.exports = {
getGlobalOrigin,
setGlobalOrigin
};
}
});
// lib/fetch/dataURL.js
var require_dataURL = __commonJS({
"lib/fetch/dataURL.js"(exports2, module2) {
var assert = require("node:assert");
var encoder = new TextEncoder();
var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-Za-z0-9]+$/;
var HTTP_WHITESPACE_REGEX = /[\u000A|\u000D|\u0009|\u0020]/;
var ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g;
var HTTP_QUOTED_STRING_TOKENS = /[\u0009|\u0020-\u007E|\u0080-\u00FF]/;
function dataURLProcessor(dataURL) {
assert(dataURL.protocol === "data:");
let input = URLSerializer(dataURL, true);
input = input.slice(5);
const position = { position: 0 };
let mimeType = collectASequenceOfCodePointsFast(
",",
input,
position
);
const mimeTypeLength = mimeType.length;
mimeType = removeASCIIWhitespace(mimeType, true, true);
if (position.position >= input.length) {
return "failure";
}
position.position++;
const encodedBody = input.slice(mimeTypeLength + 1);
let body = stringPercentDecode(encodedBody);
if (/;(\u0020){0,}base64$/i.test(mimeType)) {
const stringBody = isomorphicDecode(body);
body = forgivingBase64(stringBody);
if (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 };
}
__name(dataURLProcessor, "dataURLProcessor");
function URLSerializer(url, excludeFragment = false) {
if (!excludeFragment) {
return url.href;
}
const href = url.href;
const hashLength = url.hash.length;
const serialized = hashLength === 0 ? href : href.substring(0, href.length - hashLength);
if (!hashLength && href.endsWith("#")) {
return serialized.slice(0, -1);
}
return serialized;
}
__name(URLSerializer, "URLSerializer");
function collectASequenceOfCodePoints(condition, input, position) {
let result = "";
while (position.position < input.length && condition(input[position.position])) {
result += input[position.position];
position.position++;
}
return result;
}
__name(collectASequenceOfCodePoints, "collectASequenceOfCodePoints");
function collectASequenceOfCodePointsFast(char, input, position) {
const idx = input.indexOf(char, position.position);
const start = position.position;
if (idx === -1) {
position.position = input.length;
return input.slice(start);
}
position.position = idx;
return input.slice(start, position.position);
}
__name(collectASequenceOfCodePointsFast, "collectASequenceOfCodePointsFast");
function stringPercentDecode(input) {
const bytes = encoder.encode(input);
return percentDecode(bytes);
}
__name(stringPercentDecode, "stringPercentDecode");
function isHexCharByte(byte) {
return byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102;
}
__name(isHexCharByte, "isHexCharByte");
function hexByteToNumber(byte) {
return (
// 0-9
byte >= 48 && byte <= 57 ? byte - 48 : (byte & 223) - 55
);
}
__name(hexByteToNumber, "hexByteToNumber");
function percentDecode(input) {
const length = input.length;
const output = new Uint8Array(length);
let j = 0;
for (let i = 0; i < length; ++i) {
const 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);
}
__name(percentDecode, "percentDecode");
function parseMIMEType(input) {
input = removeHTTPWhitespace(input, true, true);
const position = { position: 0 };
const 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
);
subtype = removeHTTPWhitespace(subtype, false, true);
if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
return "failure";
}
const typeLowercase = type.toLowerCase();
const subtypeLowercase = subtype.toLowerCase();
const mimeType = {
type: typeLowercase,
subtype: subtypeLowercase,
/** @type {Map<string, string>} */
parameters: /* @__PURE__ */ new Map(),
// https://mimesniff.spec.whatwg.org/#mime-type-essence
essence: `${typeLowercase}/${subtypeLowercase}`
};
while (position.position < input.length) {
position.position++;
collectASequenceOfCodePoints(
// https://fetch.spec.whatwg.org/#http-whitespace
(char) => HTTP_WHITESPACE_REGEX.test(char),
input,
position
);
let parameterName = collectASequenceOfCodePoints(
(char) => char !== ";" && char !== "=",
input,
position
);
parameterName = parameterName.toLowerCase();
if (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, true);
collectASequenceOfCodePointsFast(
";",
input,
position
);
} else {
parameterValue = collectASequenceOfCodePointsFast(
";",
input,
position
);
parameterValue = removeHTTPWhitespace(parameterValue, false, true);
if (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;
}
__name(parseMIMEType, "parseMIMEType");
function forgivingBase64(data) {
data = data.replace(ASCII_WHITESPACE_REPLACE_REGEX, "");
let dataLength = data.length;
if (dataLength % 4 === 0) {
if (data.charCodeAt(dataLength - 1) === 61) {
--dataLength;
if (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";
}
const buffer = Buffer.from(data, "base64");
return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
}
__name(forgivingBase64, "forgivingBase64");
function collectAnHTTPQuotedString(input, position, extractValue) {
const positionStart = position.position;
let value = "";
assert(input[position.position] === '"');
position.position++;
while (true) {
value += collectASequenceOfCodePoints(
(char) => char !== '"' && char !== "\\",
input,
position
);
if (position.position >= input.length) {
break;
}
const quoteOrBackslash = input[position.position];
position.position++;
if (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);
}
__name(collectAnHTTPQuotedString, "collectAnHTTPQuotedString");
function serializeAMimeType(mimeType) {
assert(mimeType !== "failure");
const { parameters, essence } = mimeType;
let serialization = essence;
for (let [name, value] of parameters.entries()) {
serialization += ";";
serialization += name;
serialization += "=";
if (!HTTP_TOKEN_CODEPOINTS.test(value)) {
value = value.replace(/(\\|")/g, "\\$1");
value = '"' + value;
value += '"';
}
serialization += value;
}
return serialization;
}
__name(serializeAMimeType, "serializeAMimeType");
function isHTTPWhiteSpace(char) {
return char === 13 || char === 10 || char === 9 || char === 32;
}
__name(isHTTPWhiteSpace, "isHTTPWhiteSpace");
function removeHTTPWhitespace(str, leading = true, trailing = true) {
return removeChars(str, leading, trailing, isHTTPWhiteSpace);
}
__name(removeHTTPWhitespace, "removeHTTPWhitespace");
function isASCIIWhitespace(char) {
return char === 13 || char === 10 || char === 9 || char === 12 || char === 32;
}
__name(isASCIIWhitespace, "isASCIIWhitespace");
function removeASCIIWhitespace(str, leading = true, trailing = true) {
return removeChars(str, leading, trailing, isASCIIWhitespace);
}
__name(removeASCIIWhitespace, "removeASCIIWhitespace");
function removeChars(str, leading, trailing, predicate) {
let lead = 0;
let 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);
}
__name(removeChars, "removeChars");
function isomorphicDecode(input) {
const length = input.length;
if ((2 << 15) - 1 > length) {
return String.fromCharCode.apply(null, input);
}
let result = "";
let i = 0;
let addition = (2 << 15) - 1;
while (i < length) {
if (i + addition > length) {
addition = length - i;
}
result += String.fromCharCode.apply(null, input.subarray(i, i += addition));
}
return result;
}
__name(isomorphicDecode, "isomorphicDecode");
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 "";
}
__name(minimizeSupportedMimeType, "minimizeSupportedMimeType");
module2.exports = {
dataURLProcessor,
URLSerializer,
collectASequenceOfCodePoints,
collectASequenceOfCodePointsFast,
stringPercentDecode,
parseMIMEType,
collectAnHTTPQuotedString,
serializeAMimeType,
removeChars,
minimizeSupportedMimeType
};
}
});
// lib/fetch/util.js
var require_util2 = __commonJS({
"lib/fetch/util.js"(exports2, module2) {
"use strict";
var { Transform } = require("node:stream");
var zlib = require("node:zlib");
var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants2();
var { getGlobalOrigin } = require_global();
var { collectASequenceOfCodePoints, collectAnHTTPQuotedString, removeChars, parseMIMEType } = require_dataURL();
var { performance: performance2 } = require("node:perf_hooks");
var { isBlobLike, toUSVString, ReadableStreamFrom, isValidHTTPToken } = require_util();
var assert = require("node:assert");
var { isUint8Array } = require("util/types");
var crypto;
try {
crypto = require("node:crypto");
} catch {
}
function responseURL(response) {
const urlList = response.urlList;
const length = urlList.length;
return length === 0 ? null : urlList[length - 1].toString();
}
__name(responseURL, "responseURL");
function responseLocationURL(response, requestFragment) {
if (!redirectStatusSet.has(response.status)) {
return null;
}
let location = response.headersList.get("location", true);
if (location !== null && isValidHeaderValue(location)) {
location = new URL(location, responseURL(response));
}
if (location && !location.hash) {
location.hash = requestFragment;
}
return location;
}
__name(responseLocationURL, "responseLocationURL");
function requestCurrentURL(request) {
return request.urlList[request.urlList.length - 1];
}
__name(requestCurrentURL, "requestCurrentURL");
function requestBadPort(request) {
const url = requestCurrentURL(request);
if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) {
return "blocked";
}
return "allowed";
}
__name(requestBadPort, "requestBadPort");
function isErrorLike(object) {
return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException");
}
__name(isErrorLike, "isErrorLike");
function isValidReasonPhrase(statusText) {
for (let i = 0; i < statusText.length; ++i) {
const c = statusText.charCodeAt(i);
if (!(c === 9 || // HTAB
c >= 32 && c <= 126 || // SP / VCHAR
c >= 128 && c <= 255)) {
return false;
}
}
return true;
}
__name(isValidReasonPhrase, "isValidReasonPhrase");
function isValidHeaderName(potentialValue) {
return isValidHTTPToken(potentialValue);
}
__name(isValidHeaderName, "isValidHeaderName");
function isValidHeaderValue(potentialValue) {
if (potentialValue.startsWith(" ") || potentialValue.startsWith(" ") || potentialValue.endsWith(" ") || potentialValue.endsWith(" ")) {
return false;
}
if (potentialValue.includes("\0") || potentialValue.includes("\r") || potentialValue.includes("\n")) {
return false;
}
return true;
}
__name(isValidHeaderValue, "isValidHeaderValue");
function setRequestReferrerPolicyOnRedirect(request, actualResponse) {
const { headersList } = actualResponse;
const policyHeader = (headersList.get("referrer-policy", true) ?? "").split(",");
let policy = "";
if (policyHeader.length > 0) {
for (let i = policyHeader.length; i !== 0; i--) {
const token = policyHeader[i - 1].trim();
if (referrerPolicyTokens.has(token)) {
policy = token;
break;
}
}
}
if (policy !== "") {
request.referrerPolicy = policy;
}
}
__name(setRequestReferrerPolicyOnRedirect, "setRequestReferrerPolicyOnRedirect");
function crossOriginResourcePolicyCheck() {
return "allowed";
}
__name(crossOriginResourcePolicyCheck, "crossOriginResourcePolicyCheck");
function corsCheck() {
return "success";
}
__name(corsCheck, "corsCheck");
function TAOCheck() {
return "success";
}
__name(TAOCheck, "TAOCheck");
function appendFetchMetadata(httpRequest) {
let header = null;
header = httpRequest.mode;
httpRequest.headersList.set("sec-fetch-mode", header, true);
}
__name(appendFetchMetadata, "appendFetchMetadata");
function appendRequestOriginHeader(request) {
let serializedOrigin = request.origin;
if (request.responseTainting === "cors" || request.mode === "websocket") {
if (serializedOrigin) {
request.headersList.append("origin", serializedOrigin, true);
}
} 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:
}
if (serializedOrigin) {
request.headersList.append("origin", serializedOrigin, true);
}
}
}
__name(appendRequestOriginHeader, "appendRequestOriginHeader");
function coarsenTime(timestamp, crossOriginIsolatedCapability) {
return timestamp;
}
__name(coarsenTime, "coarsenTime");
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
};
}
__name(clampAndCoarsenConnectionTimingInfo, "clampAndCoarsenConnectionTimingInfo");
function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
return coarsenTime(performance2.now(), crossOriginIsolatedCapability);
}
__name(coarsenedSharedCurrentTime, "coarsenedSharedCurrentTime");
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
};
}
__name(createOpaqueTimingInfo, "createOpaqueTimingInfo");
function makePolicyContainer() {
return {
referrerPolicy: "strict-origin-when-cross-origin"
};
}
__name(makePolicyContainer, "makePolicyContainer");
function clonePolicyContainer(policyContainer) {
return {
referrerPolicy: policyContainer.referrerPolicy
};
}
__name(clonePolicyContainer, "clonePolicyContainer");
function determineRequestsReferrer(request) {
const policy = request.referrerPolicy;
assert(policy);
let referrerSource = null;
if (request.referrer === "client") {
const globalOrigin = getGlobalOrigin();
if (!globalOrigin || globalOrigin.origin === "null") {
return "no-referrer";
}
referrerSource = new URL(globalOrigin);
} else if (request.referrer instanceof URL) {
referrerSource = request.referrer;
}
let referrerURL = stripURLForReferrer(referrerSource);
const referrerOrigin = stripURLForReferrer(referrerSource, true);
if (referrerURL.toString().length > 4096) {
referrerURL = referrerOrigin;
}
const areSameOrigin = sameOrigin(request, referrerURL);
const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request.url);
switch (policy) {
case "origin":
return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true);
case "unsafe-url":
return referrerURL;
case "same-origin":
return areSameOrigin ? referrerOrigin : "no-referrer";
case "origin-when-cross-origin":
return areSameOrigin ? referrerURL : referrerOrigin;
case "strict-origin-when-cross-origin": {
const currentURL = requestCurrentURL(request);
if (sameOrigin(referrerURL, currentURL)) {
return referrerURL;
}
if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
return "no-referrer";
}
return referrerOrigin;
}
case "strict-origin":
case "no-referrer-when-downgrade":
default:
return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin;
}
}
__name(determineRequestsReferrer, "determineRequestsReferrer");
function stripURLForReferrer(url, originOnly) {
assert(url instanceof URL);
if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") {
return "no-referrer";
}
url.username = "";
url.password = "";
url.hash = "";
if (originOnly) {
url.pathname = "";
url.search = "";
}
return url;
}
__name(stripURLForReferrer, "stripURLForReferrer");
function isURLPotentiallyTrustworthy(url) {
if (!(url instanceof URL)) {
return false;
}
if (url.href === "about:blank" || url.href === "about:srcdoc") {
return true;
}
if (url.protocol === "data:")
return true;
if (url.protocol === "file:")
return true;
return isOriginPotentiallyTrustworthy(url.origin);
function isOriginPotentiallyTrustworthy(origin) {
if (origin == null || origin === "null")
return false;
const originAsURL = new URL(origin);
if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") {
return true;
}
if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) {
return true;
}
return false;
}
__name(isOriginPotentiallyTrustworthy, "isOriginPotentiallyTrustworthy");
}
__name(isURLPotentiallyTrustworthy, "isURLPotentiallyTrustworthy");
function bytesMatch(bytes, metadataList) {
if (crypto === void 0) {
return true;
}
const parsedMetadata = parseMetadata(metadataList);
if (parsedMetadata === "no metadata") {
return true;
}
if (parsedMetadata.length === 0) {
return true;
}
const list = parsedMetadata.sort((c, d) => d.algo.localeCompare(c.algo));
const strongest = list[0].algo;
const metadata = list.filter((item) => item.algo === strongest);
for (const item of metadata) {
const algorithm = item.algo;
let expectedValue = item.hash;
if (expectedValue.endsWith("==")) {
expectedValue = expectedValue.slice(0, -2);
}
let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64");
if (actualValue.endsWith("==")) {
actualValue = actualValue.slice(0, -2);
}
if (actualValue === expectedValue) {
return true;
}
let actualBase64URL = crypto.createHash(algorithm).update(bytes).digest("base64url");
if (actualBase64URL.endsWith("==")) {
actualBase64URL = actualBase64URL.slice(0, -2);
}
if (actualBase64URL === expectedValue) {
return true;
}
}
return false;
}
__name(bytesMatch, "bytesMatch");
var parseHashWithOptions = /(?<algo>sha256|sha384|sha512)-(?<hash>[A-Za-z0-9+/]+={0,2}(?=\s|$))( +[!-~]*)?/i;
function parseMetadata(metadata) {
const result = [];
let empty = true;
const supportedHashes = crypto.getHashes();
for (const token of metadata.split(" ")) {
empty = false;
const parsedToken = parseHashWithOptions.exec(token);
if (parsedToken === null || parsedToken.groups === void 0) {
continue;
}
const algorithm = parsedToken.groups.algo;
if (supportedHashes.includes(algorithm.toLowerCase())) {
result.push(parsedToken.groups);
}
}
if (empty === true) {
return "no metadata";
}
return result;
}
__name(parseMetadata, "parseMetadata");
function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) {
}
__name(tryUpgradeRequestToAPotentiallyTrustworthyURL, "tryUpgradeRequestToAPotentiallyTrustworthyURL");
function sameOrigin(A, B) {
if (A.origin === B.origin && A.origin === "null") {
return true;
}
if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) {
return true;
}
return false;
}
__name(sameOrigin, "sameOrigin");
function createDeferredPromise() {
let res;
let rej;
const promise = new Promise((resolve, reject) => {
res = resolve;
rej = reject;
});
return { promise, resolve: res, reject: rej };
}
__name(createDeferredPromise, "createDeferredPromise");
function isAborted(fetchParams) {
return fetchParams.controller.state === "aborted";
}
__name(isAborted, "isAborted");
function isCancelled(fetchParams) {
return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated";
}
__name(isCancelled, "isCancelled");
var normalizeMethodRecordBase = {
delete: "DELETE",
DELETE: "DELETE",
get: "GET",
GET: "GET",
head: "HEAD",
HEAD: "HEAD",
options: "OPTIONS",
OPTIONS: "OPTIONS",
post: "POST",
POST: "POST",
put: "PUT",
PUT: "PUT"
};
var normalizeMethodRecord = {
...normalizeMethodRecordBase,
patch: "patch",
PATCH: "PATCH"
};
Object.setPrototypeOf(normalizeMethodRecordBase, null);
Object.setPrototypeOf(normalizeMethodRecord, null);
function normalizeMethod(method) {
return normalizeMethodRecordBase[method.toLowerCase()] ?? method;
}
__name(normalizeMethod, "normalizeMethod");
function serializeJavascriptValueToJSONString(value) {
const result = JSON.stringify(value);
if (result === void 0) {
throw new TypeError("Value is not JSON serializable");
}
assert(typeof result === "string");
return result;
}
__name(serializeJavascriptValueToJSONString, "serializeJavascriptValueToJSONString");
var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
function makeIterator(iterator, name, kind, keyIndex = 0, valueIndex = 1) {
const object = {
index: 0,
kind,
target: iterator
};
const iteratorObject = Object.create(esIteratorPrototype);
Object.defineProperty(iteratorObject, "next", {
value: /* @__PURE__ */ __name(function next() {
if (Object.getPrototypeOf(this) !== iteratorObject) {
throw new TypeError(
`'next' called on an object that does not implement interface ${name} Iterator.`
);
}
const { index, kind: kind2, target } = object;
const values = target();
const len = values.length;
if (index >= len) {
return { value: void 0, done: true };
}
const { [keyIndex]: key, [valueIndex]: value } = values[index];
object.index = index + 1;
let result;
switch (kind2) {
case "key":
result = key;
break;
case "value":
result = value;
break;
case "key+value":
result = [key, value];
break;
}
return {
value: result,
done: false
};
}, "next"),
writable: true,
enumerable: true,
configurable: true
});
Object.defineProperty(iteratorObject, Symbol.toStringTag, {
value: `${name} Iterator`,
writable: false,
enumerable: false,
configurable: true
});
return Object.create(iteratorObject);
}
__name(makeIterator, "makeIterator");
async function fullyReadBody(body, processBody, processBodyError) {
const successSteps = processBody;
const errorSteps = processBodyError;
let reader;
try {
reader = body.stream.getReader();
} catch (e) {
errorSteps(e);
return;
}
try {
const result = await readAllBytes(reader);
successSteps(result);
} catch (e) {
errorSteps(e);
}
}
__name(fullyReadBody, "fullyReadBody");
function isReadableStreamLike(stream) {
return stream instanceof ReadableStream || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function";
}
__name(isReadableStreamLike, "isReadableStreamLike");
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;
}
}
}
__name(readableStreamClose, "readableStreamClose");
function isomorphicEncode(input) {
for (let i = 0; i < input.length; i++) {
assert(input.charCodeAt(i) <= 255);
}
return input;
}
__name(isomorphicEncode, "isomorphicEncode");
async function readAllBytes(reader) {
const bytes = [];
let byteLength = 0;
while (true) {
const { done, value: chunk } = await reader.read();
if (done) {
return Buffer.concat(bytes, byteLength);
}
if (!isUint8Array(chunk)) {
throw new TypeError("Received non-Uint8Array chunk");
}
bytes.push(chunk);
byteLength += chunk.length;
}
}
__name(readAllBytes, "readAllBytes");
function urlIsLocal(url) {
assert("protocol" in url);
const protocol = url.protocol;
return protocol === "about:" || protocol === "blob:" || protocol === "data:";
}
__name(urlIsLocal, "urlIsLocal");
function urlHasHttpsScheme(url) {
if (typeof url === "string") {
return url.startsWith("https:");
}
return url.protocol === "https:";
}
__name(urlHasHttpsScheme, "urlHasHttpsScheme");
function urlIsHttpHttpsScheme(url) {
assert("protocol" in url);
const protocol = url.protocol;
return protocol === "http:" || protocol === "https:";
}
__name(urlIsHttpHttpsScheme, "urlIsHttpHttpsScheme");
function simpleRangeHeaderValue(value, allowWhitespace) {
const data = value;
if (!data.startsWith("bytes")) {
return "failure";
}
const position = { position: 5 };
if (allowWhitespace) {
collectASequenceOfCodePoints(
(char) => char === " " || char === " ",
data,
position
);
}
if (data.charCodeAt(position.position) !== 61) {
return "failure";
}
position.position++;
if (allowWhitespace) {
collectASequenceOfCodePoints(
(char) => char === " " || char === " ",
data,
position
);
}
const rangeStart = collectASequenceOfCodePoints(
(char) => {
const code = char.charCodeAt(0);
return code >= 48 && code <= 57;
},
data,
position
);
const rangeStartValue = rangeStart.length ? Number(rangeStart) : null;
if (allowWhitespace) {
collectASequenceOfCodePoints(
(char) => char === " " || char === " ",
data,
position
);
}
if (data.charCodeAt(position.position) !== 45) {
return "failure";
}
position.position++;
if (allowWhitespace) {
collectASequenceOfCodePoints(
(char) => char === " " || char === " ",
data,
position
);
}
const rangeEnd = collectASequenceOfCodePoints(
(char) => {
const code = char.charCodeAt(0);
return code >= 48 && code <= 57;
},
data,
position
);
const 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 };
}
__name(simpleRangeHeaderValue, "simpleRangeHeaderValue");
function buildContentRange(rangeStart, rangeEnd, fullLength) {
let contentRange = "bytes ";
contentRange += isomorphicEncode(`${rangeStart}`);
contentRange += "-";
contentRange += isomorphicEncode(`${rangeEnd}`);
contentRange += "/";
contentRange += isomorphicEncode(`${fullLength}`);
return contentRange;
}
__name(buildContentRange, "buildContentRange");
var InflateStream = class extends Transform {
static {
__name(this, "InflateStream");
}
_transform(chunk, encoding, callback) {
if (!this._inflateStream) {
if (chunk.length === 0) {
callback();
return;
}
this._inflateStream = (chunk[0] & 15) === 8 ? zlib.createInflate() : zlib.createInflateRaw();
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() {
return new InflateStream();
}
__name(createInflate, "createInflate");
function extractMimeType(headers) {
let charset = null;
let essence = null;
let mimeType = null;
const values = getDecodeSplit("content-type", headers);
if (values === null) {
return "failure";
}
for (const value of values) {
const temporaryMimeType = parseMIMEType(value);
if (temporaryMimeType === "failure" || temporaryMimeType.essence === "*/*") {
continue;
}
mimeType = temporaryMimeType;
if (mimeType.essence !== essence) {
charset = null;
if (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;
}
__name(extractMimeType, "extractMimeType");
function gettingDecodingSplitting(value) {
const input = value;
const position = { position: 0 };
const values = [];
let temporaryValue = "";
while (position.position < input.length) {
temporaryValue += collectASequenceOfCodePoints(
(char) => char !== '"' && char !== ",",
input,
position
);
if (position.position < input.length) {
if (input.charCodeAt(position.position) === 34) {
temporaryValue += collectAnHTTPQuotedString(
input,
position
);
if (position.position < input.length) {
continue;
}
} else {
assert(input.charCodeAt(position.position) === 44);
position.position++;
}
}
temporaryValue = removeChars(temporaryValue, true, true, (char) => char === 9 || char === 32);
values.push(temporaryValue);
temporaryValue = "";
}
return values;
}
__name(gettingDecodingSplitting, "gettingDecodingSplitting");
function getDecodeSplit(name, list) {
const value = list.get(name, true);
if (value === null) {
return null;
}
return gettingDecodingSplitting(value);
}
__name(getDecodeSplit, "getDecodeSplit");
module2.exports = {
isAborted,
isCancelled,
createDeferredPromise,
ReadableStreamFrom,
toUSVString,
tryUpgradeRequestToAPotentiallyTrustworthyURL,
clampAndCoarsenConnectionTimingInfo,
coarsenedSharedCurrentTime,
determineRequestsReferrer,
makePolicyContainer,
clonePolicyContainer,
appendFetchMetadata,
appendRequestOriginHeader,
TAOCheck,
corsCheck,
crossOriginResourcePolicyCheck,
createOpaqueTimingInfo,
setRequestReferrerPolicyOnRedirect,
isValidHTTPToken,
requestBadPort,
requestCurrentURL,
responseURL,
responseLocationURL,
isBlobLike,
isURLPotentiallyTrustworthy,
isValidReasonPhrase,
sameOrigin,
normalizeMethod,
serializeJavascriptValueToJSONString,
makeIterator,
isValidHeaderName,
isValidHeaderValue,
isErrorLike,
fullyReadBody,
bytesMatch,
isReadableStreamLike,
readableStreamClose,
isomorphicEncode,
urlIsLocal,
urlHasHttpsScheme,
urlIsHttpHttpsScheme,
readAllBytes,
normalizeMethodRecord,
simpleRangeHeaderValue,
buildContentRange,
parseMetadata,
createInflate,
extractMimeType
};
}
});
// lib/fetch/webidl.js
var require_webidl = __commonJS({
"lib/fetch/webidl.js"(exports2, module2) {
"use strict";
var { types } = require("node:util");
var { toUSVString } = require_util2();
var webidl = {};
webidl.converters = {};
webidl.util = {};
webidl.errors = {};
webidl.errors.exception = function(message) {
return new TypeError(`${message.header}: ${message.message}`);
};
webidl.errors.conversionFailed = function(context) {
const plural = context.types.length === 1 ? "" : " one of";
const 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, opts = void 0) {
if (opts?.strict !== false) {
if (!(V instanceof I)) {
throw new TypeError("Illegal invocation");
}
} else {
if (V?.[Symbol.toStringTag] !== I.prototype[Symbol.toStringTag]) {
throw new TypeError("Illegal invocation");
}
}
};
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.`,
...ctx
});
}
};
webidl.illegalConstructor = function() {
throw webidl.errors.exception({
header: "TypeError",
message: "Illegal constructor"
});
};
webidl.util.Type = function(V) {
switch (typeof V) {
case "undefined":
return "Undefined";
case "boolean":
return "Boolean";
case "string":
return "String";
case "symbol":
return "Symbol";
case "number":
return "Number";
case "bigint":
return "BigInt";
case "function":
case "object": {
if (V === null) {
return "Null";
}
return "Object";
}
}
};
webidl.util.ConvertToInt = function(V, bitLength, signedness, opts = {}) {
let upperBound;
let lowerBound;
if (bitLength === 64) {
upperBound = Math.pow(2, 53) - 1;
if (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 === true) {
if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) {
throw webidl.errors.exception({
header: "Integer conversion",
message: `Could not convert ${V} to an integer.`
});
}
x = webidl.util.IntegerPart(x);
if (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 === true) {
x = Math.min(Math.max(x, lowerBound), upperBound);
if (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;
}
x = webidl.util.IntegerPart(x);
x = x % Math.pow(2, bitLength);
if (signedness === "signed" && x >= Math.pow(2, bitLength) - 1) {
return x - Math.pow(2, bitLength);
}
return x;
};
webidl.util.IntegerPart = function(n) {
const r = Math.floor(Math.abs(n));
if (n < 0) {
return -1 * r;
}
return r;
};
webidl.sequenceConverter = function(converter) {
return (V) => {
if (webidl.util.Type(V) !== "Object") {
throw webidl.errors.exception({
header: "Sequence",
message: `Value of type ${webidl.util.Type(V)} is not an Object.`
});
}
const method = V?.[Symbol.iterator]?.();
const seq = [];
if (method === void 0 || typeof method.next !== "function") {
throw webidl.errors.exception({
header: "Sequence",
message: "Object is not an iterator."
});
}
while (true) {
const { done, value } = method.next();
if (done) {
break;
}
seq.push(converter(value));
}
return seq;
};
};
webidl.recordConverter = function(keyConverter, valueConverter) {
return (O) => {
if (webidl.util.Type(O) !== "Object") {
throw webidl.errors.exception({
header: "Record",
message: `Value of type ${webidl.util.Type(O)} is not an Object.`
});
}
const result = {};
if (!types.isProxy(O)) {
const keys2 = Object.keys(O);
for (const key of keys2) {
const typedKey = keyConverter(key);
const typedValue = valueConverter(O[key]);
result[typedKey] = typedValue;
}
return result;
}
const keys = Reflect.ownKeys(O);
for (const key of keys) {
const desc = Reflect.getOwnPropertyDescriptor(O, key);
if (desc?.enumerable) {
const typedKey = keyConverter(key);
const typedValue = valueConverter(O[key]);
result[typedKey] = typedValue;
}
}
return result;
};
};
webidl.interfaceConverter = function(i) {
return (V, opts = {}) => {
if (opts.strict !== false && !(V instanceof i)) {
throw webidl.errors.exception({
header: i.name,
message: `Expected ${V} to be an instance of ${i.name}.`
});
}
return V;
};
};
webidl.dictionaryConverter = function(converters) {
return (dictionary) => {
const type = webidl.util.Type(dictionary);
const dict = {};
if (type === "Null" || type === "Undefined") {
return dict;
} else if (type !== "Object") {
throw webidl.errors.exception({
header: "Dictionary",
message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
});
}
for (const options of converters) {
const { key, defaultValue, required, converter } = options;
if (required === true) {
if (!Object.hasOwn(dictionary, key)) {
throw webidl.errors.exception({
header: "Dictionary",
message: `Missing required key "${key}".`
});
}
}
let value = dictionary[key];
const hasDefault = Object.hasOwn(options, "defaultValue");
if (hasDefault && value !== null) {
value = value ?? defaultValue;
}
if (required || hasDefault || value !== void 0) {
value = converter(value);
if (options.allowedValues && !options.allowedValues.includes(value)) {
throw webidl.errors.exception({
header: "Dictionary",
message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.`
});
}
dict[key] = value;
}
}
return dict;
};
};
webidl.nullableConverter = function(converter) {
return (V) => {
if (V === null) {
return V;
}
return converter(V);
};
};
webidl.converters.DOMString = function(V, opts = {}) {
if (V === null && opts.legacyNullToEmptyString) {
return "";
}
if (typeof V === "symbol") {
throw new TypeError("Could not convert argument of type symbol to string.");
}
return String(V);
};
webidl.converters.ByteString = function(V) {
const x = webidl.converters.DOMString(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) {
const x = Boolean(V);
return x;
};
webidl.converters.any = function(V) {
return V;
};
webidl.converters["long long"] = function(V) {
const x = webidl.util.ConvertToInt(V, 64, "signed");
return x;
};
webidl.converters["unsigned long long"] = function(V) {
const x = webidl.util.ConvertToInt(V, 64, "unsigned");
return x;
};
webidl.converters["unsigned long"] = function(V) {
const x = webidl.util.ConvertToInt(V, 32, "unsigned");
return x;
};
webidl.converters["unsigned short"] = function(V, opts) {
const x = webidl.util.ConvertToInt(V, 16, "unsigned", opts);
return x;
};
webidl.converters.ArrayBuffer = function(V, opts = {}) {
if (webidl.util.Type(V) !== "Object" || !types.isAnyArrayBuffer(V)) {
throw webidl.errors.conversionFailed({
prefix: `${V}`,
argument: `${V}`,
types: ["ArrayBuffer"]
});
}
if (opts.allowShared === false && types.isSharedArrayBuffer(V)) {
throw webidl.errors.exception({
header: "ArrayBuffer",
message: "SharedArrayBuffer is not allowed."
});
}
return V;
};
webidl.converters.TypedArray = function(V, T, opts = {}) {
if (webidl.util.Type(V) !== "Object" || !types.isTypedArray(V) || V.constructor.name !== T.name) {
throw webidl.errors.conversionFailed({
prefix: `${T.name}`,
argument: `${V}`,
types: [T.name]
});
}
if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
throw webidl.errors.exception({
header: "ArrayBuffer",
message: "SharedArrayBuffer is not allowed."
});
}
return V;
};
webidl.converters.DataView = function(V, opts = {}) {
if (webidl.util.Type(V) !== "Object" || !types.isDataView(V)) {
throw webidl.errors.exception({
header: "DataView",
message: "Object is not a DataView."
});
}
if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
throw webidl.errors.exception({
header: "ArrayBuffer",
message: "SharedArrayBuffer is not allowed."
});
}
return V;
};
webidl.converters.BufferSource = function(V, opts = {}) {
if (types.isAnyArrayBuffer(V)) {
return webidl.converters.ArrayBuffer(V, { ...opts, allowShared: false });
}
if (types.isTypedArray(V)) {
return webidl.converters.TypedArray(V, V.constructor, { ...opts, allowShared: false });
}
if (types.isDataView(V)) {
return webidl.converters.DataView(V, opts, { ...opts, allowShared: false });
}
throw new TypeError(`Could not convert ${V} to a BufferSource.`);
};
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
);
module2.exports = {
webidl
};
}
});
// lib/fetch/headers.js
var require_headers = __commonJS({
"lib/fetch/headers.js"(exports2, module2) {
"use strict";
var { kHeadersList, kConstruct } = require_symbols();
var { kGuard } = require_symbols2();
var { kEnumerableProperty } = require_util();
var {
makeIterator,
isValidHeaderName,
isValidHeaderValue
} = require_util2();
var { webidl } = require_webidl();
var assert = require("node:assert");
var kHeadersMap = Symbol("headers map");
var kHeadersSortedMap = Symbol("headers map sorted");
function isHTTPWhiteSpaceCharCode(code) {
return code === 10 || code === 13 || code === 9 || code === 32;
}
__name(isHTTPWhiteSpaceCharCode, "isHTTPWhiteSpaceCharCode");
function headerValueNormalize(potentialValue) {
let i = 0;
let 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);
}
__name(headerValueNormalize, "headerValueNormalize");
function fill(headers, object) {
if (Array.isArray(object)) {
for (let i = 0; i < object.length; ++i) {
const 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) {
const 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>"]
});
}
}
__name(fill, "fill");
function appendHeader(headers, name, value) {
value = headerValueNormalize(value);
if (!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 (headers[kGuard] === "immutable") {
throw new TypeError("immutable");
} else if (headers[kGuard] === "request-no-cors") {
}
return headers[kHeadersList].append(name, value, false);
}
__name(appendHeader, "appendHeader");
var HeadersList = class _HeadersList {
static {
__name(this, "HeadersList");
}
/** @type {[string, string][]|null} */
cookies = null;
constructor(init) {
if (init instanceof _HeadersList) {
this[kHeadersMap] = new Map(init[kHeadersMap]);
this[kHeadersSortedMap] = init[kHeadersSortedMap];
this.cookies = init.cookies === null ? null : [...init.cookies];
} else {
this[kHeadersMap] = new Map(init);
this[kHeadersSortedMap] = null;
}
}
/**
* @see https://fetch.spec.whatwg.org/#header-list-contains
* @param {string} name
* @param {boolean} isLowerCase
*/
contains(name, isLowerCase) {
return this[kHeadersMap].has(isLowerCase ? name : name.toLowerCase());
}
clear() {
this[kHeadersMap].clear();
this[kHeadersSortedMap] = null;
this.cookies = null;
}
/**
* @see https://fetch.spec.whatwg.org/#concept-header-list-append
* @param {string} name
* @param {string} value
* @param {boolean} isLowerCase
*/
append(name, value, isLowerCase) {
this[kHeadersSortedMap] = null;
const lowercaseName = isLowerCase ? name : name.toLowerCase();
const exists = this[kHeadersMap].get(lowercaseName);
if (exists) {
const delimiter = lowercaseName === "cookie" ? "; " : ", ";
this[kHeadersMap].set(lowercaseName, {
name: exists.name,
value: `${exists.value}${delimiter}${value}`
});
} else {
this[kHeadersMap].set(lowercaseName, { name, value });
}
if (lowercaseName === "set-cookie") {
(this.cookies ??= []).push(value);
}
}
/**
* @see https://fetch.spec.whatwg.org/#concept-header-list-set
* @param {string} name
* @param {string} value
* @param {boolean} isLowerCase
*/
set(name, value, isLowerCase) {
this[kHeadersSortedMap] = null;
const lowercaseName = isLowerCase ? name : name.toLowerCase();
if (lowercaseName === "set-cookie") {
this.cookies = [value];
}
this[kHeadersMap].set(lowercaseName, { name, value });
}
/**
* @see https://fetch.spec.whatwg.org/#concept-header-list-delete
* @param {string} name
* @param {boolean} isLowerCase
*/
delete(name, isLowerCase) {
this[kHeadersSortedMap] = null;
if (!isLowerCase)
name = name.toLowerCase();
if (name === "set-cookie") {
this.cookies = null;
}
this[kHeadersMap].delete(name);
}
/**
* @see https://fetch.spec.whatwg.org/#concept-header-list-get
* @param {string} name
* @param {boolean} isLowerCase
* @returns {string | null}
*/
get(name, isLowerCase) {
return this[kHeadersMap].get(isLowerCase ? name : name.toLowerCase())?.value ?? null;
}
*[Symbol.iterator]() {
for (const [name, { value }] of this[kHeadersMap]) {
yield [name, value];
}
}
get entries() {
const headers = {};
if (this[kHeadersMap].size) {
for (const { name, value } of this[kHeadersMap].values()) {
headers[name] = value;
}
}
return headers;
}
};
var Headers = class _Headers {
static {
__name(this, "Headers");
}
constructor(init = void 0) {
if (init === kConstruct) {
return;
}
this[kHeadersList] = new HeadersList();
this[kGuard] = "none";
if (init !== void 0) {
init = webidl.converters.HeadersInit(init);
fill(this, init);
}
}
// https://fetch.spec.whatwg.org/#dom-headers-append
append(name, value) {
webidl.brandCheck(this, _Headers);
webidl.argumentLengthCheck(arguments, 2, { header: "Headers.append" });
name = webidl.converters.ByteString(name);
value = webidl.converters.ByteString(value);
return appendHeader(this, name, value);
}
// https://fetch.spec.whatwg.org/#dom-headers-delete
delete(name) {
webidl.brandCheck(this, _Headers);
webidl.argumentLengthCheck(arguments, 1, { header: "Headers.delete" });
name = webidl.converters.ByteString(name);
if (!isValidHeaderName(name)) {
throw webidl.errors.invalidArgument({
prefix: "Headers.delete",
value: name,
type: "header name"
});
}
if (this[kGuard] === "immutable") {
throw new TypeError("immutable");
} else if (this[kGuard] === "request-no-cors") {
}
if (!this[kHeadersList].contains(name, false)) {
return;
}
this[kHeadersList].delete(name, false);
}
// https://fetch.spec.whatwg.org/#dom-headers-get
get(name) {
webidl.brandCheck(this, _Headers);
webidl.argumentLengthCheck(arguments, 1, { header: "Headers.get" });
name = webidl.converters.ByteString(name);
if (!isValidHeaderName(name)) {
throw webidl.errors.invalidArgument({
prefix: "Headers.get",
value: name,
type: "header name"
});
}
return this[kHeadersList].get(name, false);
}
// https://fetch.spec.whatwg.org/#dom-headers-has
has(name) {
webidl.brandCheck(this, _Headers);
webidl.argumentLengthCheck(arguments, 1, { header: "Headers.has" });
name = webidl.converters.ByteString(name);
if (!isValidHeaderName(name)) {
throw webidl.errors.invalidArgument({
prefix: "Headers.has",
value: name,
type: "header name"
});
}
return this[kHeadersList].contains(name, false);
}
// https://fetch.spec.whatwg.org/#dom-headers-set
set(name, value) {
webidl.brandCheck(this, _Headers);
webidl.argumentLengthCheck(arguments, 2, { header: "Headers.set" });
name = webidl.converters.ByteString(name);
value = webidl.converters.ByteString(value);
value = headerValueNormalize(value);
if (!isValidHeaderName(name)) {
throw webidl.errors.invalidArgument({
prefix: "Headers.set",
value: name,
type: "header name"
});
} else if (!isValidHeaderValue(value)) {
throw webidl.errors.invalidArgument({
prefix: "Headers.set",
value,
type: "header value"
});
}
if (this[kGuard] === "immutable") {
throw new TypeError("immutable");
} else if (this[kGuard] === "request-no-cors") {
}
this[kHeadersList].set(name, value, false);
}
// https://fetch.spec.whatwg.org/#dom-headers-getsetcookie
getSetCookie() {
webidl.brandCheck(this, _Headers);
const list = this[kHeadersList].cookies;
if (list) {
return [...list];
}
return [];
}
// https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
get [kHeadersSortedMap]() {
if (this[kHeadersList][kHeadersSortedMap]) {
return this[kHeadersList][kHeadersSortedMap];
}
const headers = [];
const names = [...this[kHeadersList]].sort((a, b) => a[0] < b[0] ? -1 : 1);
const cookies = this[kHeadersList].cookies;
for (let i = 0; i < names.length; ++i) {
const [name, value] = names[i];
if (name === "set-cookie") {
for (let j = 0; j < cookies.length; ++j) {
headers.push([name, cookies[j]]);
}
} else {
assert(value !== null);
headers.push([name, value]);
}
}
this[kHeadersList][kHeadersSortedMap] = headers;
return headers;
}
keys() {
webidl.brandCheck(this, _Headers);
return makeIterator(
() => this[kHeadersSortedMap],
"Headers",
"key",
0,
1
);
}
values() {
webidl.brandCheck(this, _Headers);
return makeIterator(
() => this[kHeadersSortedMap],
"Headers",
"value",
0,
1
);
}
entries() {
webidl.brandCheck(this, _Headers);
return makeIterator(
() => this[kHeadersSortedMap],
"Headers",
"key+value",
0,
1
);
}
/**
* @param {(value: string, key: string, self: Headers) => void} callbackFn
* @param {unknown} thisArg
*/
forEach(callbackFn, thisArg = globalThis) {
webidl.brandCheck(this, _Headers);
webidl.argumentLengthCheck(arguments, 1, { header: "Headers.forEach" });
if (typeof callbackFn !== "function") {
throw new TypeError(
"Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'."
);
}
for (const [key, value] of this) {
callbackFn.call(thisArg, value, key, this);
}
}
[Symbol.for("nodejs.util.inspect.custom")]() {
webidl.brandCheck(this, _Headers);
return this[kHeadersList];
}
};
Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
Object.defineProperties(Headers.prototype, {
append: kEnumerableProperty,
delete: kEnumerableProperty,
get: kEnumerableProperty,
has: kEnumerableProperty,
set: kEnumerableProperty,
getSetCookie: kEnumerableProperty,
keys: kEnumerableProperty,
values: kEnumerableProperty,
entries: kEnumerableProperty,
forEach: kEnumerableProperty,
[Symbol.iterator]: { enumerable: false },
[Symbol.toStringTag]: {
value: "Headers",
configurable: true
}
});
webidl.converters.HeadersInit = function(V) {
if (webidl.util.Type(V) === "Object") {
if (V[Symbol.iterator]) {
return webidl.converters["sequence<sequence<ByteString>>"](V);
}
return webidl.converters["record<ByteString, ByteString>"](V);
}
throw webidl.errors.conversionFailed({
prefix: "Headers constructor",
argument: "Argument 1",
types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
});
};
module2.exports = {
fill,
Headers,
HeadersList
};
}
});
// node_modules/@fastify/busboy/deps/streamsearch/sbmh.js
var require_sbmh = __commonJS({
"node_modules/@fastify/busboy/deps/streamsearch/sbmh.js"(exports2, module2) {
"use strict";
var EventEmitter = require("node:events").EventEmitter;
var inherits = require("node:util").inherits;
function SBMH(needle) {
if (typeof needle === "string") {
needle = Buffer.from(needle);
}
if (!Buffer.isBuffer(needle)) {
throw new TypeError("The needle has to be a String or a Buffer.");
}
const needleLength = needle.length;
if (needleLength === 0) {
throw new Error("The needle cannot be an empty String/Buffer.");
}
if (needleLength > 256) {
throw new Error("The needle cannot have a length bigger than 256.");
}
this.maxMatches = Infinity;
this.matches = 0;
this._occ = new Array(256).fill(needleLength);
this._lookbehind_size = 0;
this._needle = needle;
this._bufpos = 0;
this._lookbehind = Buffer.alloc(needleLength);
for (var i = 0; i < needleLength - 1; ++i) {
this._occ[needle[i]] = needleLength - 1 - i;
}
}
__name(SBMH, "SBMH");
inherits(SBMH, EventEmitter);
SBMH.prototype.reset = function() {
this._lookbehind_size = 0;
this.matches = 0;
this._bufpos = 0;
};
SBMH.prototype.push = function(chunk, pos) {
if (!Buffer.isBuffer(chunk)) {
chunk = Buffer.from(chunk, "binary");
}
const chlen = chunk.length;
this._bufpos = pos || 0;
let r;
while (r !== chlen && this.matches < this.maxMatches) {
r = this._sbmh_feed(chunk);
}
return r;
};
SBMH.prototype._sbmh_feed = function(data) {
const len = data.length;
const needle = this._needle;
const needleLength = needle.length;
const lastNeedleChar = needle[needleLength - 1];
let pos = -this._lookbehind_size;
let ch;
if (pos < 0) {
while (pos < 0 && pos <= len - needleLength) {
ch = this._sbmh_lookup_char(data, pos + needleLength - 1);
if (ch === lastNeedleChar && this._sbmh_memcmp(data, pos, needleLength - 1)) {
this._lookbehind_size = 0;
++this.matches;
this.emit("info", true);
return this._bufpos = pos + needleLength;
}
pos += this._occ[ch];
}
if (pos < 0) {
while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) {
++pos;
}
}
if (pos >= 0) {
this.emit("info", false, this._lookbehind, 0, this._lookbehind_size);
this._lookbehind_size = 0;
} else {
const bytesToCutOff = this._lookbehind_size + pos;
if (bytesToCutOff > 0) {
this.emit("info", false, this._lookbehind, 0, bytesToCutOff);
}
this._lookbehind.copy(
this._lookbehind,
0,
bytesToCutOff,
this._lookbehind_size - bytesToCutOff
);
this._lookbehind_size -= bytesToCutOff;
data.copy(this._lookbehind, this._lookbehind_size);
this._lookbehind_size += len;
this._bufpos = len;
return len;
}
}
pos += (pos >= 0) * this._bufpos;
if (data.indexOf(needle, pos) !== -1) {
pos = data.indexOf(needle, pos);
++this.matches;
if (pos > 0) {
this.emit("info", true, data, this._bufpos, pos);
} else {
this.emit("info", true);
}
return this._bufpos = pos + needleLength;
} else {
pos = len - needleLength;
}
while (pos < len && (data[pos] !== needle[0] || Buffer.compare(
data.subarray(pos, pos + len - pos),
needle.subarray(0, len - pos)
) !== 0)) {
++pos;
}
if (pos < len) {
data.copy(this._lookbehind, 0, pos, pos + (len - pos));
this._lookbehind_size = len - pos;
}
if (pos > 0) {
this.emit("info", false, data, this._bufpos, pos < len ? pos : len);
}
this._bufpos = len;
return len;
};
SBMH.prototype._sbmh_lookup_char = function(data, pos) {
return pos < 0 ? this._lookbehind[this._lookbehind_size + pos] : data[pos];
};
SBMH.prototype._sbmh_memcmp = function(data, pos, len) {
for (var i = 0; i < len; ++i) {
if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) {
return false;
}
}
return true;
};
module2.exports = SBMH;
}
});
// node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js
var require_PartStream = __commonJS({
"node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js"(exports2, module2) {
"use strict";
var inherits = require("node:util").inherits;
var ReadableStream2 = require("node:stream").Readable;
function PartStream(opts) {
ReadableStream2.call(this, opts);
}
__name(PartStream, "PartStream");
inherits(PartStream, ReadableStream2);
PartStream.prototype._read = function(n) {
};
module2.exports = PartStream;
}
});
// node_modules/@fastify/busboy/lib/utils/getLimit.js
var require_getLimit = __commonJS({
"node_modules/@fastify/busboy/lib/utils/getLimit.js"(exports2, module2) {
"use strict";
module2.exports = /* @__PURE__ */ __name(function getLimit(limits, name, defaultLimit) {
if (!limits || limits[name] === void 0 || limits[name] === null) {
return defaultLimit;
}
if (typeof limits[name] !== "number" || isNaN(limits[name])) {
throw new TypeError("Limit " + name + " is not a valid number");
}
return limits[name];
}, "getLimit");
}
});
// node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js
var require_HeaderParser = __commonJS({
"node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js"(exports2, module2) {
"use strict";
var EventEmitter = require("node:events").EventEmitter;
var inherits = require("node:util").inherits;
var getLimit = require_getLimit();
var StreamSearch = require_sbmh();
var B_DCRLF = Buffer.from("\r\n\r\n");
var RE_CRLF = /\r\n/g;
var RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/;
function HeaderParser(cfg) {
EventEmitter.call(this);
cfg = cfg || {};
const self = this;
this.nread = 0;
this.maxed = false;
this.npairs = 0;
this.maxHeaderPairs = getLimit(cfg, "maxHeaderPairs", 2e3);
this.maxHeaderSize = getLimit(cfg, "maxHeaderSize", 80 * 1024);
this.buffer = "";
this.header = {};
this.finished = false;
this.ss = new StreamSearch(B_DCRLF);
this.ss.on("info", function(isMatch, data, start, end) {
if (data && !self.maxed) {
if (self.nread + end - start >= self.maxHeaderSize) {
end = self.maxHeaderSize - self.nread + start;
self.nread = self.maxHeaderSize;
self.maxed = true;
} else {
self.nread += end - start;
}
self.buffer += data.toString("binary", start, end);
}
if (isMatch) {
self._finish();
}
});
}
__name(HeaderParser, "HeaderParser");
inherits(HeaderParser, EventEmitter);
HeaderParser.prototype.push = function(data) {
const r = this.ss.push(data);
if (this.finished) {
return r;
}
};
HeaderParser.prototype.reset = function() {
this.finished = false;
this.buffer = "";
this.header = {};
this.ss.reset();
};
HeaderParser.prototype._finish = function() {
if (this.buffer) {
this._parseHeader();
}
this.ss.matches = this.ss.maxMatches;
const header = this.header;
this.header = {};
this.buffer = "";
this.finished = true;
this.nread = this.npairs = 0;
this.maxed = false;
this.emit("header", header);
};
HeaderParser.prototype._parseHeader = function() {
if (this.npairs === this.maxHeaderPairs) {
return;
}
const lines = this.buffer.split(RE_CRLF);
const len = lines.length;
let m, h;
for (var i = 0; i < len; ++i) {
if (lines[i].length === 0) {
continue;
}
if (lines[i][0] === " " || lines[i][0] === " ") {
if (h) {
this.header[h][this.header[h].length - 1] += lines[i];
continue;
}
}
const posColon = lines[i].indexOf(":");
if (posColon === -1 || posColon === 0) {
return;
}
m = RE_HDR.exec(lines[i]);
h = m[1].toLowerCase();
this.header[h] = this.header[h] || [];
this.header[h].push(m[2] || "");
if (++this.npairs === this.maxHeaderPairs) {
break;
}
}
};
module2.exports = HeaderParser;
}
});
// node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js
var require_Dicer = __commonJS({
"node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js"(exports2, module2) {
"use strict";
var WritableStream = require("node:stream").Writable;
var inherits = require("node:util").inherits;
var StreamSearch = require_sbmh();
var PartStream = require_PartStream();
var HeaderParser = require_HeaderParser();
var DASH = 45;
var B_ONEDASH = Buffer.from("-");
var B_CRLF = Buffer.from("\r\n");
var EMPTY_FN = /* @__PURE__ */ __name(function() {
}, "EMPTY_FN");
function Dicer(cfg) {
if (!(this instanceof Dicer)) {
return new Dicer(cfg);
}
WritableStream.call(this, cfg);
if (!cfg || !cfg.headerFirst && typeof cfg.boundary !== "string") {
throw new TypeError("Boundary required");
}
if (typeof cfg.boundary === "string") {
this.setBoundary(cfg.boundary);
} else {
this._bparser = void 0;
}
this._headerFirst = cfg.headerFirst;
this._dashes = 0;
this._parts = 0;
this._finished = false;
this._realFinish = false;
this._isPreamble = true;
this._justMatched = false;
this._firstWrite = true;
this._inHeader = true;
this._part = void 0;
this._cb = void 0;
this._ignoreData = false;
this._partOpts = { highWaterMark: cfg.partHwm };
this._pause = false;
const self = this;
this._hparser = new HeaderParser(cfg);
this._hparser.on("header", function(header) {
self._inHeader = false;
self._part.emit("header", header);
});
}
__name(Dicer, "Dicer");
inherits(Dicer, WritableStream);
Dicer.prototype.emit = function(ev) {
if (ev === "finish" && !this._realFinish) {
if (!this._finished) {
const self = this;
process.nextTick(function() {
self.emit("error", new Error("Unexpected end of multipart data"));
if (self._part && !self._ignoreData) {
const type = self._isPreamble ? "Preamble" : "Part";
self._part.emit("error", new Error(type + " terminated early due to unexpected end of multipart data"));
self._part.push(null);
process.nextTick(function() {
self._realFinish = true;
self.emit("finish");
self._realFinish = false;
});
return;
}
self._realFinish = true;
self.emit("finish");
self._realFinish = false;
});
}
} else {
WritableStream.prototype.emit.apply(this, arguments);
}
};
Dicer.prototype._write = function(data, encoding, cb) {
if (!this._hparser && !this._bparser) {
return cb();
}
if (this._headerFirst && this._isPreamble) {
if (!this._part) {
this._part = new PartStream(this._partOpts);
if (this._events.preamble) {
this.emit("preamble", this._part);
} else {
this._ignore();
}
}
const r = this._hparser.push(data);
if (!this._inHeader && r !== void 0 && r < data.length) {
data = data.slice(r);
} else {
return cb();
}
}
if (this._firstWrite) {
this._bparser.push(B_CRLF);
this._firstWrite = false;
}
this._bparser.push(data);
if (this._pause) {
this._cb = cb;
} else {
cb();
}
};
Dicer.prototype.reset = function() {
this._part = void 0;
this._bparser = void 0;
this._hparser = void 0;
};
Dicer.prototype.setBoundary = function(boundary) {
const self = this;
this._bparser = new StreamSearch("\r\n--" + boundary);
this._bparser.on("info", function(isMatch, data, start, end) {
self._oninfo(isMatch, data, start, end);
});
};
Dicer.prototype._ignore = function() {
if (this._part && !this._ignoreData) {
this._ignoreData = true;
this._part.on("error", EMPTY_FN);
this._part.resume();
}
};
Dicer.prototype._oninfo = function(isMatch, data, start, end) {
let buf;
const self = this;
let i = 0;
let r;
let shouldWriteMore = true;
if (!this._part && this._justMatched && data) {
while (this._dashes < 2 && start + i < end) {
if (data[start + i] === DASH) {
++i;
++this._dashes;
} else {
if (this._dashes) {
buf = B_ONEDASH;
}
this._dashes = 0;
break;
}
}
if (this._dashes === 2) {
if (start + i < end && this._events.trailer) {
this.emit("trailer", data.slice(start + i, end));
}
this.reset();
this._finished = true;
if (self._parts === 0) {
self._realFinish = true;
self.emit("finish");
self._realFinish = false;
}
}
if (this._dashes) {
return;
}
}
if (this._justMatched) {
this._justMatched = false;
}
if (!this._part) {
this._part = new PartStream(this._partOpts);
this._part._read = function(n) {
self._unpause();
};
if (this._isPreamble && this._events.preamble) {
this.emit("preamble", this._part);
} else if (this._isPreamble !== true && this._events.part) {
this.emit("part", this._part);
} else {
this._ignore();
}
if (!this._isPreamble) {
this._inHeader = true;
}
}
if (data && start < end && !this._ignoreData) {
if (this._isPreamble || !this._inHeader) {
if (buf) {
shouldWriteMore = this._part.push(buf);
}
shouldWriteMore = this._part.push(data.slice(start, end));
if (!shouldWriteMore) {
this._pause = true;
}
} else if (!this._isPreamble && this._inHeader) {
if (buf) {
this._hparser.push(buf);
}
r = this._hparser.push(data.slice(start, end));
if (!this._inHeader && r !== void 0 && r < end) {
this._oninfo(false, data, start + r, end);
}
}
}
if (isMatch) {
this._hparser.reset();
if (this._isPreamble) {
this._isPreamble = false;
} else {
if (start !== end) {
++this._parts;
this._part.on("end", function() {
if (--self._parts === 0) {
if (self._finished) {
self._realFinish = true;
self.emit("finish");
self._realFinish = false;
} else {
self._unpause();
}
}
});
}
}
this._part.push(null);
this._part = void 0;
this._ignoreData = false;
this._justMatched = true;
this._dashes = 0;
}
};
Dicer.prototype._unpause = function() {
if (!this._pause) {
return;
}
this._pause = false;
if (this._cb) {
const cb = this._cb;
this._cb = void 0;
cb();
}
};
module2.exports = Dicer;
}
});
// node_modules/@fastify/busboy/lib/utils/decodeText.js
var require_decodeText = __commonJS({
"node_modules/@fastify/busboy/lib/utils/decodeText.js"(exports2, module2) {
"use strict";
var utf8Decoder = new TextDecoder("utf-8");
var textDecoders = /* @__PURE__ */ new Map([
["utf-8", utf8Decoder],
["utf8", utf8Decoder]
]);
function getDecoder(charset) {
let lc;
while (true) {
switch (charset) {
case "utf-8":
case "utf8":
return decoders.utf8;
case "latin1":
case "ascii":
case "us-ascii":
case "iso-8859-1":
case "iso8859-1":
case "iso88591":
case "iso_8859-1":
case "windows-1252":
case "iso_8859-1:1987":
case "cp1252":
case "x-cp1252":
return decoders.latin1;
case "utf16le":
case "utf-16le":
case "ucs2":
case "ucs-2":
return decoders.utf16le;
case "base64":
return decoders.base64;
default:
if (lc === void 0) {
lc = true;
charset = charset.toLowerCase();
continue;
}
return decoders.other.bind(charset);
}
}
}
__name(getDecoder, "getDecoder");
var decoders = {
utf8: (data, sourceEncoding) => {
if (data.length === 0) {
return "";
}
if (typeof data === "string") {
data = Buffer.from(data, sourceEncoding);
}
return data.utf8Slice(0, data.length);
},
latin1: (data, sourceEncoding) => {
if (data.length === 0) {
return "";
}
if (typeof data === "string") {
return data;
}
return data.latin1Slice(0, data.length);
},
utf16le: (data, sourceEncoding) => {
if (data.length === 0) {
return "";
}
if (typeof data === "string") {
data = Buffer.from(data, sourceEncoding);
}
return data.ucs2Slice(0, data.length);
},
base64: (data, sourceEncoding) => {
if (data.length === 0) {
return "";
}
if (typeof data === "string") {
data = Buffer.from(data, sourceEncoding);
}
return data.base64Slice(0, data.length);
},
other: (data, sourceEncoding) => {
if (data.length === 0) {
return "";
}
if (typeof data === "string") {
data = Buffer.from(data, sourceEncoding);
}
if (textDecoders.has(exports2.toString())) {
try {
return textDecoders.get(exports2).decode(data);
} catch (e) {
}
}
return typeof data === "string" ? data : data.toString();
}
};
function decodeText(text, sourceEncoding, destEncoding) {
if (text) {
return getDecoder(destEncoding)(text, sourceEncoding);
}
return text;
}
__name(decodeText, "decodeText");
module2.exports = decodeText;
}
});
// node_modules/@fastify/busboy/lib/utils/parseParams.js
var require_parseParams = __commonJS({
"node_modules/@fastify/busboy/lib/utils/parseParams.js"(exports2, module2) {
"use strict";
var decodeText = require_decodeText();
var RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g;
var EncodedLookup = {
"%00": "\0",
"%01": "",
"%02": "",
"%03": "",
"%04": "",
"%05": "",
"%06": "",
"%07": "\x07",
"%08": "\b",
"%09": " ",
"%0a": "\n",
"%0A": "\n",
"%0b": "\v",
"%0B": "\v",
"%0c": "\f",
"%0C": "\f",
"%0d": "\r",
"%0D": "\r",
"%0e": "",
"%0E": "",
"%0f": "",
"%0F": "",
"%10": "",
"%11": "",
"%12": "",
"%13": "",
"%14": "",
"%15": "",
"%16": "",
"%17": "",
"%18": "",
"%19": "",
"%1a": "",
"%1A": "",
"%1b": "\x1B",
"%1B": "\x1B",
"%1c": " ",
"%1C": " ",
"%1d": " ",
"%1D": " ",
"%1e": " ",
"%1E": " ",
"%1f": " ",
"%1F": " ",
"%20": " ",
"%21": "!",
"%22": '"',
"%23": "#",
"%24": "$",
"%25": "%",
"%26": "&",
"%27": "'",
"%28": "(",
"%29": ")",
"%2a": "*",
"%2A": "*",
"%2b": "+",
"%2B": "+",
"%2c": ",",
"%2C": ",",
"%2d": "-",
"%2D": "-",
"%2e": ".",
"%2E": ".",
"%2f": "/",
"%2F": "/",
"%30": "0",
"%31": "1",
"%32": "2",
"%33": "3",
"%34": "4",
"%35": "5",
"%36": "6",
"%37": "7",
"%38": "8",
"%39": "9",
"%3a": ":",
"%3A": ":",
"%3b": ";",
"%3B": ";",
"%3c": "<",
"%3C": "<",
"%3d": "=",
"%3D": "=",
"%3e": ">",
"%3E": ">",
"%3f": "?",
"%3F": "?",
"%40": "@",
"%41": "A",
"%42": "B",
"%43": "C",
"%44": "D",
"%45": "E",
"%46": "F",
"%47": "G",
"%48": "H",
"%49": "I",
"%4a": "J",
"%4A": "J",
"%4b": "K",
"%4B": "K",
"%4c": "L",
"%4C": "L",
"%4d": "M",
"%4D": "M",
"%4e": "N",
"%4E": "N",
"%4f": "O",
"%4F": "O",
"%50": "P",
"%51": "Q",
"%52": "R",
"%53": "S",
"%54": "T",
"%55": "U",
"%56": "V",
"%57": "W",
"%58": "X",
"%59": "Y",
"%5a": "Z",
"%5A": "Z",
"%5b": "[",
"%5B": "[",
"%5c": "\\",
"%5C": "\\",
"%5d": "]",
"%5D": "]",
"%5e": "^",
"%5E": "^",
"%5f": "_",
"%5F": "_",
"%60": "`",
"%61": "a",
"%62": "b",
"%63": "c",
"%64": "d",
"%65": "e",
"%66": "f",
"%67": "g",
"%68": "h",
"%69": "i",
"%6a": "j",
"%6A": "j",
"%6b": "k",
"%6B": "k",
"%6c": "l",
"%6C": "l",
"%6d": "m",
"%6D": "m",
"%6e": "n",
"%6E": "n",
"%6f": "o",
"%6F": "o",
"%70": "p",
"%71": "q",
"%72": "r",
"%73": "s",
"%74": "t",
"%75": "u",
"%76": "v",
"%77": "w",
"%78": "x",
"%79": "y",
"%7a": "z",
"%7A": "z",
"%7b": "{",
"%7B": "{",
"%7c": "|",
"%7C": "|",
"%7d": "}",
"%7D": "}",
"%7e": "~",
"%7E": "~",
"%7f": "\x7F",
"%7F": "\x7F",
"%80": "\x80",
"%81": "\x81",
"%82": "\x82",
"%83": "\x83",
"%84": "\x84",
"%85": "\x85",
"%86": "\x86",
"%87": "\x87",
"%88": "\x88",
"%89": "\x89",
"%8a": "\x8A",
"%8A": "\x8A",
"%8b": "\x8B",
"%8B": "\x8B",
"%8c": "\x8C",
"%8C": "\x8C",
"%8d": "\x8D",
"%8D": "\x8D",
"%8e": "\x8E",
"%8E": "\x8E",
"%8f": "\x8F",
"%8F": "\x8F",
"%90": "\x90",
"%91": "\x91",
"%92": "\x92",
"%93": "\x93",
"%94": "\x94",
"%95": "\x95",
"%96": "\x96",
"%97": "\x97",
"%98": "\x98",
"%99": "\x99",
"%9a": "\x9A",
"%9A": "\x9A",
"%9b": "\x9B",
"%9B": "\x9B",
"%9c": "\x9C",
"%9C": "\x9C",
"%9d": "\x9D",
"%9D": "\x9D",
"%9e": "\x9E",
"%9E": "\x9E",
"%9f": "\x9F",
"%9F": "\x9F",
"%a0": "\xA0",
"%A0": "\xA0",
"%a1": "\xA1",
"%A1": "\xA1",
"%a2": "\xA2",
"%A2": "\xA2",
"%a3": "\xA3",
"%A3": "\xA3",
"%a4": "\xA4",
"%A4": "\xA4",
"%a5": "\xA5",
"%A5": "\xA5",
"%a6": "\xA6",
"%A6": "\xA6",
"%a7": "\xA7",
"%A7": "\xA7",
"%a8": "\xA8",
"%A8": "\xA8",
"%a9": "\xA9",
"%A9": "\xA9",
"%aa": "\xAA",
"%Aa": "\xAA",
"%aA": "\xAA",
"%AA": "\xAA",
"%ab": "\xAB",
"%Ab": "\xAB",
"%aB": "\xAB",
"%AB": "\xAB",
"%ac": "\xAC",
"%Ac": "\xAC",
"%aC": "\xAC",
"%AC": "\xAC",
"%ad": "\xAD",
"%Ad": "\xAD",
"%aD": "\xAD",
"%AD": "\xAD",
"%ae": "\xAE",
"%Ae": "\xAE",
"%aE": "\xAE",
"%AE": "\xAE",
"%af": "\xAF",
"%Af": "\xAF",
"%aF": "\xAF",
"%AF": "\xAF",
"%b0": "\xB0",
"%B0": "\xB0",
"%b1": "\xB1",
"%B1": "\xB1",
"%b2": "\xB2",
"%B2": "\xB2",
"%b3": "\xB3",
"%B3": "\xB3",
"%b4": "\xB4",
"%B4": "\xB4",
"%b5": "\xB5",
"%B5": "\xB5",
"%b6": "\xB6",
"%B6": "\xB6",
"%b7": "\xB7",
"%B7": "\xB7",
"%b8": "\xB8",
"%B8": "\xB8",
"%b9": "\xB9",
"%B9": "\xB9",
"%ba": "\xBA",
"%Ba": "\xBA",
"%bA": "\xBA",
"%BA": "\xBA",
"%bb": "\xBB",
"%Bb": "\xBB",
"%bB": "\xBB",
"%BB": "\xBB",
"%bc": "\xBC",
"%Bc": "\xBC",
"%bC": "\xBC",
"%BC": "\xBC",
"%bd": "\xBD",
"%Bd": "\xBD",
"%bD": "\xBD",
"%BD": "\xBD",
"%be": "\xBE",
"%Be": "\xBE",
"%bE": "\xBE",
"%BE": "\xBE",
"%bf": "\xBF",
"%Bf": "\xBF",
"%bF": "\xBF",
"%BF": "\xBF",
"%c0": "\xC0",
"%C0": "\xC0",
"%c1": "\xC1",
"%C1": "\xC1",
"%c2": "\xC2",
"%C2": "\xC2",
"%c3": "\xC3",
"%C3": "\xC3",
"%c4": "\xC4",
"%C4": "\xC4",
"%c5": "\xC5",
"%C5": "\xC5",
"%c6": "\xC6",
"%C6": "\xC6",
"%c7": "\xC7",
"%C7": "\xC7",
"%c8": "\xC8",
"%C8": "\xC8",
"%c9": "\xC9",
"%C9": "\xC9",
"%ca": "\xCA",
"%Ca": "\xCA",
"%cA": "\xCA",
"%CA": "\xCA",
"%cb": "\xCB",
"%Cb": "\xCB",
"%cB": "\xCB",
"%CB": "\xCB",
"%cc": "\xCC",
"%Cc": "\xCC",
"%cC": "\xCC",
"%CC": "\xCC",
"%cd": "\xCD",
"%Cd": "\xCD",
"%cD": "\xCD",
"%CD": "\xCD",
"%ce": "\xCE",
"%Ce": "\xCE",
"%cE": "\xCE",
"%CE": "\xCE",
"%cf": "\xCF",
"%Cf": "\xCF",
"%cF": "\xCF",
"%CF": "\xCF",
"%d0": "\xD0",
"%D0": "\xD0",
"%d1": "\xD1",
"%D1": "\xD1",
"%d2": "\xD2",
"%D2": "\xD2",
"%d3": "\xD3",
"%D3": "\xD3",
"%d4": "\xD4",
"%D4": "\xD4",
"%d5": "\xD5",
"%D5": "\xD5",
"%d6": "\xD6",
"%D6": "\xD6",
"%d7": "\xD7",
"%D7": "\xD7",
"%d8": "\xD8",
"%D8": "\xD8",
"%d9": "\xD9",
"%D9": "\xD9",
"%da": "\xDA",
"%Da": "\xDA",
"%dA": "\xDA",
"%DA": "\xDA",
"%db": "\xDB",
"%Db": "\xDB",
"%dB": "\xDB",
"%DB": "\xDB",
"%dc": "\xDC",
"%Dc": "\xDC",
"%dC": "\xDC",
"%DC": "\xDC",
"%dd": "\xDD",
"%Dd": "\xDD",
"%dD": "\xDD",
"%DD": "\xDD",
"%de": "\xDE",
"%De": "\xDE",
"%dE": "\xDE",
"%DE": "\xDE",
"%df": "\xDF",
"%Df": "\xDF",
"%dF": "\xDF",
"%DF": "\xDF",
"%e0": "\xE0",
"%E0": "\xE0",
"%e1": "\xE1",
"%E1": "\xE1",
"%e2": "\xE2",
"%E2": "\xE2",
"%e3": "\xE3",
"%E3": "\xE3",
"%e4": "\xE4",
"%E4": "\xE4",
"%e5": "\xE5",
"%E5": "\xE5",
"%e6": "\xE6",
"%E6": "\xE6",
"%e7": "\xE7",
"%E7": "\xE7",
"%e8": "\xE8",
"%E8": "\xE8",
"%e9": "\xE9",
"%E9": "\xE9",
"%ea": "\xEA",
"%Ea": "\xEA",
"%eA": "\xEA",
"%EA": "\xEA",
"%eb": "\xEB",
"%Eb": "\xEB",
"%eB": "\xEB",
"%EB": "\xEB",
"%ec": "\xEC",
"%Ec": "\xEC",
"%eC": "\xEC",
"%EC": "\xEC",
"%ed": "\xED",
"%Ed": "\xED",
"%eD": "\xED",
"%ED": "\xED",
"%ee": "\xEE",
"%Ee": "\xEE",
"%eE": "\xEE",
"%EE": "\xEE",
"%ef": "\xEF",
"%Ef": "\xEF",
"%eF": "\xEF",
"%EF": "\xEF",
"%f0": "\xF0",
"%F0": "\xF0",
"%f1": "\xF1",
"%F1": "\xF1",
"%f2": "\xF2",
"%F2": "\xF2",
"%f3": "\xF3",
"%F3": "\xF3",
"%f4": "\xF4",
"%F4": "\xF4",
"%f5": "\xF5",
"%F5": "\xF5",
"%f6": "\xF6",
"%F6": "\xF6",
"%f7": "\xF7",
"%F7": "\xF7",
"%f8": "\xF8",
"%F8": "\xF8",
"%f9": "\xF9",
"%F9": "\xF9",
"%fa": "\xFA",
"%Fa": "\xFA",
"%fA": "\xFA",
"%FA": "\xFA",
"%fb": "\xFB",
"%Fb": "\xFB",
"%fB": "\xFB",
"%FB": "\xFB",
"%fc": "\xFC",
"%Fc": "\xFC",
"%fC": "\xFC",
"%FC": "\xFC",
"%fd": "\xFD",
"%Fd": "\xFD",
"%fD": "\xFD",
"%FD": "\xFD",
"%fe": "\xFE",
"%Fe": "\xFE",
"%fE": "\xFE",
"%FE": "\xFE",
"%ff": "\xFF",
"%Ff": "\xFF",
"%fF": "\xFF",
"%FF": "\xFF"
};
function encodedReplacer(match) {
return EncodedLookup[match];
}
__name(encodedReplacer, "encodedReplacer");
var STATE_KEY = 0;
var STATE_VALUE = 1;
var STATE_CHARSET = 2;
var STATE_LANG = 3;
function parseParams(str) {
const res = [];
let state = STATE_KEY;
let charset = "";
let inquote = false;
let escaping = false;
let p = 0;
let tmp = "";
const len = str.length;
for (var i = 0; i < len; ++i) {
const char = str[i];
if (char === "\\" && inquote) {
if (escaping) {
escaping = false;
} else {
escaping = true;
continue;
}
} else if (char === '"') {
if (!escaping) {
if (inquote) {
inquote = false;
state = STATE_KEY;
} else {
inquote = true;
}
continue;
} else {
escaping = false;
}
} else {
if (escaping && inquote) {
tmp += "\\";
}
escaping = false;
if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") {
if (state === STATE_CHARSET) {
state = STATE_LANG;
charset = tmp.substring(1);
} else {
state = STATE_VALUE;
}
tmp = "";
continue;
} else if (state === STATE_KEY && (char === "*" || char === "=") && res.length) {
state = char === "*" ? STATE_CHARSET : STATE_VALUE;
res[p] = [tmp, void 0];
tmp = "";
continue;
} else if (!inquote && char === ";") {
state = STATE_KEY;
if (charset) {
if (tmp.length) {
tmp = decodeText(
tmp.replace(RE_ENCODED, encodedReplacer),
"binary",
charset
);
}
charset = "";
} else if (tmp.length) {
tmp = decodeText(tmp, "binary", "utf8");
}
if (res[p] === void 0) {
res[p] = tmp;
} else {
res[p][1] = tmp;
}
tmp = "";
++p;
continue;
} else if (!inquote && (char === " " || char === " ")) {
continue;
}
}
tmp += char;
}
if (charset && tmp.length) {
tmp = decodeText(
tmp.replace(RE_ENCODED, encodedReplacer),
"binary",
charset
);
} else if (tmp) {
tmp = decodeText(tmp, "binary", "utf8");
}
if (res[p] === void 0) {
if (tmp) {
res[p] = tmp;
}
} else {
res[p][1] = tmp;
}
return res;
}
__name(parseParams, "parseParams");
module2.exports = parseParams;
}
});
// node_modules/@fastify/busboy/lib/utils/basename.js
var require_basename = __commonJS({
"node_modules/@fastify/busboy/lib/utils/basename.js"(exports2, module2) {
"use strict";
module2.exports = /* @__PURE__ */ __name(function basename(path) {
if (typeof path !== "string") {
return "";
}
for (var i = path.length - 1; i >= 0; --i) {
switch (path.charCodeAt(i)) {
case 47:
case 92:
path = path.slice(i + 1);
return path === ".." || path === "." ? "" : path;
}
}
return path === ".." || path === "." ? "" : path;
}, "basename");
}
});
// node_modules/@fastify/busboy/lib/types/multipart.js
var require_multipart = __commonJS({
"node_modules/@fastify/busboy/lib/types/multipart.js"(exports2, module2) {
"use strict";
var { Readable } = require("node:stream");
var { inherits } = require("node:util");
var Dicer = require_Dicer();
var parseParams = require_parseParams();
var decodeText = require_decodeText();
var basename = require_basename();
var getLimit = require_getLimit();
var RE_BOUNDARY = /^boundary$/i;
var RE_FIELD = /^form-data$/i;
var RE_CHARSET = /^charset$/i;
var RE_FILENAME = /^filename$/i;
var RE_NAME = /^name$/i;
Multipart.detect = /^multipart\/form-data/i;
function Multipart(boy, cfg) {
let i;
let len;
const self = this;
let boundary;
const limits = cfg.limits;
const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => contentType === "application/octet-stream" || fileName !== void 0);
const parsedConType = cfg.parsedConType || [];
const defCharset = cfg.defCharset || "utf8";
const preservePath = cfg.preservePath;
const fileOpts = { highWaterMark: cfg.fileHwm };
for (i = 0, len = parsedConType.length; i < len; ++i) {
if (Array.isArray(parsedConType[i]) && RE_BOUNDARY.test(parsedConType[i][0])) {
boundary = parsedConType[i][1];
break;
}
}
function checkFinished() {
if (nends === 0 && finished && !boy._done) {
finished = false;
self.end();
}
}
__name(checkFinished, "checkFinished");
if (typeof boundary !== "string") {
throw new Error("Multipart: Boundary not found");
}
const fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024);
const fileSizeLimit = getLimit(limits, "fileSize", Infinity);
const filesLimit = getLimit(limits, "files", Infinity);
const fieldsLimit = getLimit(limits, "fields", Infinity);
const partsLimit = getLimit(limits, "parts", Infinity);
const headerPairsLimit = getLimit(limits, "headerPairs", 2e3);
const headerSizeLimit = getLimit(limits, "headerSize", 80 * 1024);
let nfiles = 0;
let nfields = 0;
let nends = 0;
let curFile;
let curField;
let finished = false;
this._needDrain = false;
this._pause = false;
this._cb = void 0;
this._nparts = 0;
this._boy = boy;
const parserCfg = {
boundary,
maxHeaderPairs: headerPairsLimit,
maxHeaderSize: headerSizeLimit,
partHwm: fileOpts.highWaterMark,
highWaterMark: cfg.highWaterMark
};
this.parser = new Dicer(parserCfg);
this.parser.on("drain", function() {
self._needDrain = false;
if (self._cb && !self._pause) {
const cb = self._cb;
self._cb = void 0;
cb();
}
}).on("part", /* @__PURE__ */ __name(function onPart(part) {
if (++self._nparts > partsLimit) {
self.parser.removeListener("part", onPart);
self.parser.on("part", skipPart);
boy.hitPartsLimit = true;
boy.emit("partsLimit");
return skipPart(part);
}
if (curField) {
const field = curField;
field.emit("end");
field.removeAllListeners("end");
}
part.on("header", function(header) {
let contype;
let fieldname;
let parsed;
let charset;
let encoding;
let filename;
let nsize = 0;
if (header["content-type"]) {
parsed = parseParams(header["content-type"][0]);
if (parsed[0]) {
contype = parsed[0].toLowerCase();
for (i = 0, len = parsed.length; i < len; ++i) {
if (RE_CHARSET.test(parsed[i][0])) {
charset = parsed[i][1].toLowerCase();
break;
}
}
}
}
if (contype === void 0) {
contype = "text/plain";
}
if (charset === void 0) {
charset = defCharset;
}
if (header["content-disposition"]) {
parsed = parseParams(header["content-disposition"][0]);
if (!RE_FIELD.test(parsed[0])) {
return skipPart(part);
}
for (i = 0, len = parsed.length; i < len; ++i) {
if (RE_NAME.test(parsed[i][0])) {
fieldname = parsed[i][1];
} else if (RE_FILENAME.test(parsed[i][0])) {
filename = parsed[i][1];
if (!preservePath) {
filename = basename(filename);
}
}
}
} else {
return skipPart(part);
}
if (header["content-transfer-encoding"]) {
encoding = header["content-transfer-encoding"][0].toLowerCase();
} else {
encoding = "7bit";
}
let onData, onEnd;
if (isPartAFile(fieldname, contype, filename)) {
if (nfiles === filesLimit) {
if (!boy.hitFilesLimit) {
boy.hitFilesLimit = true;
boy.emit("filesLimit");
}
return skipPart(part);
}
++nfiles;
if (!boy._events.file) {
self.parser._ignore();
return;
}
++nends;
const file = new FileStream(fileOpts);
curFile = file;
file.on("end", function() {
--nends;
self._pause = false;
checkFinished();
if (self._cb && !self._needDrain) {
const cb = self._cb;
self._cb = void 0;
cb();
}
});
file._read = function(n) {
if (!self._pause) {
return;
}
self._pause = false;
if (self._cb && !self._needDrain) {
const cb = self._cb;
self._cb = void 0;
cb();
}
};
boy.emit("file", fieldname, file, filename, encoding, contype);
onData = /* @__PURE__ */ __name(function(data) {
if ((nsize += data.length) > fileSizeLimit) {
const extralen = fileSizeLimit - nsize + data.length;
if (extralen > 0) {
file.push(data.slice(0, extralen));
}
file.truncated = true;
file.bytesRead = fileSizeLimit;
part.removeAllListeners("data");
file.emit("limit");
return;
} else if (!file.push(data)) {
self._pause = true;
}
file.bytesRead = nsize;
}, "onData");
onEnd = /* @__PURE__ */ __name(function() {
curFile = void 0;
file.push(null);
}, "onEnd");
} else {
if (nfields === fieldsLimit) {
if (!boy.hitFieldsLimit) {
boy.hitFieldsLimit = true;
boy.emit("fieldsLimit");
}
return skipPart(part);
}
++nfields;
++nends;
let buffer = "";
let truncated = false;
curField = part;
onData = /* @__PURE__ */ __name(function(data) {
if ((nsize += data.length) > fieldSizeLimit) {
const extralen = fieldSizeLimit - (nsize - data.length);
buffer += data.toString("binary", 0, extralen);
truncated = true;
part.removeAllListeners("data");
} else {
buffer += data.toString("binary");
}
}, "onData");
onEnd = /* @__PURE__ */ __name(function() {
curField = void 0;
if (buffer.length) {
buffer = decodeText(buffer, "binary", charset);
}
boy.emit("field", fieldname, buffer, false, truncated, encoding, contype);
--nends;
checkFinished();
}, "onEnd");
}
part._readableState.sync = false;
part.on("data", onData);
part.on("end", onEnd);
}).on("error", function(err) {
if (curFile) {
curFile.emit("error", err);
}
});
}, "onPart")).on("error", function(err) {
boy.emit("error", err);
}).on("finish", function() {
finished = true;
checkFinished();
});
}
__name(Multipart, "Multipart");
Multipart.prototype.write = function(chunk, cb) {
const r = this.parser.write(chunk);
if (r && !this._pause) {
cb();
} else {
this._needDrain = !r;
this._cb = cb;
}
};
Multipart.prototype.end = function() {
const self = this;
if (self.parser.writable) {
self.parser.end();
} else if (!self._boy._done) {
process.nextTick(function() {
self._boy._done = true;
self._boy.emit("finish");
});
}
};
function skipPart(part) {
part.resume();
}
__name(skipPart, "skipPart");
function FileStream(opts) {
Readable.call(this, opts);
this.bytesRead = 0;
this.truncated = false;
}
__name(FileStream, "FileStream");
inherits(FileStream, Readable);
FileStream.prototype._read = function(n) {
};
module2.exports = Multipart;
}
});
// node_modules/@fastify/busboy/lib/utils/Decoder.js
var require_Decoder = __commonJS({
"node_modules/@fastify/busboy/lib/utils/Decoder.js"(exports2, module2) {
"use strict";
var RE_PLUS = /\+/g;
var HEX = [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
];
function Decoder() {
this.buffer = void 0;
}
__name(Decoder, "Decoder");
Decoder.prototype.write = function(str) {
str = str.replace(RE_PLUS, " ");
let res = "";
let i = 0;
let p = 0;
const len = str.length;
for (; i < len; ++i) {
if (this.buffer !== void 0) {
if (!HEX[str.charCodeAt(i)]) {
res += "%" + this.buffer;
this.buffer = void 0;
--i;
} else {
this.buffer += str[i];
++p;
if (this.buffer.length === 2) {
res += String.fromCharCode(parseInt(this.buffer, 16));
this.buffer = void 0;
}
}
} else if (str[i] === "%") {
if (i > p) {
res += str.substring(p, i);
p = i;
}
this.buffer = "";
++p;
}
}
if (p < len && this.buffer === void 0) {
res += str.substring(p);
}
return res;
};
Decoder.prototype.reset = function() {
this.buffer = void 0;
};
module2.exports = Decoder;
}
});
// node_modules/@fastify/busboy/lib/types/urlencoded.js
var require_urlencoded = __commonJS({
"node_modules/@fastify/busboy/lib/types/urlencoded.js"(exports2, module2) {
"use strict";
var Decoder = require_Decoder();
var decodeText = require_decodeText();
var getLimit = require_getLimit();
var RE_CHARSET = /^charset$/i;
UrlEncoded.detect = /^application\/x-www-form-urlencoded/i;
function UrlEncoded(boy, cfg) {
const limits = cfg.limits;
const parsedConType = cfg.parsedConType;
this.boy = boy;
this.fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024);
this.fieldNameSizeLimit = getLimit(limits, "fieldNameSize", 100);
this.fieldsLimit = getLimit(limits, "fields", Infinity);
let charset;
for (var i = 0, len = parsedConType.length; i < len; ++i) {
if (Array.isArray(parsedConType[i]) && RE_CHARSET.test(parsedConType[i][0])) {
charset = parsedConType[i][1].toLowerCase();
break;
}
}
if (charset === void 0) {
charset = cfg.defCharset || "utf8";
}
this.decoder = new Decoder();
this.charset = charset;
this._fields = 0;
this._state = "key";
this._checkingBytes = true;
this._bytesKey = 0;
this._bytesVal = 0;
this._key = "";
this._val = "";
this._keyTrunc = false;
this._valTrunc = false;
this._hitLimit = false;
}
__name(UrlEncoded, "UrlEncoded");
UrlEncoded.prototype.write = function(data, cb) {
if (this._fields === this.fieldsLimit) {
if (!this.boy.hitFieldsLimit) {
this.boy.hitFieldsLimit = true;
this.boy.emit("fieldsLimit");
}
return cb();
}
let idxeq;
let idxamp;
let i;
let p = 0;
const len = data.length;
while (p < len) {
if (this._state === "key") {
idxeq = idxamp = void 0;
for (i = p; i < len; ++i) {
if (!this._checkingBytes) {
++p;
}
if (data[i] === 61) {
idxeq = i;
break;
} else if (data[i] === 38) {
idxamp = i;
break;
}
if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) {
this._hitLimit = true;
break;
} else if (this._checkingBytes) {
++this._bytesKey;
}
}
if (idxeq !== void 0) {
if (idxeq > p) {
this._key += this.decoder.write(data.toString("binary", p, idxeq));
}
this._state = "val";
this._hitLimit = false;
this._checkingBytes = true;
this._val = "";
this._bytesVal = 0;
this._valTrunc = false;
this.decoder.reset();
p = idxeq + 1;
} else if (idxamp !== void 0) {
++this._fields;
let key;
const keyTrunc = this._keyTrunc;
if (idxamp > p) {
key = this._key += this.decoder.write(data.toString("binary", p, idxamp));
} else {
key = this._key;
}
this._hitLimit = false;
this._checkingBytes = true;
this._key = "";
this._bytesKey = 0;
this._keyTrunc = false;
this.decoder.reset();
if (key.length) {
this.boy.emit(
"field",
decodeText(key, "binary", this.charset),
"",
keyTrunc,
false
);
}
p = idxamp + 1;
if (this._fields === this.fieldsLimit) {
return cb();
}
} else if (this._hitLimit) {
if (i > p) {
this._key += this.decoder.write(data.toString("binary", p, i));
}
p = i;
if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) {
this._checkingBytes = false;
this._keyTrunc = true;
}
} else {
if (p < len) {
this._key += this.decoder.write(data.toString("binary", p));
}
p = len;
}
} else {
idxamp = void 0;
for (i = p; i < len; ++i) {
if (!this._checkingBytes) {
++p;
}
if (data[i] === 38) {
idxamp = i;
break;
}
if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) {
this._hitLimit = true;
break;
} else if (this._checkingBytes) {
++this._bytesVal;
}
}
if (idxamp !== void 0) {
++this._fields;
if (idxamp > p) {
this._val += this.decoder.write(data.toString("binary", p, idxamp));
}
this.boy.emit(
"field",
decodeText(this._key, "binary", this.charset),
decodeText(this._val, "binary", this.charset),
this._keyTrunc,
this._valTrunc
);
this._state = "key";
this._hitLimit = false;
this._checkingBytes = true;
this._key = "";
this._bytesKey = 0;
this._keyTrunc = false;
this.decoder.reset();
p = idxamp + 1;
if (this._fields === this.fieldsLimit) {
return cb();
}
} else if (this._hitLimit) {
if (i > p) {
this._val += this.decoder.write(data.toString("binary", p, i));
}
p = i;
if (this._val === "" && this.fieldSizeLimit === 0 || (this._bytesVal = this._val.length) === this.fieldSizeLimit) {
this._checkingBytes = false;
this._valTrunc = true;
}
} else {
if (p < len) {
this._val += this.decoder.write(data.toString("binary", p));
}
p = len;
}
}
}
cb();
};
UrlEncoded.prototype.end = function() {
if (this.boy._done) {
return;
}
if (this._state === "key" && this._key.length > 0) {
this.boy.emit(
"field",
decodeText(this._key, "binary", this.charset),
"",
this._keyTrunc,
false
);
} else if (this._state === "val") {
this.boy.emit(
"field",
decodeText(this._key, "binary", this.charset),
decodeText(this._val, "binary", this.charset),
this._keyTrunc,
this._valTrunc
);
}
this.boy._done = true;
this.boy.emit("finish");
};
module2.exports = UrlEncoded;
}
});
// node_modules/@fastify/busboy/lib/main.js
var require_main = __commonJS({
"node_modules/@fastify/busboy/lib/main.js"(exports2, module2) {
"use strict";
var WritableStream = require("node:stream").Writable;
var { inherits } = require("node:util");
var Dicer = require_Dicer();
var MultipartParser = require_multipart();
var UrlencodedParser = require_urlencoded();
var parseParams = require_parseParams();
function Busboy(opts) {
if (!(this instanceof Busboy)) {
return new Busboy(opts);
}
if (typeof opts !== "object") {
throw new TypeError("Busboy expected an options-Object.");
}
if (typeof opts.headers !== "object") {
throw new TypeError("Busboy expected an options-Object with headers-attribute.");
}
if (typeof opts.headers["content-type"] !== "string") {
throw new TypeError("Missing Content-Type-header.");
}
const {
headers,
...streamOptions
} = opts;
this.opts = {
autoDestroy: false,
...streamOptions
};
WritableStream.call(this, this.opts);
this._done = false;
this._parser = this.getParserByHeaders(headers);
this._finished = false;
}
__name(Busboy, "Busboy");
inherits(Busboy, WritableStream);
Busboy.prototype.emit = function(ev) {
if (ev === "finish") {
if (!this._done) {
this._parser?.end();
return;
} else if (this._finished) {
return;
}
this._finished = true;
}
WritableStream.prototype.emit.apply(this, arguments);
};
Busboy.prototype.getParserByHeaders = function(headers) {
const parsed = parseParams(headers["content-type"]);
const cfg = {
defCharset: this.opts.defCharset,
fileHwm: this.opts.fileHwm,
headers,
highWaterMark: this.opts.highWaterMark,
isPartAFile: this.opts.isPartAFile,
limits: this.opts.limits,
parsedConType: parsed,
preservePath: this.opts.preservePath
};
if (MultipartParser.detect.test(parsed[0])) {
return new MultipartParser(this, cfg);
}
if (UrlencodedParser.detect.test(parsed[0])) {
return new UrlencodedParser(this, cfg);
}
throw new Error("Unsupported Content-Type.");
};
Busboy.prototype._write = function(chunk, encoding, cb) {
this._parser.write(chunk, cb);
};
module2.exports = Busboy;
module2.exports.default = Busboy;
module2.exports.Busboy = Busboy;
module2.exports.Dicer = Dicer;
}
});
// lib/fetch/file.js
var require_file = __commonJS({
"lib/fetch/file.js"(exports2, module2) {
"use strict";
var { Blob: Blob2, File: NativeFile } = require("node:buffer");
var { types } = require("node:util");
var { kState } = require_symbols2();
var { isBlobLike } = require_util2();
var { webidl } = require_webidl();
var { parseMIMEType, serializeAMimeType } = require_dataURL();
var { kEnumerableProperty } = require_util();
var encoder = new TextEncoder();
var File = class _File extends Blob2 {
static {
__name(this, "File");
}
constructor(fileBits, fileName, options = {}) {
webidl.argumentLengthCheck(arguments, 2, { header: "File constructor" });
fileBits = webidl.converters["sequence<BlobPart>"](fileBits);
fileName = webidl.converters.USVString(fileName);
options = webidl.converters.FilePropertyBag(options);
const n = fileName;
let t = options.type;
let d;
substep: {
if (t) {
t = parseMIMEType(t);
if (t === "failure") {
t = "";
break substep;
}
t = serializeAMimeType(t).toLowerCase();
}
d = options.lastModified;
}
super(processBlobParts(fileBits, options), { type: t });
this[kState] = {
name: n,
lastModified: d,
type: t
};
}
get name() {
webidl.brandCheck(this, _File);
return this[kState].name;
}
get lastModified() {
webidl.brandCheck(this, _File);
return this[kState].lastModified;
}
get type() {
webidl.brandCheck(this, _File);
return this[kState].type;
}
};
var FileLike = class _FileLike {
static {
__name(this, "FileLike");
}
constructor(blobLike, fileName, options = {}) {
const n = fileName;
const t = options.type;
const d = options.lastModified ?? Date.now();
this[kState] = {
blobLike,
name: n,
type: t,
lastModified: d
};
}
stream(...args) {
webidl.brandCheck(this, _FileLike);
return this[kState].blobLike.stream(...args);
}
arrayBuffer(...args) {
webidl.brandCheck(this, _FileLike);
return this[kState].blobLike.arrayBuffer(...args);
}
slice(...args) {
webidl.brandCheck(this, _FileLike);
return this[kState].blobLike.slice(...args);
}
text(...args) {
webidl.brandCheck(this, _FileLike);
return this[kState].blobLike.text(...args);
}
get size() {
webidl.brandCheck(this, _FileLike);
return this[kState].blobLike.size;
}
get type() {
webidl.brandCheck(this, _FileLike);
return this[kState].blobLike.type;
}
get name() {
webidl.brandCheck(this, _FileLike);
return this[kState].name;
}
get lastModified() {
webidl.brandCheck(this, _FileLike);
return this[kState].lastModified;
}
get [Symbol.toStringTag]() {
return "File";
}
};
Object.defineProperties(File.prototype, {
[Symbol.toStringTag]: {
value: "File",
configurable: true
},
name: kEnumerableProperty,
lastModified: kEnumerableProperty
});
webidl.converters.Blob = webidl.interfaceConverter(Blob2);
webidl.converters.BlobPart = function(V, opts) {
if (webidl.util.Type(V) === "Object") {
if (isBlobLike(V)) {
return webidl.converters.Blob(V, { strict: false });
}
if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) {
return webidl.converters.BufferSource(V, opts);
}
}
return webidl.converters.USVString(V, opts);
};
webidl.converters["sequence<BlobPart>"] = webidl.sequenceConverter(
webidl.converters.BlobPart
);
webidl.converters.FilePropertyBag = webidl.dictionaryConverter([
{
key: "lastModified",
converter: webidl.converters["long long"],
get defaultValue() {
return Date.now();
}
},
{
key: "type",
converter: webidl.converters.DOMString,
defaultValue: ""
},
{
key: "endings",
converter: (value) => {
value = webidl.converters.DOMString(value);
value = value.toLowerCase();
if (value !== "native") {
value = "transparent";
}
return value;
},
defaultValue: "transparent"
}
]);
function processBlobParts(parts, options) {
const bytes = [];
for (const element of parts) {
if (typeof element === "string") {
let s = element;
if (options.endings === "native") {
s = convertLineEndingsNative(s);
}
bytes.push(encoder.encode(s));
} else if (ArrayBuffer.isView(element) || types.isArrayBuffer(element)) {
if (element.buffer) {
bytes.push(
new Uint8Array(element.buffer, element.byteOffset, element.byteLength)
);
} else {
bytes.push(new Uint8Array(element));
}
} else if (isBlobLike(element)) {
bytes.push(element);
}
}
return bytes;
}
__name(processBlobParts, "processBlobParts");
function convertLineEndingsNative(s) {
let nativeLineEnding = "\n";
if (process.platform === "win32") {
nativeLineEnding = "\r\n";
}
return s.replace(/\r?\n/g, nativeLineEnding);
}
__name(convertLineEndingsNative, "convertLineEndingsNative");
function isFileLike(object) {
return NativeFile && object instanceof NativeFile || object instanceof File || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File";
}
__name(isFileLike, "isFileLike");
module2.exports = { File, FileLike, isFileLike };
}
});
// lib/fetch/formdata.js
var require_formdata = __commonJS({
"lib/fetch/formdata.js"(exports2, module2) {
"use strict";
var { isBlobLike, toUSVString, makeIterator } = require_util2();
var { kState } = require_symbols2();
var { kEnumerableProperty } = require_util();
var { File: UndiciFile, FileLike, isFileLike } = require_file();
var { webidl } = require_webidl();
var { File: NativeFile } = require("node:buffer");
var File = NativeFile ?? UndiciFile;
var FormData = class _FormData {
static {
__name(this, "FormData");
}
constructor(form) {
if (form !== void 0) {
throw webidl.errors.conversionFailed({
prefix: "FormData constructor",
argument: "Argument 1",
types: ["undefined"]
});
}
this[kState] = [];
}
append(name, value, filename = void 0) {
webidl.brandCheck(this, _FormData);
webidl.argumentLengthCheck(arguments, 2, { header: "FormData.append" });
if (arguments.length === 3 && !isBlobLike(value)) {
throw new TypeError(
"Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'"
);
}
name = webidl.converters.USVString(name);
value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value);
filename = arguments.length === 3 ? webidl.converters.USVString(filename) : void 0;
const entry = makeEntry(name, value, filename);
this[kState].push(entry);
}
delete(name) {
webidl.brandCheck(this, _FormData);
webidl.argumentLengthCheck(arguments, 1, { header: "FormData.delete" });
name = webidl.converters.USVString(name);
this[kState] = this[kState].filter((entry) => entry.name !== name);
}
get(name) {
webidl.brandCheck(this, _FormData);
webidl.argumentLengthCheck(arguments, 1, { header: "FormData.get" });
name = webidl.converters.USVString(name);
const idx = this[kState].findIndex((entry) => entry.name === name);
if (idx === -1) {
return null;
}
return this[kState][idx].value;
}
getAll(name) {
webidl.brandCheck(this, _FormData);
webidl.argumentLengthCheck(arguments, 1, { header: "FormData.getAll" });
name = webidl.converters.USVString(name);
return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value);
}
has(name) {
webidl.brandCheck(this, _FormData);
webidl.argumentLengthCheck(arguments, 1, { header: "FormData.has" });
name = webidl.converters.USVString(name);
return this[kState].findIndex((entry) => entry.name === name) !== -1;
}
set(name, value, filename = void 0) {
webidl.brandCheck(this, _FormData);
webidl.argumentLengthCheck(arguments, 2, { header: "FormData.set" });
if (arguments.length === 3 && !isBlobLike(value)) {
throw new TypeError(
"Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'"
);
}
name = webidl.converters.USVString(name);
value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value);
filename = arguments.length === 3 ? toUSVString(filename) : void 0;
const entry = makeEntry(name, value, filename);
const idx = this[kState].findIndex((entry2) => entry2.name === name);
if (idx !== -1) {
this[kState] = [
...this[kState].slice(0, idx),
entry,
...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name)
];
} else {
this[kState].push(entry);
}
}
entries() {
webidl.brandCheck(this, _FormData);
return makeIterator(
() => this[kState],
"FormData",
"key+value",
"name",
"value"
);
}
keys() {
webidl.brandCheck(this, _FormData);
return makeIterator(
() => this[kState],
"FormData",
"key",
"name",
"value"
);
}
values() {
webidl.brandCheck(this, _FormData);
return makeIterator(
() => this[kState],
"FormData",
"value",
"name",
"value"
);
}
/**
* @param {(value: string, key: string, self: FormData) => void} callbackFn
* @param {unknown} thisArg
*/
forEach(callbackFn, thisArg = globalThis) {
webidl.brandCheck(this, _FormData);
webidl.argumentLengthCheck(arguments, 1, { header: "FormData.forEach" });
if (typeof callbackFn !== "function") {
throw new TypeError(
"Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'."
);
}
for (const [key, value] of this) {
callbackFn.call(thisArg, value, key, this);
}
}
};
FormData.prototype[Symbol.iterator] = FormData.prototype.entries;
Object.defineProperties(FormData.prototype, {
append: kEnumerableProperty,
delete: kEnumerableProperty,
get: kEnumerableProperty,
getAll: kEnumerableProperty,
has: kEnumerableProperty,
set: kEnumerableProperty,
entries: kEnumerableProperty,
keys: kEnumerableProperty,
values: kEnumerableProperty,
forEach: kEnumerableProperty,
[Symbol.iterator]: { enumerable: false },
[Symbol.toStringTag]: {
value: "FormData",
configurable: true
}
});
function makeEntry(name, value, filename) {
name = Buffer.from(name).toString("utf8");
if (typeof value === "string") {
value = Buffer.from(value).toString("utf8");
} else {
if (!isFileLike(value)) {
value = value instanceof Blob ? new File([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type });
}
if (filename !== void 0) {
const options = {
type: value.type,
lastModified: value.lastModified
};
value = NativeFile && value instanceof NativeFile || value instanceof UndiciFile ? new File([value], filename, options) : new FileLike(value, filename, options);
}
}
return { name, value };
}
__name(makeEntry, "makeEntry");
module2.exports = { FormData };
}
});
// lib/fetch/body.js
var require_body = __commonJS({
"lib/fetch/body.js"(exports2, module2) {
"use strict";
var Busboy = require_main();
var util = require_util();
var {
ReadableStreamFrom,
isBlobLike,
isReadableStreamLike,
readableStreamClose,
createDeferredPromise,
fullyReadBody,
extractMimeType
} = require_util2();
var { FormData } = require_formdata();
var { kState } = require_symbols2();
var { webidl } = require_webidl();
var { Blob: Blob2, File: NativeFile } = require("node:buffer");
var { kBodyUsed } = require_symbols();
var assert = require("node:assert");
var { isErrored } = require_util();
var { isUint8Array, isArrayBuffer } = require("util/types");
var { File: UndiciFile } = require_file();
var { serializeAMimeType } = require_dataURL();
var File = NativeFile ?? UndiciFile;
var textEncoder = new TextEncoder();
var textDecoder = new TextDecoder();
function extractBody(object, keepalive = false) {
let stream = null;
if (object instanceof ReadableStream) {
stream = object;
} else if (isBlobLike(object)) {
stream = object.stream();
} else {
stream = new ReadableStream({
async pull(controller) {
const buffer = typeof source === "string" ? textEncoder.encode(source) : source;
if (buffer.byteLength) {
controller.enqueue(buffer);
}
queueMicrotask(() => readableStreamClose(controller));
},
start() {
},
type: "bytes"
});
}
assert(isReadableStreamLike(stream));
let action = null;
let source = null;
let length = null;
let type = null;
if (typeof object === "string") {
source = object;
type = "text/plain;charset=UTF-8";
} else if (object instanceof URLSearchParams) {
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 (util.isFormDataLike(object)) {
const boundary = `----formdata-undici-0${`${Math.floor(Math.random() * 1e11)}`.padStart(11, "0")}`;
const prefix = `--${boundary}\r
Content-Disposition: form-data`;
const escape = /* @__PURE__ */ __name((str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), "escape");
const normalizeLinefeeds = /* @__PURE__ */ __name((value) => value.replace(/\r?\n|\r/g, "\r\n"), "normalizeLinefeeds");
const blobParts = [];
const rn = new Uint8Array([13, 10]);
length = 0;
let hasUnknownSizeValue = false;
for (const [name, value] of object) {
if (typeof value === "string") {
const chunk2 = textEncoder.encode(prefix + `; name="${escape(normalizeLinefeeds(name))}"\r
\r
${normalizeLinefeeds(value)}\r
`);
blobParts.push(chunk2);
length += chunk2.byteLength;
} else {
const chunk2 = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape(value.name)}"` : "") + `\r
Content-Type: ${value.type || "application/octet-stream"}\r
\r
`);
blobParts.push(chunk2, value, rn);
if (typeof value.size === "number") {
length += chunk2.byteLength + value.size + rn.byteLength;
} else {
hasUnknownSizeValue = true;
}
}
}
const chunk = textEncoder.encode(`--${boundary}--`);
blobParts.push(chunk);
length += chunk.byteLength;
if (hasUnknownSizeValue) {
length = null;
}
source = object;
action = /* @__PURE__ */ __name(async function* () {
for (const part of blobParts) {
if (part.stream) {
yield* part.stream();
} else {
yield part;
}
}
}, "action");
type = `multipart/form-data; boundary=${boundary}`;
} else if (isBlobLike(object)) {
source = object;
length = object.size;
if (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 = object instanceof ReadableStream ? 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) {
const { value, done } = await iterator.next();
if (done) {
queueMicrotask(() => {
controller.close();
controller.byobRequest?.respond(0);
});
} else {
if (!isErrored(stream)) {
const buffer = new Uint8Array(value);
if (buffer.byteLength) {
controller.enqueue(buffer);
}
}
}
return controller.desiredSize > 0;
},
async cancel(reason) {
await iterator.return();
},
type: "bytes"
});
}
const body = { stream, source, length };
return [body, type];
}
__name(extractBody, "extractBody");
function safelyExtractBody(object, keepalive = false) {
if (object instanceof ReadableStream) {
assert(!util.isDisturbed(object), "The body has already been consumed.");
assert(!object.locked, "The stream is locked.");
}
return extractBody(object, keepalive);
}
__name(safelyExtractBody, "safelyExtractBody");
function cloneBody(body) {
const [out1, out2] = body.stream.tee();
const out2Clone = structuredClone(out2, { transfer: [out2] });
const [, finalClone] = out2Clone.tee();
body.stream = out1;
return {
stream: finalClone,
length: body.length,
source: body.source
};
}
__name(cloneBody, "cloneBody");
async function* consumeBody(body) {
if (body) {
if (isUint8Array(body)) {
yield body;
} else {
const stream = body.stream;
if (util.isDisturbed(stream)) {
throw new TypeError("The body has already been consumed.");
}
if (stream.locked) {
throw new TypeError("The stream is locked.");
}
stream[kBodyUsed] = true;
yield* stream;
}
}
}
__name(consumeBody, "consumeBody");
function throwIfAborted(state) {
if (state.aborted) {
throw new DOMException("The operation was aborted.", "AbortError");
}
}
__name(throwIfAborted, "throwIfAborted");
function bodyMixinMethods(instance) {
const methods = {
blob() {
return specConsumeBody(this, (bytes) => {
let mimeType = bodyMimeType(this);
if (mimeType === null) {
mimeType = "";
} else if (mimeType) {
mimeType = serializeAMimeType(mimeType);
}
return new Blob2([bytes], { type: mimeType });
}, instance);
},
arrayBuffer() {
return specConsumeBody(this, (bytes) => {
return new Uint8Array(bytes).buffer;
}, instance);
},
text() {
return specConsumeBody(this, utf8DecodeBytes, instance);
},
json() {
return specConsumeBody(this, parseJSONFromBytes, instance);
},
async formData() {
webidl.brandCheck(this, instance);
throwIfAborted(this[kState]);
const mimeType = bodyMimeType(this);
if (mimeType !== null && mimeType.essence === "multipart/form-data") {
const headers = {};
for (const [key, value] of this.headers)
headers[key] = value;
const responseFormData = new FormData();
let busboy;
try {
busboy = new Busboy({
headers,
preservePath: true
});
} catch (err) {
throw new DOMException(`${err}`, "AbortError");
}
busboy.on("field", (name, value) => {
responseFormData.append(name, value);
});
busboy.on("file", (name, value, filename, encoding, mimeType2) => {
const chunks = [];
if (encoding === "base64" || encoding.toLowerCase() === "base64") {
let base64chunk = "";
value.on("data", (chunk) => {
base64chunk += chunk.toString().replace(/[\r\n]/gm, "");
const end = base64chunk.length - base64chunk.length % 4;
chunks.push(Buffer.from(base64chunk.slice(0, end), "base64"));
base64chunk = base64chunk.slice(end);
});
value.on("end", () => {
chunks.push(Buffer.from(base64chunk, "base64"));
responseFormData.append(name, new File(chunks, filename, { type: mimeType2 }));
});
} else {
value.on("data", (chunk) => {
chunks.push(chunk);
});
value.on("end", () => {
responseFormData.append(name, new File(chunks, filename, { type: mimeType2 }));
});
}
});
const busboyResolve = new Promise((resolve, reject) => {
busboy.on("finish", resolve);
busboy.on("error", (err) => reject(new TypeError(err)));
});
if (this.body !== null)
for await (const chunk of consumeBody(this[kState].body))
busboy.write(chunk);
busboy.end();
await busboyResolve;
return responseFormData;
} else if (mimeType !== null && mimeType.essence === "application/x-www-form-urlencoded") {
let entries;
try {
let text = "";
const streamingDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
for await (const chunk of consumeBody(this[kState].body)) {
if (!isUint8Array(chunk)) {
throw new TypeError("Expected Uint8Array chunk");
}
text += streamingDecoder.decode(chunk, { stream: true });
}
text += streamingDecoder.decode();
entries = new URLSearchParams(text);
} catch (err) {
throw new TypeError(void 0, { cause: err });
}
const formData = new FormData();
for (const [name, value] of entries) {
formData.append(name, value);
}
return formData;
} else {
await Promise.resolve();
throwIfAborted(this[kState]);
throw webidl.errors.exception({
header: `${instance.name}.formData`,
message: "Could not parse content as FormData."
});
}
}
};
return methods;
}
__name(bodyMixinMethods, "bodyMixinMethods");
function mixinBody(prototype) {
Object.assign(prototype.prototype, bodyMixinMethods(prototype));
}
__name(mixinBody, "mixinBody");
async function specConsumeBody(object, convertBytesToJSValue, instance) {
webidl.brandCheck(object, instance);
throwIfAborted(object[kState]);
if (bodyUnusable(object[kState].body)) {
throw new TypeError("Body is unusable");
}
const promise = createDeferredPromise();
const errorSteps = /* @__PURE__ */ __name((error) => promise.reject(error), "errorSteps");
const successSteps = /* @__PURE__ */ __name((data) => {
try {
promise.resolve(convertBytesToJSValue(data));
} catch (e) {
errorSteps(e);
}
}, "successSteps");
if (object[kState].body == null) {
successSteps(new Uint8Array());
return promise.promise;
}
await fullyReadBody(object[kState].body, successSteps, errorSteps);
return promise.promise;
}
__name(specConsumeBody, "specConsumeBody");
function bodyUnusable(body) {
return body != null && (body.stream.locked || util.isDisturbed(body.stream));
}
__name(bodyUnusable, "bodyUnusable");
function utf8DecodeBytes(buffer) {
if (buffer.length === 0) {
return "";
}
if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
buffer = buffer.subarray(3);
}
const output = textDecoder.decode(buffer);
return output;
}
__name(utf8DecodeBytes, "utf8DecodeBytes");
function parseJSONFromBytes(bytes) {
return JSON.parse(utf8DecodeBytes(bytes));
}
__name(parseJSONFromBytes, "parseJSONFromBytes");
function bodyMimeType(requestOrResponse) {
const headers = requestOrResponse[kState].headersList;
const mimeType = extractMimeType(headers);
if (mimeType === "failure") {
return null;
}
return mimeType;
}
__name(bodyMimeType, "bodyMimeType");
module2.exports = {
extractBody,
safelyExtractBody,
cloneBody,
mixinBody
};
}
});
// lib/fetch/response.js
var require_response = __commonJS({
"lib/fetch/response.js"(exports2, module2) {
"use strict";
var { Headers, HeadersList, fill } = require_headers();
var { extractBody, cloneBody, mixinBody } = require_body();
var util = require_util();
var { kEnumerableProperty } = util;
var {
isValidReasonPhrase,
isCancelled,
isAborted,
isBlobLike,
serializeJavascriptValueToJSONString,
isErrorLike,
isomorphicEncode
} = require_util2();
var {
redirectStatusSet,
nullBodyStatus
} = require_constants2();
var { kState, kHeaders, kGuard, kRealm } = require_symbols2();
var { webidl } = require_webidl();
var { FormData } = require_formdata();
var { getGlobalOrigin } = require_global();
var { URLSerializer } = require_dataURL();
var { kHeadersList, kConstruct } = require_symbols();
var assert = require("node:assert");
var { types } = require("node:util");
var textEncoder = new TextEncoder("utf-8");
var Response = class _Response {
static {
__name(this, "Response");
}
// Creates network error Response.
static error() {
const relevantRealm = { settingsObject: {} };
const responseObject = fromInnerResponse(makeNetworkError(), "immutable", relevantRealm);
return responseObject;
}
// https://fetch.spec.whatwg.org/#dom-response-json
static json(data, init = {}) {
webidl.argumentLengthCheck(arguments, 1, { header: "Response.json" });
if (init !== null) {
init = webidl.converters.ResponseInit(init);
}
const bytes = textEncoder.encode(
serializeJavascriptValueToJSONString(data)
);
const body = extractBody(bytes);
const relevantRealm = { settingsObject: {} };
const responseObject = fromInnerResponse(makeResponse({}), "response", relevantRealm);
initializeResponse(responseObject, init, { body: body[0], type: "application/json" });
return responseObject;
}
// Creates a redirect Response that redirects to url with status status.
static redirect(url, status = 302) {
const relevantRealm = { settingsObject: {} };
webidl.argumentLengthCheck(arguments, 1, { header: "Response.redirect" });
url = webidl.converters.USVString(url);
status = webidl.converters["unsigned short"](status);
let parsedURL;
try {
parsedURL = new URL(url, getGlobalOrigin());
} catch (err) {
throw new TypeError(`Failed to parse URL from ${url}`, { cause: err });
}
if (!redirectStatusSet.has(status)) {
throw new RangeError(`Invalid status code ${status}`);
}
const responseObject = fromInnerResponse(makeResponse({}), "immutable", relevantRealm);
responseObject[kState].status = status;
const value = isomorphicEncode(URLSerializer(parsedURL));
responseObject[kState].headersList.append("location", value, true);
return responseObject;
}
// https://fetch.spec.whatwg.org/#dom-response
constructor(body = null, init = {}) {
if (body === kConstruct) {
return;
}
if (body !== null) {
body = webidl.converters.BodyInit(body);
}
init = webidl.converters.ResponseInit(init);
this[kRealm] = { settingsObject: {} };
this[kState] = makeResponse({});
this[kHeaders] = new Headers(kConstruct);
this[kHeaders][kGuard] = "response";
this[kHeaders][kHeadersList] = this[kState].headersList;
this[kHeaders][kRealm] = this[kRealm];
let bodyWithType = null;
if (body != null) {
const [extractedBody, type] = extractBody(body);
bodyWithType = { body: extractedBody, type };
}
initializeResponse(this, init, bodyWithType);
}
// Returns response’s type, e.g., "cors".
get type() {
webidl.brandCheck(this, _Response);
return this[kState].type;
}
// Returns response’s URL, if it has one; otherwise the empty string.
get url() {
webidl.brandCheck(this, _Response);
const urlList = this[kState].urlList;
const url = urlList[urlList.length - 1] ?? null;
if (url === null) {
return "";
}
return URLSerializer(url, true);
}
// Returns whether response was obtained through a redirect.
get redirected() {
webidl.brandCheck(this, _Response);
return this[kState].urlList.length > 1;
}
// Returns response’s status.
get status() {
webidl.brandCheck(this, _Response);
return this[kState].status;
}
// Returns whether response’s status is an ok status.
get ok() {
webidl.brandCheck(this, _Response);
return this[kState].status >= 200 && this[kState].status <= 299;
}
// Returns response’s status message.
get statusText() {
webidl.brandCheck(this, _Response);
return this[kState].statusText;
}
// Returns response’s headers as Headers.
get headers() {
webidl.brandCheck(this, _Response);
return this[kHeaders];
}
get body() {
webidl.brandCheck(this, _Response);
return this[kState].body ? this[kState].body.stream : null;
}
get bodyUsed() {
webidl.brandCheck(this, _Response);
return !!this[kState].body && util.isDisturbed(this[kState].body.stream);
}
// Returns a clone of response.
clone() {
webidl.brandCheck(this, _Response);
if (this.bodyUsed || this.body?.locked) {
throw webidl.errors.exception({
header: "Response.clone",
message: "Body has already been consumed."
});
}
const clonedResponse = cloneResponse(this[kState]);
return fromInnerResponse(clonedResponse, this[kHeaders][kGuard], this[kRealm]);
}
};
mixinBody(Response);
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: true
}
});
Object.defineProperties(Response, {
json: kEnumerableProperty,
redirect: kEnumerableProperty,
error: kEnumerableProperty
});
function cloneResponse(response) {
if (response.internalResponse) {
return filterResponse(
cloneResponse(response.internalResponse),
response.type
);
}
const newResponse = makeResponse({ ...response, body: null });
if (response.body != null) {
newResponse.body = cloneBody(response.body);
}
return newResponse;
}
__name(cloneResponse, "cloneResponse");
function makeResponse(init) {
return {
aborted: false,
rangeRequested: false,
timingAllowPassed: false,
requestIncludesCredentials: false,
type: "default",
status: 200,
timingInfo: null,
cacheState: "",
statusText: "",
...init,
headersList: init?.headersList ? new HeadersList(init?.headersList) : new HeadersList(),
urlList: init?.urlList ? [...init.urlList] : []
};
}
__name(makeResponse, "makeResponse");
function makeNetworkError(reason) {
const isError = isErrorLike(reason);
return makeResponse({
type: "error",
status: 0,
error: isError ? reason : new Error(reason ? String(reason) : reason),
aborted: reason && reason.name === "AbortError"
});
}
__name(makeNetworkError, "makeNetworkError");
function isNetworkError(response) {
return (
// A network error is a response whose type is "error",
response.type === "error" && // status is 0
response.status === 0
);
}
__name(isNetworkError, "isNetworkError");
function makeFilteredResponse(response, state) {
state = {
internalResponse: response,
...state
};
return new Proxy(response, {
get(target, p) {
return p in state ? state[p] : target[p];
},
set(target, p, value) {
assert(!(p in state));
target[p] = value;
return true;
}
});
}
__name(makeFilteredResponse, "makeFilteredResponse");
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(false);
}
}
__name(filterResponse, "filterResponse");
function makeAppropriateNetworkError(fetchParams, err = null) {
assert(isCancelled(fetchParams));
return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException("Request was cancelled."), { cause: err }));
}
__name(makeAppropriateNetworkError, "makeAppropriateNetworkError");
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) {
response[kState].status = init.status;
}
if ("statusText" in init && init.statusText != null) {
response[kState].statusText = init.statusText;
}
if ("headers" in init && init.headers != null) {
fill(response[kHeaders], init.headers);
}
if (body) {
if (nullBodyStatus.includes(response.status)) {
throw webidl.errors.exception({
header: "Response constructor",
message: `Invalid response status code ${response.status}`
});
}
response[kState].body = body.body;
if (body.type != null && !response[kState].headersList.contains("content-type", true)) {
response[kState].headersList.append("content-type", body.type, true);
}
}
}
__name(initializeResponse, "initializeResponse");
function fromInnerResponse(innerResponse, guard, realm) {
const response = new Response(kConstruct);
response[kState] = innerResponse;
response[kRealm] = realm;
response[kHeaders] = new Headers(kConstruct);
response[kHeaders][kHeadersList] = innerResponse.headersList;
response[kHeaders][kGuard] = guard;
response[kHeaders][kRealm] = realm;
return response;
}
__name(fromInnerResponse, "fromInnerResponse");
webidl.converters.ReadableStream = webidl.interfaceConverter(
ReadableStream
);
webidl.converters.FormData = webidl.interfaceConverter(
FormData
);
webidl.converters.URLSearchParams = webidl.interfaceConverter(
URLSearchParams
);
webidl.converters.XMLHttpRequestBodyInit = function(V) {
if (typeof V === "string") {
return webidl.converters.USVString(V);
}
if (isBlobLike(V)) {
return webidl.converters.Blob(V, { strict: false });
}
if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
return webidl.converters.BufferSource(V);
}
if (util.isFormDataLike(V)) {
return webidl.converters.FormData(V, { strict: false });
}
if (V instanceof URLSearchParams) {
return webidl.converters.URLSearchParams(V);
}
return webidl.converters.DOMString(V);
};
webidl.converters.BodyInit = function(V) {
if (V instanceof ReadableStream) {
return webidl.converters.ReadableStream(V);
}
if (V?.[Symbol.asyncIterator]) {
return V;
}
return webidl.converters.XMLHttpRequestBodyInit(V);
};
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
}
]);
module2.exports = {
isNetworkError,
makeNetworkError,
makeResponse,
makeAppropriateNetworkError,
filterResponse,
Response,
cloneResponse,
fromInnerResponse
};
}
});
// lib/compat/dispatcher-weakref.js
var require_dispatcher_weakref = __commonJS({
"lib/compat/dispatcher-weakref.js"(exports2, module2) {
"use strict";
var { kConnected, kSize } = require_symbols();
var CompatWeakRef = class {
static {
__name(this, "CompatWeakRef");
}
constructor(value) {
this.value = value;
}
deref() {
return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value;
}
};
var CompatFinalizer = class {
static {
__name(this, "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) {
}
};
module2.exports = function() {
if (process.env.NODE_V8_COVERAGE) {
return {
WeakRef: CompatWeakRef,
FinalizationRegistry: CompatFinalizer
};
}
return { WeakRef, FinalizationRegistry };
};
}
});
// lib/fetch/request.js
var require_request = __commonJS({
"lib/fetch/request.js"(exports2, module2) {
"use strict";
var { extractBody, mixinBody, cloneBody } = require_body();
var { Headers, fill: fillHeaders, HeadersList } = require_headers();
var { FinalizationRegistry: FinalizationRegistry2 } = require_dispatcher_weakref()();
var util = require_util();
var {
isValidHTTPToken,
sameOrigin,
normalizeMethod,
makePolicyContainer,
normalizeMethodRecord
} = require_util2();
var {
forbiddenMethodsSet,
corsSafeListedMethodsSet,
referrerPolicy,
requestRedirect,
requestMode,
requestCredentials,
requestCache,
requestDuplex
} = require_constants2();
var { kEnumerableProperty } = util;
var { kHeaders, kSignal, kState, kGuard, kRealm } = require_symbols2();
var { webidl } = require_webidl();
var { getGlobalOrigin } = require_global();
var { URLSerializer } = require_dataURL();
var { kHeadersList, kConstruct } = require_symbols();
var assert = require("node:assert");
var { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = require("node:events");
var kAbortController = Symbol("abortController");
var requestFinalizer = new FinalizationRegistry2(({ signal, abort }) => {
signal.removeEventListener("abort", abort);
});
var patchMethodWarning = false;
var Request = class _Request {
static {
__name(this, "Request");
}
// https://fetch.spec.whatwg.org/#dom-request
constructor(input, init = {}) {
if (input === kConstruct) {
return;
}
webidl.argumentLengthCheck(arguments, 1, { header: "Request constructor" });
input = webidl.converters.RequestInfo(input);
init = webidl.converters.RequestInit(init);
this[kRealm] = {
settingsObject: {
baseUrl: getGlobalOrigin(),
get origin() {
return this.baseUrl?.origin;
},
policyContainer: makePolicyContainer()
}
};
let request = null;
let fallbackMode = null;
const baseUrl = this[kRealm].settingsObject.baseUrl;
let signal = null;
if (typeof input === "string") {
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(input instanceof _Request);
request = input[kState];
signal = input[kSignal];
}
const origin = this[kRealm].settingsObject.origin;
let 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({
// URL request’s URL.
// undici implementation note: this is set as the first item in request's urlList in makeRequest
// method request’s method.
method: request.method,
// header list A copy of request’s header list.
// undici implementation note: headersList is cloned in makeRequest
headersList: request.headersList,
// unsafe-request flag Set.
unsafeRequest: request.unsafeRequest,
// client This’s relevant settings object.
client: this[kRealm].settingsObject,
// window window.
window,
// priority request’s priority.
priority: request.priority,
// origin request’s origin. The propagation of the origin is only significant for navigation requests
// being handled by a service worker. In this scenario a request can have an origin that is different
// from the current client.
origin: request.origin,
// referrer request’s referrer.
referrer: request.referrer,
// referrer policy request’s referrer policy.
referrerPolicy: request.referrerPolicy,
// mode request’s mode.
mode: request.mode,
// credentials mode request’s credentials mode.
credentials: request.credentials,
// cache mode request’s cache mode.
cache: request.cache,
// redirect mode request’s redirect mode.
redirect: request.redirect,
// integrity metadata request’s integrity metadata.
integrity: request.integrity,
// keepalive request’s keepalive.
keepalive: request.keepalive,
// reload-navigation flag request’s reload-navigation flag.
reloadNavigation: request.reloadNavigation,
// history-navigation flag request’s history-navigation flag.
historyNavigation: request.historyNavigation,
// URL list A clone of request’s URL list.
urlList: [...request.urlList]
});
const initHasKey = Object.keys(init).length !== 0;
if (initHasKey) {
if (request.mode === "navigate") {
request.mode = "same-origin";
}
request.reloadNavigation = false;
request.historyNavigation = false;
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) {
const 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, this[kRealm].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;
const mayBeNormalized = normalizeMethodRecord[method];
if (mayBeNormalized !== void 0) {
request.method = mayBeNormalized;
} else {
if (!isValidHTTPToken(method)) {
throw new TypeError(`'${method}' is not a valid HTTP method.`);
}
if (forbiddenMethodsSet.has(method.toUpperCase())) {
throw new TypeError(`'${method}' HTTP method is unsupported.`);
}
method = normalizeMethod(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 = true;
}
}
if (init.signal !== void 0) {
signal = init.signal;
}
this[kState] = request;
const ac = new AbortController();
this[kSignal] = ac.signal;
this[kSignal][kRealm] = this[kRealm];
if (signal != null) {
if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") {
throw new TypeError(
"Failed to construct 'Request': member signal is not of type AbortSignal."
);
}
if (signal.aborted) {
ac.abort(signal.reason);
} else {
this[kAbortController] = ac;
const acRef = new WeakRef(ac);
const abort = /* @__PURE__ */ __name(function() {
const ac2 = acRef.deref();
if (ac2 !== void 0) {
requestFinalizer.unregister(abort);
this.removeEventListener("abort", abort);
ac2.abort(this.reason);
}
}, "abort");
try {
if (typeof getMaxListeners === "function" && getMaxListeners(signal) === defaultMaxListeners) {
setMaxListeners(100, signal);
} else if (getEventListeners(signal, "abort").length >= defaultMaxListeners) {
setMaxListeners(100, signal);
}
} catch {
}
util.addAbortListener(signal, abort);
requestFinalizer.register(ac, { signal, abort }, abort);
}
}
this[kHeaders] = new Headers(kConstruct);
this[kHeaders][kHeadersList] = request.headersList;
this[kHeaders][kGuard] = "request";
this[kHeaders][kRealm] = this[kRealm];
if (mode === "no-cors") {
if (!corsSafeListedMethodsSet.has(request.method)) {
throw new TypeError(
`'${request.method} is unsupported in no-cors mode.`
);
}
this[kHeaders][kGuard] = "request-no-cors";
}
if (initHasKey) {
const headersList = this[kHeaders][kHeadersList];
const headers = init.headers !== void 0 ? init.headers : new HeadersList(headersList);
headersList.clear();
if (headers instanceof HeadersList) {
for (const [key, val] of headers) {
headersList.append(key, val);
}
headersList.cookies = headers.cookies;
} else {
fillHeaders(this[kHeaders], headers);
}
}
const inputBody = input instanceof _Request ? input[kState].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) {
const [extractedBody, contentType] = extractBody(
init.body,
request.keepalive
);
initBody = extractedBody;
if (contentType && !this[kHeaders][kHeadersList].contains("content-type", true)) {
this[kHeaders].append("content-type", contentType);
}
}
const 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 = true;
}
let finalBody = inputOrInitBody;
if (initBody == null && inputBody != null) {
if (util.isDisturbed(inputBody.stream) || inputBody.stream.locked) {
throw new TypeError(
"Cannot construct a Request with a Request object that has already been used."
);
}
const identityTransform = new TransformStream();
inputBody.stream.pipeThrough(identityTransform);
finalBody = {
source: inputBody.source,
length: inputBody.length,
stream: identityTransform.readable
};
}
this[kState].body = finalBody;
}
// Returns request’s HTTP method, which is "GET" by default.
get method() {
webidl.brandCheck(this, _Request);
return this[kState].method;
}
// Returns the URL of request as a string.
get url() {
webidl.brandCheck(this, _Request);
return URLSerializer(this[kState].url);
}
// Returns a Headers object consisting of the headers associated with request.
// Note that headers added in the network layer by the user agent will not
// be accounted for in this object, e.g., the "Host" header.
get headers() {
webidl.brandCheck(this, _Request);
return this[kHeaders];
}
// Returns the kind of resource requested by request, e.g., "document"
// or "script".
get destination() {
webidl.brandCheck(this, _Request);
return this[kState].destination;
}
// Returns the referrer of request. Its value can be a same-origin URL if
// explicitly set in init, the empty string to indicate no referrer, and
// "about:client" when defaulting to the global’s default. This is used
// during fetching to determine the value of the `Referer` header of the
// request being made.
get referrer() {
webidl.brandCheck(this, _Request);
if (this[kState].referrer === "no-referrer") {
return "";
}
if (this[kState].referrer === "client") {
return "about:client";
}
return this[kState].referrer.toString();
}
// Returns the referrer policy associated with request.
// This is used during fetching to compute the value of the request’s
// referrer.
get referrerPolicy() {
webidl.brandCheck(this, _Request);
return this[kState].referrerPolicy;
}
// Returns the mode associated with request, which is a string indicating
// whether the request will use CORS, or will be restricted to same-origin
// URLs.
get mode() {
webidl.brandCheck(this, _Request);
return this[kState].mode;
}
// Returns the credentials mode associated with request,
// which is a string indicating whether credentials will be sent with the
// request always, never, or only when sent to a same-origin URL.
get credentials() {
return this[kState].credentials;
}
// Returns the cache mode associated with request,
// which is a string indicating how the request will
// interact with the browser’s cache when fetching.
get cache() {
webidl.brandCheck(this, _Request);
return this[kState].cache;
}
// Returns the redirect mode associated with request,
// which is a string indicating how redirects for the
// request will be handled during fetching. A request
// will follow redirects by default.
get redirect() {
webidl.brandCheck(this, _Request);
return this[kState].redirect;
}
// Returns request’s subresource integrity metadata, which is a
// cryptographic hash of the resource being fetched. Its value
// consists of multiple hashes separated by whitespace. [SRI]
get integrity() {
webidl.brandCheck(this, _Request);
return this[kState].integrity;
}
// Returns a boolean indicating whether or not request can outlive the
// global in which it was created.
get keepalive() {
webidl.brandCheck(this, _Request);
return this[kState].keepalive;
}
// Returns a boolean indicating whether or not request is for a reload
// navigation.
get isReloadNavigation() {
webidl.brandCheck(this, _Request);
return this[kState].reloadNavigation;
}
// Returns a boolean indicating whether or not request is for a history
// navigation (a.k.a. back-foward navigation).
get isHistoryNavigation() {
webidl.brandCheck(this, _Request);
return this[kState].historyNavigation;
}
// Returns the signal associated with request, which is an AbortSignal
// object indicating whether or not request has been aborted, and its
// abort event handler.
get signal() {
webidl.brandCheck(this, _Request);
return this[kSignal];
}
get body() {
webidl.brandCheck(this, _Request);
return this[kState].body ? this[kState].body.stream : null;
}
get bodyUsed() {
webidl.brandCheck(this, _Request);
return !!this[kState].body && util.isDisturbed(this[kState].body.stream);
}
get duplex() {
webidl.brandCheck(this, _Request);
return "half";
}
// Returns a clone of request.
clone() {
webidl.brandCheck(this, _Request);
if (this.bodyUsed || this.body?.locked) {
throw new TypeError("unusable");
}
const clonedRequest = cloneRequest(this[kState]);
const ac = new AbortController();
if (this.signal.aborted) {
ac.abort(this.signal.reason);
} else {
util.addAbortListener(
this.signal,
() => {
ac.abort(this.signal.reason);
}
);
}
return fromInnerRequest(clonedRequest, ac.signal, this[kHeaders][kGuard], this[kRealm]);
}
};
mixinBody(Request);
function makeRequest(init) {
const request = {
method: "GET",
localURLsOnly: false,
unsafeRequest: false,
body: null,
client: null,
reservedClient: null,
replacesClientId: "",
window: "client",
keepalive: false,
serviceWorkers: "all",
initiator: "",
destination: "",
priority: null,
origin: "client",
policyContainer: "client",
referrer: "client",
referrerPolicy: "",
mode: "no-cors",
useCORSPreflightFlag: false,
credentials: "same-origin",
useCredentials: false,
cache: "default",
redirect: "follow",
integrity: "",
cryptoGraphicsNonceMetadata: "",
parserMetadata: "",
reloadNavigation: false,
historyNavigation: false,
userActivation: false,
taintedOrigin: false,
redirectCount: 0,
responseTainting: "basic",
preventNoCacheCacheControlHeaderModification: false,
done: false,
timingAllowFailed: false,
...init,
headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList()
};
request.url = request.urlList[0];
return request;
}
__name(makeRequest, "makeRequest");
function cloneRequest(request) {
const newRequest = makeRequest({ ...request, body: null });
if (request.body != null) {
newRequest.body = cloneBody(request.body);
}
return newRequest;
}
__name(cloneRequest, "cloneRequest");
function fromInnerRequest(innerRequest, signal, guard, realm) {
const request = new Request(kConstruct);
request[kState] = innerRequest;
request[kRealm] = realm;
request[kSignal] = signal;
request[kSignal][kRealm] = realm;
request[kHeaders] = new Headers(kConstruct);
request[kHeaders][kHeadersList] = innerRequest.headersList;
request[kHeaders][kGuard] = guard;
request[kHeaders][kRealm] = realm;
return request;
}
__name(fromInnerRequest, "fromInnerRequest");
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: true
}
});
webidl.converters.Request = webidl.interfaceConverter(
Request
);
webidl.converters.RequestInfo = function(V) {
if (typeof V === "string") {
return webidl.converters.USVString(V);
}
if (V instanceof Request) {
return webidl.converters.Request(V);
}
return webidl.converters.USVString(V);
};
webidl.converters.AbortSignal = webidl.interfaceConverter(
AbortSignal
);
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,
// https://w3c.github.io/webappsec-referrer-policy/#referrer-policy
allowedValues: referrerPolicy
},
{
key: "mode",
converter: webidl.converters.DOMString,
// https://fetch.spec.whatwg.org/#concept-request-mode
allowedValues: requestMode
},
{
key: "credentials",
converter: webidl.converters.DOMString,
// https://fetch.spec.whatwg.org/#requestcredentials
allowedValues: requestCredentials
},
{
key: "cache",
converter: webidl.converters.DOMString,
// https://fetch.spec.whatwg.org/#requestcache
allowedValues: requestCache
},
{
key: "redirect",
converter: webidl.converters.DOMString,
// https://fetch.spec.whatwg.org/#requestredirect
allowedValues: requestRedirect
},
{
key: "integrity",
converter: webidl.converters.DOMString
},
{
key: "keepalive",
converter: webidl.converters.boolean
},
{
key: "signal",
converter: webidl.nullableConverter(
(signal) => webidl.converters.AbortSignal(
signal,
{ strict: false }
)
)
},
{
key: "window",
converter: webidl.converters.any
},
{
key: "duplex",
converter: webidl.converters.DOMString,
allowedValues: requestDuplex
}
]);
module2.exports = { Request, makeRequest, fromInnerRequest };
}
});
// lib/dispatcher.js
var require_dispatcher = __commonJS({
"lib/dispatcher.js"(exports2, module2) {
"use strict";
var EventEmitter = require("node:events");
var Dispatcher = class extends EventEmitter {
static {
__name(this, "Dispatcher");
}
dispatch() {
throw new Error("not implemented");
}
close() {
throw new Error("not implemented");
}
destroy() {
throw new Error("not implemented");
}
};
module2.exports = Dispatcher;
}
});
// lib/dispatcher-base.js
var require_dispatcher_base = __commonJS({
"lib/dispatcher-base.js"(exports2, module2) {
"use strict";
var Dispatcher = require_dispatcher();
var {
ClientDestroyedError,
ClientClosedError,
InvalidArgumentError
} = require_errors();
var { kDestroy, kClose, kDispatch, kInterceptors } = require_symbols();
var kDestroyed = Symbol("destroyed");
var kClosed = Symbol("closed");
var kOnDestroyed = Symbol("onDestroyed");
var kOnClosed = Symbol("onClosed");
var kInterceptedDispatch = Symbol("Intercepted Dispatch");
var DispatcherBase = class extends Dispatcher {
static {
__name(this, "DispatcherBase");
}
constructor() {
super();
this[kDestroyed] = false;
this[kOnDestroyed] = null;
this[kClosed] = false;
this[kOnClosed] = [];
}
get destroyed() {
return this[kDestroyed];
}
get closed() {
return this[kClosed];
}
get interceptors() {
return this[kInterceptors];
}
set interceptors(newInterceptors) {
if (newInterceptors) {
for (let i = newInterceptors.length - 1; i >= 0; i--) {
const interceptor = this[kInterceptors][i];
if (typeof interceptor !== "function") {
throw new InvalidArgumentError("interceptor must be an function");
}
}
}
this[kInterceptors] = newInterceptors;
}
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] = true;
this[kOnClosed].push(callback);
const onClosed = /* @__PURE__ */ __name(() => {
const callbacks = this[kOnClosed];
this[kOnClosed] = null;
for (let i = 0; i < callbacks.length; i++) {
callbacks[i](null, null);
}
}, "onClosed");
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 ? (
/* istanbul ignore next: should never error */
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] = true;
this[kOnDestroyed] = this[kOnDestroyed] || [];
this[kOnDestroyed].push(callback);
const onDestroyed = /* @__PURE__ */ __name(() => {
const callbacks = this[kOnDestroyed];
this[kOnDestroyed] = null;
for (let i = 0; i < callbacks.length; i++) {
callbacks[i](null, null);
}
}, "onDestroyed");
this[kDestroy](err).then(() => {
queueMicrotask(onDestroyed);
});
}
[kInterceptedDispatch](opts, handler) {
if (!this[kInterceptors] || this[kInterceptors].length === 0) {
this[kInterceptedDispatch] = this[kDispatch];
return this[kDispatch](opts, handler);
}
let dispatch = this[kDispatch].bind(this);
for (let i = this[kInterceptors].length - 1; i >= 0; i--) {
dispatch = this[kInterceptors][i](dispatch);
}
this[kInterceptedDispatch] = dispatch;
return dispatch(opts, handler);
}
dispatch(opts, handler) {
if (!handler || typeof handler !== "object") {
throw new InvalidArgumentError("handler must be an object");
}
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[kInterceptedDispatch](opts, handler);
} catch (err) {
if (typeof handler.onError !== "function") {
throw new InvalidArgumentError("invalid onError method");
}
handler.onError(err);
return false;
}
}
};
module2.exports = DispatcherBase;
}
});
// lib/node/fixed-queue.js
var require_fixed_queue = __commonJS({
"lib/node/fixed-queue.js"(exports2, module2) {
"use strict";
var kSize = 2048;
var kMask = kSize - 1;
var FixedCircularBuffer = class {
static {
__name(this, "FixedCircularBuffer");
}
constructor() {
this.bottom = 0;
this.top = 0;
this.list = new Array(kSize);
this.next = null;
}
isEmpty() {
return this.top === this.bottom;
}
isFull() {
return (this.top + 1 & kMask) === this.bottom;
}
push(data) {
this.list[this.top] = data;
this.top = this.top + 1 & kMask;
}
shift() {
const nextItem = this.list[this.bottom];
if (nextItem === void 0)
return null;
this.list[this.bottom] = void 0;
this.bottom = this.bottom + 1 & kMask;
return nextItem;
}
};
module2.exports = class FixedQueue {
static {
__name(this, "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() {
const tail = this.tail;
const next = tail.shift();
if (tail.isEmpty() && tail.next !== null) {
this.tail = tail.next;
}
return next;
}
};
}
});
// lib/pool-stats.js
var require_pool_stats = __commonJS({
"lib/pool-stats.js"(exports2, module2) {
var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols();
var kPool = Symbol("pool");
var PoolStats = class {
static {
__name(this, "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];
}
};
module2.exports = PoolStats;
}
});
// lib/pool-base.js
var require_pool_base = __commonJS({
"lib/pool-base.js"(exports2, module2) {
"use strict";
var DispatcherBase = require_dispatcher_base();
var FixedQueue = require_fixed_queue();
var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols();
var PoolStats = require_pool_stats();
var kClients = Symbol("clients");
var kNeedDrain = Symbol("needDrain");
var kQueue = Symbol("queue");
var kClosedResolve = Symbol("closed resolve");
var kOnDrain = Symbol("onDrain");
var kOnConnect = Symbol("onConnect");
var kOnDisconnect = Symbol("onDisconnect");
var kOnConnectionError = Symbol("onConnectionError");
var kGetDispatcher = Symbol("get dispatcher");
var kAddClient = Symbol("add client");
var kRemoveClient = Symbol("remove client");
var kStats = Symbol("stats");
var PoolBase = class extends DispatcherBase {
static {
__name(this, "PoolBase");
}
constructor() {
super();
this[kQueue] = new FixedQueue();
this[kClients] = [];
this[kQueued] = 0;
const pool = this;
this[kOnDrain] = /* @__PURE__ */ __name(function onDrain(origin, targets) {
const queue = pool[kQueue];
let needDrain = false;
while (!needDrain) {
const item = queue.shift();
if (!item) {
break;
}
pool[kQueued]--;
needDrain = !this.dispatch(item.opts, item.handler);
}
this[kNeedDrain] = needDrain;
if (!this[kNeedDrain] && pool[kNeedDrain]) {
pool[kNeedDrain] = false;
pool.emit("drain", origin, [pool, ...targets]);
}
if (pool[kClosedResolve] && queue.isEmpty()) {
Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]);
}
}, "onDrain");
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 (const { [kPending]: pending } of this[kClients]) {
ret += pending;
}
return ret;
}
get [kRunning]() {
let ret = 0;
for (const { [kRunning]: running } of this[kClients]) {
ret += running;
}
return ret;
}
get [kSize]() {
let ret = this[kQueued];
for (const { [kSize]: size } of this[kClients]) {
ret += size;
}
return ret;
}
get stats() {
return this[kStats];
}
async [kClose]() {
if (this[kQueue].isEmpty()) {
return Promise.all(this[kClients].map((c) => c.close()));
} else {
return new Promise((resolve) => {
this[kClosedResolve] = resolve;
});
}
}
async [kDestroy](err) {
while (true) {
const item = this[kQueue].shift();
if (!item) {
break;
}
item.handler.onError(err);
}
return Promise.all(this[kClients].map((c) => c.destroy(err)));
}
[kDispatch](opts, handler) {
const dispatcher = this[kGetDispatcher]();
if (!dispatcher) {
this[kNeedDrain] = true;
this[kQueue].push({ opts, handler });
this[kQueued]++;
} else if (!dispatcher.dispatch(opts, handler)) {
dispatcher[kNeedDrain] = true;
this[kNeedDrain] = !this[kGetDispatcher]();
}
return !this[kNeedDrain];
}
[kAddClient](client) {
client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
this[kClients].push(client);
if (this[kNeedDrain]) {
process.nextTick(() => {
if (this[kNeedDrain]) {
this[kOnDrain](client[kUrl], [this, client]);
}
});
}
return this;
}
[kRemoveClient](client) {
client.close(() => {
const idx = this[kClients].indexOf(client);
if (idx !== -1) {
this[kClients].splice(idx, 1);
}
});
this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true);
}
};
module2.exports = {
PoolBase,
kClients,
kNeedDrain,
kAddClient,
kRemoveClient,
kGetDispatcher
};
}
});
// lib/core/diagnostics.js
var require_diagnostics = __commonJS({
"lib/core/diagnostics.js"(exports2, module2) {
"use strict";
var diagnosticsChannel = require("node:diagnostics_channel");
var util = require("node:util");
var undiciDebugLog = util.debuglog("undici");
var fetchDebuglog = util.debuglog("fetch");
var websocketDebuglog = util.debuglog("websocket");
var isClientSet = false;
var channels = {
// Client
beforeConnect: diagnosticsChannel.channel("undici:client:beforeConnect"),
connected: diagnosticsChannel.channel("undici:client:connected"),
connectError: diagnosticsChannel.channel("undici:client:connectError"),
sendHeaders: diagnosticsChannel.channel("undici:client:sendHeaders"),
// Request
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"),
// WebSocket
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")
};
if (undiciDebugLog.enabled || fetchDebuglog.enabled) {
const debuglog = fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog;
diagnosticsChannel.channel("undici:client:beforeConnect").subscribe((evt) => {
const {
connectParams: { version, protocol, port, host }
} = evt;
debuglog(
"connecting to %s using %s%s",
`${host}${port ? `:${port}` : ""}`,
protocol,
version
);
});
diagnosticsChannel.channel("undici:client:connected").subscribe((evt) => {
const {
connectParams: { version, protocol, port, host }
} = evt;
debuglog(
"connected to %s using %s%s",
`${host}${port ? `:${port}` : ""}`,
protocol,
version
);
});
diagnosticsChannel.channel("undici:client:connectError").subscribe((evt) => {
const {
connectParams: { version, protocol, port, host },
error
} = evt;
debuglog(
"connection to %s using %s%s errored - %s",
`${host}${port ? `:${port}` : ""}`,
protocol,
version,
error.message
);
});
diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => {
const {
request: { method, path, origin }
} = evt;
debuglog("sending request to %s %s/%s", method, origin, path);
});
diagnosticsChannel.channel("undici:request:headers").subscribe((evt) => {
const {
request: { method, path, origin },
response: { statusCode }
} = evt;
debuglog(
"received response to %s %s/%s - HTTP %d",
method,
origin,
path,
statusCode
);
});
diagnosticsChannel.channel("undici:request:trailers").subscribe((evt) => {
const {
request: { method, path, origin }
} = evt;
debuglog("trailers received from %s %s/%s", method, origin, path);
});
diagnosticsChannel.channel("undici:request:error").subscribe((evt) => {
const {
request: { method, path, origin },
error
} = evt;
debuglog(
"request to %s %s/%s errored - %s",
method,
origin,
path,
error.message
);
});
isClientSet = true;
}
if (websocketDebuglog.enabled) {
if (!isClientSet) {
const debuglog = undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog;
diagnosticsChannel.channel("undici:client:beforeConnect").subscribe((evt) => {
const {
connectParams: { version, protocol, port, host }
} = evt;
debuglog(
"connecting to %s%s using %s%s",
host,
port ? `:${port}` : "",
protocol,
version
);
});
diagnosticsChannel.channel("undici:client:connected").subscribe((evt) => {
const {
connectParams: { version, protocol, port, host }
} = evt;
debuglog(
"connected to %s%s using %s%s",
host,
port ? `:${port}` : "",
protocol,
version
);
});
diagnosticsChannel.channel("undici:client:connectError").subscribe((evt) => {
const {
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.channel("undici:client:sendHeaders").subscribe((evt) => {
const {
request: { method, path, origin }
} = evt;
debuglog("sending request to %s %s/%s", method, origin, path);
});
}
diagnosticsChannel.channel("undici:websocket:open").subscribe((evt) => {
const {
address: { address, port }
} = evt;
websocketDebuglog("connection opened %s%s", address, port ? `:${port}` : "");
});
diagnosticsChannel.channel("undici:websocket:close").subscribe((evt) => {
const { websocket, code, reason } = evt;
websocketDebuglog(
"closed connection to %s - %s %s",
websocket.url,
code,
reason
);
});
diagnosticsChannel.channel("undici:websocket:socket_error").subscribe((err) => {
websocketDebuglog("connection errored - %s", err.message);
});
diagnosticsChannel.channel("undici:websocket:ping").subscribe((evt) => {
websocketDebuglog("ping received");
});
diagnosticsChannel.channel("undici:websocket:pong").subscribe((evt) => {
websocketDebuglog("pong received");
});
}
module2.exports = {
channels
};
}
});
// lib/timers.js
var require_timers = __commonJS({
"lib/timers.js"(exports2, module2) {
"use strict";
var fastNow = Date.now();
var fastNowTimeout;
var fastTimers = [];
function onTimeout() {
fastNow = Date.now();
let len = fastTimers.length;
let idx = 0;
while (idx < len) {
const timer = fastTimers[idx];
if (timer.state === 0) {
timer.state = fastNow + timer.delay;
} else if (timer.state > 0 && fastNow >= timer.state) {
timer.state = -1;
timer.callback(timer.opaque);
}
if (timer.state === -1) {
timer.state = -2;
if (idx !== len - 1) {
fastTimers[idx] = fastTimers.pop();
} else {
fastTimers.pop();
}
len -= 1;
} else {
idx += 1;
}
}
if (fastTimers.length > 0) {
refreshTimeout();
}
}
__name(onTimeout, "onTimeout");
function refreshTimeout() {
if (fastNowTimeout?.refresh) {
fastNowTimeout.refresh();
} else {
clearTimeout(fastNowTimeout);
fastNowTimeout = setTimeout(onTimeout, 1e3);
if (fastNowTimeout.unref) {
fastNowTimeout.unref();
}
}
}
__name(refreshTimeout, "refreshTimeout");
var Timeout = class {
static {
__name(this, "Timeout");
}
constructor(callback, delay, opaque) {
this.callback = callback;
this.delay = delay;
this.opaque = opaque;
this.state = -2;
this.refresh();
}
refresh() {
if (this.state === -2) {
fastTimers.push(this);
if (!fastNowTimeout || fastTimers.length === 1) {
refreshTimeout();
}
}
this.state = 0;
}
clear() {
this.state = -1;
}
};
module2.exports = {
setTimeout(callback, delay, opaque) {
return delay < 1e3 ? setTimeout(callback, delay, opaque) : new Timeout(callback, delay, opaque);
},
clearTimeout(timeout) {
if (timeout instanceof Timeout) {
timeout.clear();
} else {
clearTimeout(timeout);
}
}
};
}
});
// lib/core/request.js
var require_request2 = __commonJS({
"lib/core/request.js"(exports2, module2) {
"use strict";
var {
InvalidArgumentError,
NotSupportedError
} = require_errors();
var assert = require("node:assert");
var { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require_symbols();
var util = require_util();
var { channels } = require_diagnostics();
var { headerNameLowerCasedRecord } = require_constants();
var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
var invalidPathRegex = /[^\u0021-\u00ff]/;
var kHandler = Symbol("handler");
var extractBody;
var Request = class _Request {
static {
__name(this, "Request");
}
constructor(origin, {
path,
method,
body,
headers,
query,
idempotent,
blocking,
upgrade,
headersTimeout,
bodyTimeout,
reset,
throwOnError,
expectContinue
}, 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.exec(path) !== null) {
throw new InvalidArgumentError("invalid request path");
}
if (typeof method !== "string") {
throw new InvalidArgumentError("method must be a string");
} else if (!util.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");
}
this.headersTimeout = headersTimeout;
this.bodyTimeout = bodyTimeout;
this.throwOnError = throwOnError === true;
this.method = method;
this.abort = null;
if (body == null) {
this.body = null;
} else if (util.isStream(body)) {
this.body = body;
const rState = this.body._readableState;
if (!rState || !rState.autoDestroy) {
this.endHandler = /* @__PURE__ */ __name(function autoDestroy() {
util.destroy(this);
}, "autoDestroy");
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 (util.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 (util.isFormDataLike(body) || util.isIterable(body) || util.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");
}
this.completed = false;
this.aborted = false;
this.upgrade = upgrade || null;
this.path = query ? util.buildURL(path, query) : path;
this.origin = origin;
this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
this.blocking = blocking == null ? false : blocking;
this.reset = reset == null ? null : reset;
this.host = null;
this.contentLength = null;
this.contentType = null;
this.headers = "";
this.expectContinue = expectContinue != null ? expectContinue : false;
if (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") {
const keys = Object.keys(headers);
for (let i = 0; i < keys.length; i++) {
const key = keys[i];
processHeader(this, key, headers[key]);
}
} else if (headers != null) {
throw new InvalidArgumentError("headers must be an object or an array");
}
if (util.isFormDataLike(this.body)) {
if (!extractBody) {
extractBody = require_body().extractBody;
}
const [bodyStream, contentType] = extractBody(body);
if (this.contentType == null) {
this.contentType = contentType;
this.headers += `content-type: ${contentType}\r
`;
}
this.body = bodyStream.stream;
this.contentLength = bodyStream.length;
} else if (util.isBlobLike(body) && this.contentType == null && body.type) {
this.contentType = body.type;
this.headers += `content-type: ${body.type}\r
`;
}
util.validateHandler(handler, method, upgrade);
this.servername = util.getServerName(this.host);
this[kHandler] = handler;
if (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) {
assert(!this.aborted);
assert(!this.completed);
if (this.error) {
abort(this.error);
} else {
this.abort = abort;
return this[kHandler].onConnect(abort);
}
}
onResponseStarted() {
return this[kHandler].onResponseStarted?.();
}
onHeaders(statusCode, headers, resume, statusText) {
assert(!this.aborted);
assert(!this.completed);
if (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) {
this.abort(err);
return false;
}
}
onUpgrade(statusCode, headers, socket) {
assert(!this.aborted);
assert(!this.completed);
return this[kHandler].onUpgrade(statusCode, headers, socket);
}
onComplete(trailers) {
this.onFinally();
assert(!this.aborted);
this.completed = true;
if (channels.trailers.hasSubscribers) {
channels.trailers.publish({ request: this, trailers });
}
try {
return this[kHandler].onComplete(trailers);
} catch (err) {
this.onError(err);
}
}
onError(error) {
this.onFinally();
if (channels.error.hasSubscribers) {
channels.error.publish({ request: this, error });
}
if (this.aborted) {
return;
}
this.aborted = true;
return 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;
}
}
// TODO: adjust to support H2
addHeader(key, value) {
processHeader(this, key, value);
return this;
}
static [kHTTP1BuildRequest](origin, opts, handler) {
return new _Request(origin, opts, handler);
}
static [kHTTP2BuildRequest](origin, opts, handler) {
const headers = opts.headers;
opts = { ...opts, headers: null };
const request = new _Request(origin, opts, handler);
request.headers = {};
if (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(request, headers[i], headers[i + 1], true);
}
} else if (headers && typeof headers === "object") {
const keys = Object.keys(headers);
for (let i = 0; i < keys.length; i++) {
const key = keys[i];
processHeader(request, key, headers[key], true);
}
} else if (headers != null) {
throw new InvalidArgumentError("headers must be an object or an array");
}
return request;
}
static [kHTTP2CopyHeaders](raw) {
const rawHeaders = raw.split("\r\n");
const headers = {};
for (const header of rawHeaders) {
const [key, value] = header.split(": ");
if (value == null || value.length === 0)
continue;
if (headers[key]) {
headers[key] += `,${value}`;
} else {
headers[key] = value;
}
}
return headers;
}
};
function processHeaderValue(key, val, skipAppend) {
if (val && typeof val === "object") {
throw new InvalidArgumentError(`invalid ${key} header`);
}
val = val != null ? `${val}` : "";
if (headerCharRegex.exec(val) !== null) {
throw new InvalidArgumentError(`invalid ${key} header`);
}
return skipAppend ? val : `${key}: ${val}\r
`;
}
__name(processHeaderValue, "processHeaderValue");
function processHeader(request, key, val, skipAppend = false) {
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) {
headerName = key.toLowerCase();
if (headerNameLowerCasedRecord[headerName] === void 0 && !util.isValidHTTPToken(headerName)) {
throw new InvalidArgumentError("invalid header key");
}
}
if (request.host === null && headerName === "host") {
if (headerCharRegex.exec(val) !== null) {
throw new InvalidArgumentError(`invalid ${key} header`);
}
request.host = val;
} else if (request.contentLength === null && headerName === "content-length") {
request.contentLength = parseInt(val, 10);
if (!Number.isFinite(request.contentLength)) {
throw new InvalidArgumentError("invalid content-length header");
}
} else if (request.contentType === null && headerName === "content-type") {
request.contentType = val;
if (skipAppend)
request.headers[key] = processHeaderValue(key, val, skipAppend);
else
request.headers += processHeaderValue(key, val);
} else if (headerName === "transfer-encoding" || headerName === "keep-alive" || headerName === "upgrade") {
throw new InvalidArgumentError(`invalid ${headerName} header`);
} else if (headerName === "connection") {
const value = typeof val === "string" ? val.toLowerCase() : null;
if (value !== "close" && value !== "keep-alive") {
throw new InvalidArgumentError("invalid connection header");
} else if (value === "close") {
request.reset = true;
}
} else if (headerName === "expect") {
throw new NotSupportedError("expect header not supported");
} else if (Array.isArray(val)) {
for (let i = 0; i < val.length; i++) {
if (skipAppend) {
if (request.headers[key]) {
request.headers[key] += `,${processHeaderValue(key, val[i], skipAppend)}`;
} else {
request.headers[key] = processHeaderValue(key, val[i], skipAppend);
}
} else {
request.headers += processHeaderValue(key, val[i]);
}
}
} else if (skipAppend) {
request.headers[key] = processHeaderValue(key, val, skipAppend);
} else {
request.headers += processHeaderValue(key, val);
}
}
__name(processHeader, "processHeader");
module2.exports = Request;
}
});
// lib/core/connect.js
var require_connect = __commonJS({
"lib/core/connect.js"(exports2, module2) {
"use strict";
var net = require("node:net");
var assert = require("node:assert");
var util = require_util();
var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
var tls;
var SessionCache;
if (global.FinalizationRegistry && !(process.env.NODE_V8_COVERAGE || process.env.UNDICI_NO_FG)) {
SessionCache = class WeakSessionCache {
static {
__name(this, "WeakSessionCache");
}
constructor(maxCachedSessions) {
this._maxCachedSessions = maxCachedSessions;
this._sessionCache = /* @__PURE__ */ new Map();
this._sessionRegistry = new global.FinalizationRegistry((key) => {
if (this._sessionCache.size < this._maxCachedSessions) {
return;
}
const ref = this._sessionCache.get(key);
if (ref !== void 0 && ref.deref() === void 0) {
this._sessionCache.delete(key);
}
});
}
get(sessionKey) {
const 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 {
static {
__name(this, "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) {
const { value: oldestKey } = this._sessionCache.keys().next();
this._sessionCache.delete(oldestKey);
}
this._sessionCache.set(sessionKey, session);
}
};
}
function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, ...opts }) {
if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero");
}
const options = { path: socketPath, ...opts };
const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
timeout = timeout == null ? 1e4 : timeout;
allowH2 = allowH2 != null ? allowH2 : false;
return /* @__PURE__ */ __name(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;
const sessionKey = servername || hostname;
const session = sessionCache.get(sessionKey) || null;
assert(sessionKey);
socket = tls.connect({
highWaterMark: 16384,
// TLS in node can't have bigger HWM anyway...
...options,
servername,
session,
localAddress,
// TODO(HTTP/2): Add support for h2c
ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"],
socket: httpSocket,
// upgrade socket connection
port: port || 443,
host: hostname
});
socket.on("session", function(session2) {
sessionCache.set(sessionKey, session2);
});
} else {
assert(!httpSocket, "httpSocket can only be sent on TLS update");
socket = net.connect({
highWaterMark: 64 * 1024,
// Same as nodejs fs streams.
...options,
localAddress,
port: port || 80,
host: hostname
});
}
if (options.keepAlive == null || options.keepAlive) {
const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay;
socket.setKeepAlive(true, keepAliveInitialDelay);
}
const cancelTimeout = setupTimeout(() => onConnectTimeout(socket), timeout);
socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() {
cancelTimeout();
if (callback) {
const cb = callback;
callback = null;
cb(null, this);
}
}).on("error", function(err) {
cancelTimeout();
if (callback) {
const cb = callback;
callback = null;
cb(err);
}
});
return socket;
}, "connect");
}
__name(buildConnector, "buildConnector");
function setupTimeout(onConnectTimeout2, timeout) {
if (!timeout) {
return () => {
};
}
let s1 = null;
let s2 = null;
const timeoutId = setTimeout(() => {
s1 = setImmediate(() => {
if (process.platform === "win32") {
s2 = setImmediate(() => onConnectTimeout2());
} else {
onConnectTimeout2();
}
});
}, timeout);
return () => {
clearTimeout(timeoutId);
clearImmediate(s1);
clearImmediate(s2);
};
}
__name(setupTimeout, "setupTimeout");
function onConnectTimeout(socket) {
let message = "Connect Timeout Error";
if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
message = +` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(", ")})`;
}
util.destroy(socket, new ConnectTimeoutError(message));
}
__name(onConnectTimeout, "onConnectTimeout");
module2.exports = buildConnector;
}
});
// lib/llhttp/utils.js
var require_utils = __commonJS({
"lib/llhttp/utils.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.enumToMap = void 0;
function enumToMap(obj) {
const res = {};
Object.keys(obj).forEach((key) => {
const value = obj[key];
if (typeof value === "number") {
res[key] = value;
}
});
return res;
}
__name(enumToMap, "enumToMap");
exports2.enumToMap = enumToMap;
}
});
// lib/llhttp/constants.js
var require_constants3 = __commonJS({
"lib/llhttp/constants.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0;
var utils_1 = require_utils();
var ERROR;
(function(ERROR2) {
ERROR2[ERROR2["OK"] = 0] = "OK";
ERROR2[ERROR2["INTERNAL"] = 1] = "INTERNAL";
ERROR2[ERROR2["STRICT"] = 2] = "STRICT";
ERROR2[ERROR2["LF_EXPECTED"] = 3] = "LF_EXPECTED";
ERROR2[ERROR2["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH";
ERROR2[ERROR2["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION";
ERROR2[ERROR2["INVALID_METHOD"] = 6] = "INVALID_METHOD";
ERROR2[ERROR2["INVALID_URL"] = 7] = "INVALID_URL";
ERROR2[ERROR2["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT";
ERROR2[ERROR2["INVALID_VERSION"] = 9] = "INVALID_VERSION";
ERROR2[ERROR2["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN";
ERROR2[ERROR2["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH";
ERROR2[ERROR2["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE";
ERROR2[ERROR2["INVALID_STATUS"] = 13] = "INVALID_STATUS";
ERROR2[ERROR2["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE";
ERROR2[ERROR2["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING";
ERROR2[ERROR2["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN";
ERROR2[ERROR2["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE";
ERROR2[ERROR2["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE";
ERROR2[ERROR2["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER";
ERROR2[ERROR2["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE";
ERROR2[ERROR2["PAUSED"] = 21] = "PAUSED";
ERROR2[ERROR2["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE";
ERROR2[ERROR2["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE";
ERROR2[ERROR2["USER"] = 24] = "USER";
})(ERROR = exports2.ERROR || (exports2.ERROR = {}));
var TYPE;
(function(TYPE2) {
TYPE2[TYPE2["BOTH"] = 0] = "BOTH";
TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST";
TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE";
})(TYPE = exports2.TYPE || (exports2.TYPE = {}));
var FLAGS;
(function(FLAGS2) {
FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE";
FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE";
FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE";
FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED";
FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE";
FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH";
FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY";
FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING";
FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING";
})(FLAGS = exports2.FLAGS || (exports2.FLAGS = {}));
var LENIENT_FLAGS;
(function(LENIENT_FLAGS2) {
LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS";
LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH";
LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE";
})(LENIENT_FLAGS = exports2.LENIENT_FLAGS || (exports2.LENIENT_FLAGS = {}));
var METHODS;
(function(METHODS2) {
METHODS2[METHODS2["DELETE"] = 0] = "DELETE";
METHODS2[METHODS2["GET"] = 1] = "GET";
METHODS2[METHODS2["HEAD"] = 2] = "HEAD";
METHODS2[METHODS2["POST"] = 3] = "POST";
METHODS2[METHODS2["PUT"] = 4] = "PUT";
METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT";
METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS";
METHODS2[METHODS2["TRACE"] = 7] = "TRACE";
METHODS2[METHODS2["COPY"] = 8] = "COPY";
METHODS2[METHODS2["LOCK"] = 9] = "LOCK";
METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL";
METHODS2[METHODS2["MOVE"] = 11] = "MOVE";
METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND";
METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH";
METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH";
METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK";
METHODS2[METHODS2["BIND"] = 16] = "BIND";
METHODS2[METHODS2["REBIND"] = 17] = "REBIND";
METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND";
METHODS2[METHODS2["ACL"] = 19] = "ACL";
METHODS2[METHODS2["REPORT"] = 20] = "REPORT";
METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY";
METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT";
METHODS2[METHODS2["MERGE"] = 23] = "MERGE";
METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH";
METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY";
METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE";
METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE";
METHODS2[METHODS2["PATCH"] = 28] = "PATCH";
METHODS2[METHODS2["PURGE"] = 29] = "PURGE";
METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR";
METHODS2[METHODS2["LINK"] = 31] = "LINK";
METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK";
METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE";
METHODS2[METHODS2["PRI"] = 34] = "PRI";
METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE";
METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE";
METHODS2[METHODS2["SETUP"] = 37] = "SETUP";
METHODS2[METHODS2["PLAY"] = 38] = "PLAY";
METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE";
METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN";
METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER";
METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER";
METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT";
METHODS2[METHODS2["RECORD"] = 44] = "RECORD";
METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH";
})(METHODS = exports2.METHODS || (exports2.METHODS = {}));
exports2.METHODS_HTTP = [
METHODS.DELETE,
METHODS.GET,
METHODS.HEAD,
METHODS.POST,
METHODS.PUT,
METHODS.CONNECT,
METHODS.OPTIONS,
METHODS.TRACE,
METHODS.COPY,
METHODS.LOCK,
METHODS.MKCOL,
METHODS.MOVE,
METHODS.PROPFIND,
METHODS.PROPPATCH,
METHODS.SEARCH,
METHODS.UNLOCK,
METHODS.BIND,
METHODS.REBIND,
METHODS.UNBIND,
METHODS.ACL,
METHODS.REPORT,
METHODS.MKACTIVITY,
METHODS.CHECKOUT,
METHODS.MERGE,
METHODS["M-SEARCH"],
METHODS.NOTIFY,
METHODS.SUBSCRIBE,
METHODS.UNSUBSCRIBE,
METHODS.PATCH,
METHODS.PURGE,
METHODS.MKCALENDAR,
METHODS.LINK,
METHODS.UNLINK,
METHODS.PRI,
// TODO(indutny): should we allow it with HTTP?
METHODS.SOURCE
];
exports2.METHODS_ICE = [
METHODS.SOURCE
];
exports2.METHODS_RTSP = [
METHODS.OPTIONS,
METHODS.DESCRIBE,
METHODS.ANNOUNCE,
METHODS.SETUP,
METHODS.PLAY,
METHODS.PAUSE,
METHODS.TEARDOWN,
METHODS.GET_PARAMETER,
METHODS.SET_PARAMETER,
METHODS.REDIRECT,
METHODS.RECORD,
METHODS.FLUSH,
// For AirPlay
METHODS.GET,
METHODS.POST
];
exports2.METHOD_MAP = utils_1.enumToMap(METHODS);
exports2.H_METHOD_MAP = {};
Object.keys(exports2.METHOD_MAP).forEach((key) => {
if (/^H/.test(key)) {
exports2.H_METHOD_MAP[key] = exports2.METHOD_MAP[key];
}
});
var FINISH;
(function(FINISH2) {
FINISH2[FINISH2["SAFE"] = 0] = "SAFE";
FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB";
FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE";
})(FINISH = exports2.FINISH || (exports2.FINISH = {}));
exports2.ALPHA = [];
for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) {
exports2.ALPHA.push(String.fromCharCode(i));
exports2.ALPHA.push(String.fromCharCode(i + 32));
}
exports2.NUM_MAP = {
0: 0,
1: 1,
2: 2,
3: 3,
4: 4,
5: 5,
6: 6,
7: 7,
8: 8,
9: 9
};
exports2.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
};
exports2.NUM = [
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9"
];
exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM);
exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"];
exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]);
exports2.STRICT_URL_CHAR = [
"!",
'"',
"$",
"%",
"&",
"'",
"(",
")",
"*",
"+",
",",
"-",
".",
"/",
":",
";",
"<",
"=",
">",
"@",
"[",
"\\",
"]",
"^",
"_",
"`",
"{",
"|",
"}",
"~"
].concat(exports2.ALPHANUM);
exports2.URL_CHAR = exports2.STRICT_URL_CHAR.concat([" ", "\f"]);
for (let i = 128; i <= 255; i++) {
exports2.URL_CHAR.push(i);
}
exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]);
exports2.STRICT_TOKEN = [
"!",
"#",
"$",
"%",
"&",
"'",
"*",
"+",
"-",
".",
"^",
"_",
"`",
"|",
"~"
].concat(exports2.ALPHANUM);
exports2.TOKEN = exports2.STRICT_TOKEN.concat([" "]);
exports2.HEADER_CHARS = [" "];
for (let i = 32; i <= 255; i++) {
if (i !== 127) {
exports2.HEADER_CHARS.push(i);
}
}
exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c) => c !== 44);
exports2.MAJOR = exports2.NUM_MAP;
exports2.MINOR = exports2.MAJOR;
var HEADER_STATE;
(function(HEADER_STATE2) {
HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL";
HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION";
HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH";
HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING";
HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE";
HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE";
HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE";
HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE";
HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED";
})(HEADER_STATE = exports2.HEADER_STATE || (exports2.HEADER_STATE = {}));
exports2.SPECIAL_HEADERS = {
"connection": HEADER_STATE.CONNECTION,
"content-length": HEADER_STATE.CONTENT_LENGTH,
"proxy-connection": HEADER_STATE.CONNECTION,
"transfer-encoding": HEADER_STATE.TRANSFER_ENCODING,
"upgrade": HEADER_STATE.UPGRADE
};
}
});
// lib/handler/RedirectHandler.js
var require_RedirectHandler = __commonJS({
"lib/handler/RedirectHandler.js"(exports2, module2) {
"use strict";
var util = require_util();
var { kBodyUsed } = require_symbols();
var assert = require("node:assert");
var { InvalidArgumentError } = require_errors();
var EE = require("node:events");
var redirectableStatusCodes = [300, 301, 302, 303, 307, 308];
var kBody = Symbol("body");
var BodyAsyncIterable = class {
static {
__name(this, "BodyAsyncIterable");
}
constructor(body) {
this[kBody] = body;
this[kBodyUsed] = false;
}
async *[Symbol.asyncIterator]() {
assert(!this[kBodyUsed], "disturbed");
this[kBodyUsed] = true;
yield* this[kBody];
}
};
var RedirectHandler = class {
static {
__name(this, "RedirectHandler");
}
constructor(dispatch, maxRedirections, opts, handler) {
if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
throw new InvalidArgumentError("maxRedirections must be a positive number");
}
util.validateHandler(handler, opts.method, opts.upgrade);
this.dispatch = dispatch;
this.location = null;
this.abort = null;
this.opts = { ...opts, maxRedirections: 0 };
this.maxRedirections = maxRedirections;
this.handler = handler;
this.history = [];
this.redirectionLimitReached = false;
if (util.isStream(this.opts.body)) {
if (util.bodyLength(this.opts.body) === 0) {
this.opts.body.on("data", function() {
assert(false);
});
}
if (typeof this.opts.body.readableDidRead !== "boolean") {
this.opts.body[kBodyUsed] = false;
EE.prototype.on.call(this.opts.body, "data", function() {
this[kBodyUsed] = true;
});
}
} else if (this.opts.body && typeof this.opts.body.pipeTo === "function") {
this.opts.body = new BodyAsyncIterable(this.opts.body);
} else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util.isIterable(this.opts.body)) {
this.opts.body = new BodyAsyncIterable(this.opts.body);
}
}
onConnect(abort) {
this.abort = abort;
this.handler.onConnect(abort, { history: this.history });
}
onUpgrade(statusCode, headers, socket) {
this.handler.onUpgrade(statusCode, headers, socket);
}
onError(error) {
this.handler.onError(error);
}
onHeaders(statusCode, headers, resume, statusText) {
this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers);
if (this.opts.throwOnMaxRedirect && this.history.length >= this.maxRedirections) {
if (this.request) {
this.request.abort(new Error("max redirects"));
}
this.redirectionLimitReached = true;
this.abort(new Error("max redirects"));
return;
}
if (this.opts.origin) {
this.history.push(new URL(this.opts.path, this.opts.origin));
}
if (!this.location) {
return this.handler.onHeaders(statusCode, headers, resume, statusText);
}
const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
const path = search ? `${pathname}${search}` : pathname;
this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
this.opts.path = path;
this.opts.origin = origin;
this.opts.maxRedirections = 0;
this.opts.query = null;
if (statusCode === 303 && this.opts.method !== "HEAD") {
this.opts.method = "GET";
this.opts.body = null;
}
}
onData(chunk) {
if (this.location) {
} else {
return this.handler.onData(chunk);
}
}
onComplete(trailers) {
if (this.location) {
this.location = null;
this.abort = null;
this.dispatch(this.opts, this);
} else {
this.handler.onComplete(trailers);
}
}
onBodySent(chunk) {
if (this.handler.onBodySent) {
this.handler.onBodySent(chunk);
}
}
};
function parseLocation(statusCode, headers) {
if (redirectableStatusCodes.indexOf(statusCode) === -1) {
return null;
}
for (let i = 0; i < headers.length; i += 2) {
if (headers[i].length === 8 && util.headerNameToString(headers[i]) === "location") {
return headers[i + 1];
}
}
}
__name(parseLocation, "parseLocation");
function shouldRemoveHeader(header, removeContent, unknownOrigin) {
if (header.length === 4) {
return util.headerNameToString(header) === "host";
}
if (removeContent && util.headerNameToString(header).startsWith("content-")) {
return true;
}
if (unknownOrigin && (header.length === 13 || header.length === 6)) {
const name = util.headerNameToString(header);
return name === "authorization" || name === "cookie";
}
return false;
}
__name(shouldRemoveHeader, "shouldRemoveHeader");
function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
const ret = [];
if (Array.isArray(headers)) {
for (let i = 0; i < headers.length; i += 2) {
if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) {
ret.push(headers[i], headers[i + 1]);
}
}
} else if (headers && typeof headers === "object") {
for (const key of Object.keys(headers)) {
if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
ret.push(key, headers[key]);
}
}
} else {
assert(headers == null, "headers must be an object or an array");
}
return ret;
}
__name(cleanRequestHeaders, "cleanRequestHeaders");
module2.exports = RedirectHandler;
}
});
// lib/interceptor/redirectInterceptor.js
var require_redirectInterceptor = __commonJS({
"lib/interceptor/redirectInterceptor.js"(exports2, module2) {
"use strict";
var RedirectHandler = require_RedirectHandler();
function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) {
return (dispatch) => {
return /* @__PURE__ */ __name(function Intercept(opts, handler) {
const { maxRedirections = defaultMaxRedirections } = opts;
if (!maxRedirections) {
return dispatch(opts, handler);
}
const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler);
opts = { ...opts, maxRedirections: 0 };
return dispatch(opts, redirectHandler);
}, "Intercept");
};
}
__name(createRedirectInterceptor, "createRedirectInterceptor");
module2.exports = createRedirectInterceptor;
}
});
// lib/llhttp/llhttp-wasm.js
var require_llhttp_wasm = __commonJS({
"lib/llhttp/llhttp-wasm.js"(exports2, module2) {
var { Buffer: Buffer2 } = require("node:buffer");
module2.exports = Buffer2.from("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", "base64");
}
});
// lib/llhttp/llhttp_simd-wasm.js
var require_llhttp_simd_wasm = __commonJS({
"lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) {
var { Buffer: Buffer2 } = require("node:buffer");
module2.exports = Buffer2.from("AGFzbQEAAAABMAhgAX8Bf2ADf39/AX9gBH9/f38Bf2AAAGADf39/AGABfwBgAn9/AGAGf39/f39/AALLAQgDZW52GHdhc21fb25faGVhZGVyc19jb21wbGV0ZQACA2VudhV3YXNtX29uX21lc3NhZ2VfYmVnaW4AAANlbnYLd2FzbV9vbl91cmwAAQNlbnYOd2FzbV9vbl9zdGF0dXMAAQNlbnYUd2FzbV9vbl9oZWFkZXJfZmllbGQAAQNlbnYUd2FzbV9vbl9oZWFkZXJfdmFsdWUAAQNlbnYMd2FzbV9vbl9ib2R5AAEDZW52GHdhc21fb25fbWVzc2FnZV9jb21wbGV0ZQAAA0ZFAwMEAAAFAAAAAAAABQEFAAUFBQAABgAAAAAGBgYGAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAAABAQcAAAUFAwABBAUBcAESEgUDAQACBggBfwFBgNQECwfRBSIGbWVtb3J5AgALX2luaXRpYWxpemUACRlfX2luZGlyZWN0X2Z1bmN0aW9uX3RhYmxlAQALbGxodHRwX2luaXQAChhsbGh0dHBfc2hvdWxkX2tlZXBfYWxpdmUAQQxsbGh0dHBfYWxsb2MADAZtYWxsb2MARgtsbGh0dHBfZnJlZQANBGZyZWUASA9sbGh0dHBfZ2V0X3R5cGUADhVsbGh0dHBfZ2V0X2h0dHBfbWFqb3IADxVsbGh0dHBfZ2V0X2h0dHBfbWlub3IAEBFsbGh0dHBfZ2V0X21ldGhvZAARFmxsaHR0cF9nZXRfc3RhdHVzX2NvZGUAEhJsbGh0dHBfZ2V0X3VwZ3JhZGUAEwxsbGh0dHBfcmVzZXQAFA5sbGh0dHBfZXhlY3V0ZQAVFGxsaHR0cF9zZXR0aW5nc19pbml0ABYNbGxodHRwX2ZpbmlzaAAXDGxsaHR0cF9wYXVzZQAYDWxsaHR0cF9yZXN1bWUAGRtsbGh0dHBfcmVzdW1lX2FmdGVyX3VwZ3JhZGUAGhBsbGh0dHBfZ2V0X2Vycm5vABsXbGxodHRwX2dldF9lcnJvcl9yZWFzb24AHBdsbGh0dHBfc2V0X2Vycm9yX3JlYXNvbgAdFGxsaHR0cF9nZXRfZXJyb3JfcG9zAB4RbGxodHRwX2Vycm5vX25hbWUAHxJsbGh0dHBfbWV0aG9kX25hbWUAIBJsbGh0dHBfc3RhdHVzX25hbWUAIRpsbGh0dHBfc2V0X2xlbmllbnRfaGVhZGVycwAiIWxsaHR0cF9zZXRfbGVuaWVudF9jaHVua2VkX2xlbmd0aAAjHWxsaHR0cF9zZXRfbGVuaWVudF9rZWVwX2FsaXZlACQkbGxodHRwX3NldF9sZW5pZW50X3RyYW5zZmVyX2VuY29kaW5nACUYbGxodHRwX21lc3NhZ2VfbmVlZHNfZW9mAD8JFwEAQQELEQECAwQFCwYHNTk3MS8tJyspCrLgAkUCAAsIABCIgICAAAsZACAAEMKAgIAAGiAAIAI2AjggACABOgAoCxwAIAAgAC8BMiAALQAuIAAQwYCAgAAQgICAgAALKgEBf0HAABDGgICAACIBEMKAgIAAGiABQYCIgIAANgI4IAEgADoAKCABCwoAIAAQyICAgAALBwAgAC0AKAsHACAALQAqCwcAIAAtACsLBwAgAC0AKQsHACAALwEyCwcAIAAtAC4LRQEEfyAAKAIYIQEgAC0ALSECIAAtACghAyAAKAI4IQQgABDCgICAABogACAENgI4IAAgAzoAKCAAIAI6AC0gACABNgIYCxEAIAAgASABIAJqEMOAgIAACxAAIABBAEHcABDMgICAABoLZwEBf0EAIQECQCAAKAIMDQACQAJAAkACQCAALQAvDgMBAAMCCyAAKAI4IgFFDQAgASgCLCIBRQ0AIAAgARGAgICAAAAiAQ0DC0EADwsQyoCAgAAACyAAQcOWgIAANgIQQQ4hAQsgAQseAAJAIAAoAgwNACAAQdGbgIAANgIQIABBFTYCDAsLFgACQCAAKAIMQRVHDQAgAEEANgIMCwsWAAJAIAAoAgxBFkcNACAAQQA2AgwLCwcAIAAoAgwLBwAgACgCEAsJACAAIAE2AhALBwAgACgCFAsiAAJAIABBJEkNABDKgICAAAALIABBAnRBoLOAgABqKAIACyIAAkAgAEEuSQ0AEMqAgIAAAAsgAEECdEGwtICAAGooAgAL7gsBAX9B66iAgAAhAQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABBnH9qDvQDY2IAAWFhYWFhYQIDBAVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhBgcICQoLDA0OD2FhYWFhEGFhYWFhYWFhYWFhEWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYRITFBUWFxgZGhthYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2YTc4OTphYWFhYWFhYTthYWE8YWFhYT0+P2FhYWFhYWFhQGFhQWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYUJDREVGR0hJSktMTU5PUFFSU2FhYWFhYWFhVFVWV1hZWlthXF1hYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFeYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhX2BhC0Hhp4CAAA8LQaShgIAADwtBy6yAgAAPC0H+sYCAAA8LQcCkgIAADwtBq6SAgAAPC0GNqICAAA8LQeKmgIAADwtBgLCAgAAPC0G5r4CAAA8LQdekgIAADwtB75+AgAAPC0Hhn4CAAA8LQfqfgIAADwtB8qCAgAAPC0Gor4CAAA8LQa6ygIAADwtBiLCAgAAPC0Hsp4CAAA8LQYKigIAADwtBjp2AgAAPC0HQroCAAA8LQcqjgIAADwtBxbKAgAAPC0HfnICAAA8LQdKcgIAADwtBxKCAgAAPC0HXoICAAA8LQaKfgIAADwtB7a6AgAAPC0GrsICAAA8LQdSlgIAADwtBzK6AgAAPC0H6roCAAA8LQfyrgIAADwtB0rCAgAAPC0HxnYCAAA8LQbuggIAADwtB96uAgAAPC0GQsYCAAA8LQdexgIAADwtBoq2AgAAPC0HUp4CAAA8LQeCrgIAADwtBn6yAgAAPC0HrsYCAAA8LQdWfgIAADwtByrGAgAAPC0HepYCAAA8LQdSegIAADwtB9JyAgAAPC0GnsoCAAA8LQbGdgIAADwtBoJ2AgAAPC0G5sYCAAA8LQbywgIAADwtBkqGAgAAPC0GzpoCAAA8LQemsgIAADwtBrJ6AgAAPC0HUq4CAAA8LQfemgIAADwtBgKaAgAAPC0GwoYCAAA8LQf6egIAADwtBjaOAgAAPC0GJrYCAAA8LQfeigIAADwtBoLGAgAAPC0Gun4CAAA8LQcalgIAADwtB6J6AgAAPC0GTooCAAA8LQcKvgIAADwtBw52AgAAPC0GLrICAAA8LQeGdgIAADwtBja+AgAAPC0HqoYCAAA8LQbStgIAADwtB0q+AgAAPC0HfsoCAAA8LQdKygIAADwtB8LCAgAAPC0GpooCAAA8LQfmjgIAADwtBmZ6AgAAPC0G1rICAAA8LQZuwgIAADwtBkrKAgAAPC0G2q4CAAA8LQcKigIAADwtB+LKAgAAPC0GepYCAAA8LQdCigIAADwtBup6AgAAPC0GBnoCAAA8LEMqAgIAAAAtB1qGAgAAhAQsgAQsWACAAIAAtAC1B/gFxIAFBAEdyOgAtCxkAIAAgAC0ALUH9AXEgAUEAR0EBdHI6AC0LGQAgACAALQAtQfsBcSABQQBHQQJ0cjoALQsZACAAIAAtAC1B9wFxIAFBAEdBA3RyOgAtCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAgAiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCBCIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQcaRgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIwIgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAggiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEH2ioCAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCNCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIMIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABB7ZqAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAjgiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCECIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQZWQgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAI8IgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAhQiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEGqm4CAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCQCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIYIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABB7ZOAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAkQiBEUNACAAIAQRgICAgAAAIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCJCIERQ0AIAAgBBGAgICAAAAhAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIsIgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAigiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEH2iICAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCUCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIcIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABBwpmAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAkgiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCICIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQZSUgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAJMIgRFDQAgACAEEYCAgIAAACEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAlQiBEUNACAAIAQRgICAgAAAIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCWCIERQ0AIAAgBBGAgICAAAAhAwsgAwtFAQF/AkACQCAALwEwQRRxQRRHDQBBASEDIAAtAChBAUYNASAALwEyQeUARiEDDAELIAAtAClBBUYhAwsgACADOgAuQQAL/gEBA39BASEDAkAgAC8BMCIEQQhxDQAgACkDIEIAUiEDCwJAAkAgAC0ALkUNAEEBIQUgAC0AKUEFRg0BQQEhBSAEQcAAcUUgA3FBAUcNAQtBACEFIARBwABxDQBBAiEFIARB//8DcSIDQQhxDQACQCADQYAEcUUNAAJAIAAtAChBAUcNACAALQAtQQpxDQBBBQ8LQQQPCwJAIANBIHENAAJAIAAtAChBAUYNACAALwEyQf//A3EiAEGcf2pB5ABJDQAgAEHMAUYNACAAQbACRg0AQQQhBSAEQShxRQ0CIANBiARxQYAERg0CC0EADwtBAEEDIAApAyBQGyEFCyAFC2IBAn9BACEBAkAgAC0AKEEBRg0AIAAvATJB//8DcSICQZx/akHkAEkNACACQcwBRg0AIAJBsAJGDQAgAC8BMCIAQcAAcQ0AQQEhASAAQYgEcUGABEYNACAAQShxRSEBCyABC6cBAQN/AkACQAJAIAAtACpFDQAgAC0AK0UNAEEAIQMgAC8BMCIEQQJxRQ0BDAILQQAhAyAALwEwIgRBAXFFDQELQQEhAyAALQAoQQFGDQAgAC8BMkH//wNxIgVBnH9qQeQASQ0AIAVBzAFGDQAgBUGwAkYNACAEQcAAcQ0AQQAhAyAEQYgEcUGABEYNACAEQShxQQBHIQMLIABBADsBMCAAQQA6AC8gAwuZAQECfwJAAkACQCAALQAqRQ0AIAAtACtFDQBBACEBIAAvATAiAkECcUUNAQwCC0EAIQEgAC8BMCICQQFxRQ0BC0EBIQEgAC0AKEEBRg0AIAAvATJB//8DcSIAQZx/akHkAEkNACAAQcwBRg0AIABBsAJGDQAgAkHAAHENAEEAIQEgAkGIBHFBgARGDQAgAkEocUEARyEBCyABC0kBAXsgAEEQav0MAAAAAAAAAAAAAAAAAAAAACIB/QsDACAAIAH9CwMAIABBMGogAf0LAwAgAEEgaiAB/QsDACAAQd0BNgIcQQALewEBfwJAIAAoAgwiAw0AAkAgACgCBEUNACAAIAE2AgQLAkAgACABIAIQxICAgAAiAw0AIAAoAgwPCyAAIAM2AhxBACEDIAAoAgQiAUUNACAAIAEgAiAAKAIIEYGAgIAAACIBRQ0AIAAgAjYCFCAAIAE2AgwgASEDCyADC+TzAQMOfwN+BH8jgICAgABBEGsiAySAgICAACABIQQgASEFIAEhBiABIQcgASEIIAEhCSABIQogASELIAEhDCABIQ0gASEOIAEhDwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIcIhBBf2oO3QHaAQHZAQIDBAUGBwgJCgsMDQ7YAQ8Q1wEREtYBExQVFhcYGRob4AHfARwdHtUBHyAhIiMkJdQBJicoKSorLNMB0gEtLtEB0AEvMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUbbAUdISUrPAc4BS80BTMwBTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gAGBAYIBgwGEAYUBhgGHAYgBiQGKAYsBjAGNAY4BjwGQAZEBkgGTAZQBlQGWAZcBmAGZAZoBmwGcAZ0BngGfAaABoQGiAaMBpAGlAaYBpwGoAakBqgGrAawBrQGuAa8BsAGxAbIBswG0AbUBtgG3AcsBygG4AckBuQHIAboBuwG8Ab0BvgG/AcABwQHCAcMBxAHFAcYBANwBC0EAIRAMxgELQQ4hEAzFAQtBDSEQDMQBC0EPIRAMwwELQRAhEAzCAQtBEyEQDMEBC0EUIRAMwAELQRUhEAy/AQtBFiEQDL4BC0EXIRAMvQELQRghEAy8AQtBGSEQDLsBC0EaIRAMugELQRshEAy5AQtBHCEQDLgBC0EIIRAMtwELQR0hEAy2AQtBICEQDLUBC0EfIRAMtAELQQchEAyzAQtBISEQDLIBC0EiIRAMsQELQR4hEAywAQtBIyEQDK8BC0ESIRAMrgELQREhEAytAQtBJCEQDKwBC0ElIRAMqwELQSYhEAyqAQtBJyEQDKkBC0HDASEQDKgBC0EpIRAMpwELQSshEAymAQtBLCEQDKUBC0EtIRAMpAELQS4hEAyjAQtBLyEQDKIBC0HEASEQDKEBC0EwIRAMoAELQTQhEAyfAQtBDCEQDJ4BC0ExIRAMnQELQTIhEAycAQtBMyEQDJsBC0E5IRAMmgELQTUhEAyZAQtBxQEhEAyYAQtBCyEQDJcBC0E6IRAMlgELQTYhEAyVAQtBCiEQDJQBC0E3IRAMkwELQTghEAySAQtBPCEQDJEBC0E7IRAMkAELQT0hEAyPAQtBCSEQDI4BC0EoIRAMjQELQT4hEAyMAQtBPyEQDIsBC0HAACEQDIoBC0HBACEQDIkBC0HCACEQDIgBC0HDACEQDIcBC0HEACEQDIYBC0HFACEQDIUBC0HGACEQDIQBC0EqIRAMgwELQccAIRAMggELQcgAIRAMgQELQckAIRAMgAELQcoAIRAMfwtBywAhEAx+C0HNACEQDH0LQcwAIRAMfAtBzgAhEAx7C0HPACEQDHoLQdAAIRAMeQtB0QAhEAx4C0HSACEQDHcLQdMAIRAMdgtB1AAhEAx1C0HWACEQDHQLQdUAIRAMcwtBBiEQDHILQdcAIRAMcQtBBSEQDHALQdgAIRAMbwtBBCEQDG4LQdkAIRAMbQtB2gAhEAxsC0HbACEQDGsLQdwAIRAMagtBAyEQDGkLQd0AIRAMaAtB3gAhEAxnC0HfACEQDGYLQeEAIRAMZQtB4AAhEAxkC0HiACEQDGMLQeMAIRAMYgtBAiEQDGELQeQAIRAMYAtB5QAhEAxfC0HmACEQDF4LQecAIRAMXQtB6AAhEAxcC0HpACEQDFsLQeoAIRAMWgtB6wAhEAxZC0HsACEQDFgLQe0AIRAMVwtB7gAhEAxWC0HvACEQDFULQfAAIRAMVAtB8QAhEAxTC0HyACEQDFILQfMAIRAMUQtB9AAhEAxQC0H1ACEQDE8LQfYAIRAMTgtB9wAhEAxNC0H4ACEQDEwLQfkAIRAMSwtB+gAhEAxKC0H7ACEQDEkLQfwAIRAMSAtB/QAhEAxHC0H+ACEQDEYLQf8AIRAMRQtBgAEhEAxEC0GBASEQDEMLQYIBIRAMQgtBgwEhEAxBC0GEASEQDEALQYUBIRAMPwtBhgEhEAw+C0GHASEQDD0LQYgBIRAMPAtBiQEhEAw7C0GKASEQDDoLQYsBIRAMOQtBjAEhEAw4C0GNASEQDDcLQY4BIRAMNgtBjwEhEAw1C0GQASEQDDQLQZEBIRAMMwtBkgEhEAwyC0GTASEQDDELQZQBIRAMMAtBlQEhEAwvC0GWASEQDC4LQZcBIRAMLQtBmAEhEAwsC0GZASEQDCsLQZoBIRAMKgtBmwEhEAwpC0GcASEQDCgLQZ0BIRAMJwtBngEhEAwmC0GfASEQDCULQaABIRAMJAtBoQEhEAwjC0GiASEQDCILQaMBIRAMIQtBpAEhEAwgC0GlASEQDB8LQaYBIRAMHgtBpwEhEAwdC0GoASEQDBwLQakBIRAMGwtBqgEhEAwaC0GrASEQDBkLQawBIRAMGAtBrQEhEAwXC0GuASEQDBYLQQEhEAwVC0GvASEQDBQLQbABIRAMEwtBsQEhEAwSC0GzASEQDBELQbIBIRAMEAtBtAEhEAwPC0G1ASEQDA4LQbYBIRAMDQtBtwEhEAwMC0G4ASEQDAsLQbkBIRAMCgtBugEhEAwJC0G7ASEQDAgLQcYBIRAMBwtBvAEhEAwGC0G9ASEQDAULQb4BIRAMBAtBvwEhEAwDC0HAASEQDAILQcIBIRAMAQtBwQEhEAsDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBAOxwEAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB4fICEjJSg/QEFERUZHSElKS0xNT1BRUlPeA1dZW1xdYGJlZmdoaWprbG1vcHFyc3R1dnd4eXp7fH1+gAGCAYUBhgGHAYkBiwGMAY0BjgGPAZABkQGUAZUBlgGXAZgBmQGaAZsBnAGdAZ4BnwGgAaEBogGjAaQBpQGmAacBqAGpAaoBqwGsAa0BrgGvAbABsQGyAbMBtAG1AbYBtwG4AbkBugG7AbwBvQG+Ab8BwAHBAcIBwwHEAcUBxgHHAcgByQHKAcsBzAHNAc4BzwHQAdEB0gHTAdQB1QHWAdcB2AHZAdoB2wHcAd0B3gHgAeEB4gHjAeQB5QHmAecB6AHpAeoB6wHsAe0B7gHvAfAB8QHyAfMBmQKkArAC/gL+AgsgASIEIAJHDfMBQd0BIRAM/wMLIAEiECACRw3dAUHDASEQDP4DCyABIgEgAkcNkAFB9wAhEAz9AwsgASIBIAJHDYYBQe8AIRAM/AMLIAEiASACRw1/QeoAIRAM+wMLIAEiASACRw17QegAIRAM+gMLIAEiASACRw14QeYAIRAM+QMLIAEiASACRw0aQRghEAz4AwsgASIBIAJHDRRBEiEQDPcDCyABIgEgAkcNWUHFACEQDPYDCyABIgEgAkcNSkE/IRAM9QMLIAEiASACRw1IQTwhEAz0AwsgASIBIAJHDUFBMSEQDPMDCyAALQAuQQFGDesDDIcCCyAAIAEiASACEMCAgIAAQQFHDeYBIABCADcDIAznAQsgACABIgEgAhC0gICAACIQDecBIAEhAQz1AgsCQCABIgEgAkcNAEEGIRAM8AMLIAAgAUEBaiIBIAIQu4CAgAAiEA3oASABIQEMMQsgAEIANwMgQRIhEAzVAwsgASIQIAJHDStBHSEQDO0DCwJAIAEiASACRg0AIAFBAWohAUEQIRAM1AMLQQchEAzsAwsgAEIAIAApAyAiESACIAEiEGutIhJ9IhMgEyARVhs3AyAgESASViIURQ3lAUEIIRAM6wMLAkAgASIBIAJGDQAgAEGJgICAADYCCCAAIAE2AgQgASEBQRQhEAzSAwtBCSEQDOoDCyABIQEgACkDIFAN5AEgASEBDPICCwJAIAEiASACRw0AQQshEAzpAwsgACABQQFqIgEgAhC2gICAACIQDeUBIAEhAQzyAgsgACABIgEgAhC4gICAACIQDeUBIAEhAQzyAgsgACABIgEgAhC4gICAACIQDeYBIAEhAQwNCyAAIAEiASACELqAgIAAIhAN5wEgASEBDPACCwJAIAEiASACRw0AQQ8hEAzlAwsgAS0AACIQQTtGDQggEEENRw3oASABQQFqIQEM7wILIAAgASIBIAIQuoCAgAAiEA3oASABIQEM8gILA0ACQCABLQAAQfC1gIAAai0AACIQQQFGDQAgEEECRw3rASAAKAIEIRAgAEEANgIEIAAgECABQQFqIgEQuYCAgAAiEA3qASABIQEM9AILIAFBAWoiASACRw0AC0ESIRAM4gMLIAAgASIBIAIQuoCAgAAiEA3pASABIQEMCgsgASIBIAJHDQZBGyEQDOADCwJAIAEiASACRw0AQRYhEAzgAwsgAEGKgICAADYCCCAAIAE2AgQgACABIAIQuICAgAAiEA3qASABIQFBICEQDMYDCwJAIAEiASACRg0AA0ACQCABLQAAQfC3gIAAai0AACIQQQJGDQACQCAQQX9qDgTlAewBAOsB7AELIAFBAWohAUEIIRAMyAMLIAFBAWoiASACRw0AC0EVIRAM3wMLQRUhEAzeAwsDQAJAIAEtAABB8LmAgABqLQAAIhBBAkYNACAQQX9qDgTeAewB4AHrAewBCyABQQFqIgEgAkcNAAtBGCEQDN0DCwJAIAEiASACRg0AIABBi4CAgAA2AgggACABNgIEIAEhAUEHIRAMxAMLQRkhEAzcAwsgAUEBaiEBDAILAkAgASIUIAJHDQBBGiEQDNsDCyAUIQECQCAULQAAQXNqDhTdAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAgDuAgtBACEQIABBADYCHCAAQa+LgIAANgIQIABBAjYCDCAAIBRBAWo2AhQM2gMLAkAgAS0AACIQQTtGDQAgEEENRw3oASABQQFqIQEM5QILIAFBAWohAQtBIiEQDL8DCwJAIAEiECACRw0AQRwhEAzYAwtCACERIBAhASAQLQAAQVBqDjfnAeYBAQIDBAUGBwgAAAAAAAAACQoLDA0OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPEBESExQAC0EeIRAMvQMLQgIhEQzlAQtCAyERDOQBC0IEIREM4wELQgUhEQziAQtCBiERDOEBC0IHIREM4AELQgghEQzfAQtCCSERDN4BC0IKIREM3QELQgshEQzcAQtCDCERDNsBC0INIREM2gELQg4hEQzZAQtCDyERDNgBC0IKIREM1wELQgshEQzWAQtCDCERDNUBC0INIREM1AELQg4hEQzTAQtCDyERDNIBC0IAIRECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBAtAABBUGoON+UB5AEAAQIDBAUGB+YB5gHmAeYB5gHmAeYBCAkKCwwN5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAQ4PEBESE+YBC0ICIREM5AELQgMhEQzjAQtCBCERDOIBC0IFIREM4QELQgYhEQzgAQtCByERDN8BC0IIIREM3gELQgkhEQzdAQtCCiERDNwBC0ILIREM2wELQgwhEQzaAQtCDSERDNkBC0IOIREM2AELQg8hEQzXAQtCCiERDNYBC0ILIREM1QELQgwhEQzUAQtCDSERDNMBC0IOIREM0gELQg8hEQzRAQsgAEIAIAApAyAiESACIAEiEGutIhJ9IhMgEyARVhs3AyAgESASViIURQ3SAUEfIRAMwAMLAkAgASIBIAJGDQAgAEGJgICAADYCCCAAIAE2AgQgASEBQSQhEAynAwtBICEQDL8DCyAAIAEiECACEL6AgIAAQX9qDgW2AQDFAgHRAdIBC0ERIRAMpAMLIABBAToALyAQIQEMuwMLIAEiASACRw3SAUEkIRAMuwMLIAEiDSACRw0eQcYAIRAMugMLIAAgASIBIAIQsoCAgAAiEA3UASABIQEMtQELIAEiECACRw0mQdAAIRAMuAMLAkAgASIBIAJHDQBBKCEQDLgDCyAAQQA2AgQgAEGMgICAADYCCCAAIAEgARCxgICAACIQDdMBIAEhAQzYAQsCQCABIhAgAkcNAEEpIRAMtwMLIBAtAAAiAUEgRg0UIAFBCUcN0wEgEEEBaiEBDBULAkAgASIBIAJGDQAgAUEBaiEBDBcLQSohEAy1AwsCQCABIhAgAkcNAEErIRAMtQMLAkAgEC0AACIBQQlGDQAgAUEgRw3VAQsgAC0ALEEIRg3TASAQIQEMkQMLAkAgASIBIAJHDQBBLCEQDLQDCyABLQAAQQpHDdUBIAFBAWohAQzJAgsgASIOIAJHDdUBQS8hEAyyAwsDQAJAIAEtAAAiEEEgRg0AAkAgEEF2ag4EANwB3AEA2gELIAEhAQzgAQsgAUEBaiIBIAJHDQALQTEhEAyxAwtBMiEQIAEiFCACRg2wAyACIBRrIAAoAgAiAWohFSAUIAFrQQNqIRYCQANAIBQtAAAiF0EgciAXIBdBv39qQf8BcUEaSRtB/wFxIAFB8LuAgABqLQAARw0BAkAgAUEDRw0AQQYhAQyWAwsgAUEBaiEBIBRBAWoiFCACRw0ACyAAIBU2AgAMsQMLIABBADYCACAUIQEM2QELQTMhECABIhQgAkYNrwMgAiAUayAAKAIAIgFqIRUgFCABa0EIaiEWAkADQCAULQAAIhdBIHIgFyAXQb9/akH/AXFBGkkbQf8BcSABQfS7gIAAai0AAEcNAQJAIAFBCEcNAEEFIQEMlQMLIAFBAWohASAUQQFqIhQgAkcNAAsgACAVNgIADLADCyAAQQA2AgAgFCEBDNgBC0E0IRAgASIUIAJGDa4DIAIgFGsgACgCACIBaiEVIBQgAWtBBWohFgJAA0AgFC0AACIXQSByIBcgF0G/f2pB/wFxQRpJG0H/AXEgAUHQwoCAAGotAABHDQECQCABQQVHDQBBByEBDJQDCyABQQFqIQEgFEEBaiIUIAJHDQALIAAgFTYCAAyvAwsgAEEANgIAIBQhAQzXAQsCQCABIgEgAkYNAANAAkAgAS0AAEGAvoCAAGotAAAiEEEBRg0AIBBBAkYNCiABIQEM3QELIAFBAWoiASACRw0AC0EwIRAMrgMLQTAhEAytAwsCQCABIgEgAkYNAANAAkAgAS0AACIQQSBGDQAgEEF2ag4E2QHaAdoB2QHaAQsgAUEBaiIBIAJHDQALQTghEAytAwtBOCEQDKwDCwNAAkAgAS0AACIQQSBGDQAgEEEJRw0DCyABQQFqIgEgAkcNAAtBPCEQDKsDCwNAAkAgAS0AACIQQSBGDQACQAJAIBBBdmoOBNoBAQHaAQALIBBBLEYN2wELIAEhAQwECyABQQFqIgEgAkcNAAtBPyEQDKoDCyABIQEM2wELQcAAIRAgASIUIAJGDagDIAIgFGsgACgCACIBaiEWIBQgAWtBBmohFwJAA0AgFC0AAEEgciABQYDAgIAAai0AAEcNASABQQZGDY4DIAFBAWohASAUQQFqIhQgAkcNAAsgACAWNgIADKkDCyAAQQA2AgAgFCEBC0E2IRAMjgMLAkAgASIPIAJHDQBBwQAhEAynAwsgAEGMgICAADYCCCAAIA82AgQgDyEBIAAtACxBf2oOBM0B1QHXAdkBhwMLIAFBAWohAQzMAQsCQCABIgEgAkYNAANAAkAgAS0AACIQQSByIBAgEEG/f2pB/wFxQRpJG0H/AXEiEEEJRg0AIBBBIEYNAAJAAkACQAJAIBBBnX9qDhMAAwMDAwMDAwEDAwMDAwMDAwMCAwsgAUEBaiEBQTEhEAyRAwsgAUEBaiEBQTIhEAyQAwsgAUEBaiEBQTMhEAyPAwsgASEBDNABCyABQQFqIgEgAkcNAAtBNSEQDKUDC0E1IRAMpAMLAkAgASIBIAJGDQADQAJAIAEtAABBgLyAgABqLQAAQQFGDQAgASEBDNMBCyABQQFqIgEgAkcNAAtBPSEQDKQDC0E9IRAMowMLIAAgASIBIAIQsICAgAAiEA3WASABIQEMAQsgEEEBaiEBC0E8IRAMhwMLAkAgASIBIAJHDQBBwgAhEAygAwsCQANAAkAgAS0AAEF3ag4YAAL+Av4ChAP+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gIA/gILIAFBAWoiASACRw0AC0HCACEQDKADCyABQQFqIQEgAC0ALUEBcUUNvQEgASEBC0EsIRAMhQMLIAEiASACRw3TAUHEACEQDJ0DCwNAAkAgAS0AAEGQwICAAGotAABBAUYNACABIQEMtwILIAFBAWoiASACRw0AC0HFACEQDJwDCyANLQAAIhBBIEYNswEgEEE6Rw2BAyAAKAIEIQEgAEEANgIEIAAgASANEK+AgIAAIgEN0AEgDUEBaiEBDLMCC0HHACEQIAEiDSACRg2aAyACIA1rIAAoAgAiAWohFiANIAFrQQVqIRcDQCANLQAAIhRBIHIgFCAUQb9/akH/AXFBGkkbQf8BcSABQZDCgIAAai0AAEcNgAMgAUEFRg30AiABQQFqIQEgDUEBaiINIAJHDQALIAAgFjYCAAyaAwtByAAhECABIg0gAkYNmQMgAiANayAAKAIAIgFqIRYgDSABa0EJaiEXA0AgDS0AACIUQSByIBQgFEG/f2pB/wFxQRpJG0H/AXEgAUGWwoCAAGotAABHDf8CAkAgAUEJRw0AQQIhAQz1AgsgAUEBaiEBIA1BAWoiDSACRw0ACyAAIBY2AgAMmQMLAkAgASINIAJHDQBByQAhEAyZAwsCQAJAIA0tAAAiAUEgciABIAFBv39qQf8BcUEaSRtB/wFxQZJ/ag4HAIADgAOAA4ADgAMBgAMLIA1BAWohAUE+IRAMgAMLIA1BAWohAUE/IRAM/wILQcoAIRAgASINIAJGDZcDIAIgDWsgACgCACIBaiEWIA0gAWtBAWohFwNAIA0tAAAiFEEgciAUIBRBv39qQf8BcUEaSRtB/wFxIAFBoMKAgABqLQAARw39AiABQQFGDfACIAFBAWohASANQQFqIg0gAkcNAAsgACAWNgIADJcDC0HLACEQIAEiDSACRg2WAyACIA1rIAAoAgAiAWohFiANIAFrQQ5qIRcDQCANLQAAIhRBIHIgFCAUQb9/akH/AXFBGkkbQf8BcSABQaLCgIAAai0AAEcN/AIgAUEORg3wAiABQQFqIQEgDUEBaiINIAJHDQALIAAgFjYCAAyWAwtBzAAhECABIg0gAkYNlQMgAiANayAAKAIAIgFqIRYgDSABa0EPaiEXA0AgDS0AACIUQSByIBQgFEG/f2pB/wFxQRpJG0H/AXEgAUHAwoCAAGotAABHDfsCAkAgAUEPRw0AQQMhAQzxAgsgAUEBaiEBIA1BAWoiDSACRw0ACyAAIBY2AgAMlQMLQc0AIRAgASINIAJGDZQDIAIgDWsgACgCACIBaiEWIA0gAWtBBWohFwNAIA0tAAAiFEEgciAUIBRBv39qQf8BcUEaSRtB/wFxIAFB0MKAgABqLQAARw36AgJAIAFBBUcNAEEEIQEM8AILIAFBAWohASANQQFqIg0gAkcNAAsgACAWNgIADJQDCwJAIAEiDSACRw0AQc4AIRAMlAMLAkACQAJAAkAgDS0AACIBQSByIAEgAUG/f2pB/wFxQRpJG0H/AXFBnX9qDhMA/QL9Av0C/QL9Av0C/QL9Av0C/QL9Av0CAf0C/QL9AgID/QILIA1BAWohAUHBACEQDP0CCyANQQFqIQFBwgAhEAz8AgsgDUEBaiEBQcMAIRAM+wILIA1BAWohAUHEACEQDPoCCwJAIAEiASACRg0AIABBjYCAgAA2AgggACABNgIEIAEhAUHFACEQDPoCC0HPACEQDJIDCyAQIQECQAJAIBAtAABBdmoOBAGoAqgCAKgCCyAQQQFqIQELQSchEAz4AgsCQCABIgEgAkcNAEHRACEQDJEDCwJAIAEtAABBIEYNACABIQEMjQELIAFBAWohASAALQAtQQFxRQ3HASABIQEMjAELIAEiFyACRw3IAUHSACEQDI8DC0HTACEQIAEiFCACRg2OAyACIBRrIAAoAgAiAWohFiAUIAFrQQFqIRcDQCAULQAAIAFB1sKAgABqLQAARw3MASABQQFGDccBIAFBAWohASAUQQFqIhQgAkcNAAsgACAWNgIADI4DCwJAIAEiASACRw0AQdUAIRAMjgMLIAEtAABBCkcNzAEgAUEBaiEBDMcBCwJAIAEiASACRw0AQdYAIRAMjQMLAkACQCABLQAAQXZqDgQAzQHNAQHNAQsgAUEBaiEBDMcBCyABQQFqIQFBygAhEAzzAgsgACABIgEgAhCugICAACIQDcsBIAEhAUHNACEQDPICCyAALQApQSJGDYUDDKYCCwJAIAEiASACRw0AQdsAIRAMigMLQQAhFEEBIRdBASEWQQAhEAJAAkACQAJAAkACQAJAAkACQCABLQAAQVBqDgrUAdMBAAECAwQFBgjVAQtBAiEQDAYLQQMhEAwFC0EEIRAMBAtBBSEQDAMLQQYhEAwCC0EHIRAMAQtBCCEQC0EAIRdBACEWQQAhFAzMAQtBCSEQQQEhFEEAIRdBACEWDMsBCwJAIAEiASACRw0AQd0AIRAMiQMLIAEtAABBLkcNzAEgAUEBaiEBDKYCCyABIgEgAkcNzAFB3wAhEAyHAwsCQCABIgEgAkYNACAAQY6AgIAANgIIIAAgATYCBCABIQFB0AAhEAzuAgtB4AAhEAyGAwtB4QAhECABIgEgAkYNhQMgAiABayAAKAIAIhRqIRYgASAUa0EDaiEXA0AgAS0AACAUQeLCgIAAai0AAEcNzQEgFEEDRg3MASAUQQFqIRQgAUEBaiIBIAJHDQALIAAgFjYCAAyFAwtB4gAhECABIgEgAkYNhAMgAiABayAAKAIAIhRqIRYgASAUa0ECaiEXA0AgAS0AACAUQebCgIAAai0AAEcNzAEgFEECRg3OASAUQQFqIRQgAUEBaiIBIAJHDQALIAAgFjYCAAyEAwtB4wAhECABIgEgAkYNgwMgAiABayAAKAIAIhRqIRYgASAUa0EDaiEXA0AgAS0AACAUQenCgIAAai0AAEcNywEgFEEDRg3OASAUQQFqIRQgAUEBaiIBIAJHDQALIAAgFjYCAAyDAwsCQCABIgEgAkcNAEHlACEQDIMDCyAAIAFBAWoiASACEKiAgIAAIhANzQEgASEBQdYAIRAM6QILAkAgASIBIAJGDQADQAJAIAEtAAAiEEEgRg0AAkACQAJAIBBBuH9qDgsAAc8BzwHPAc8BzwHPAc8BzwECzwELIAFBAWohAUHSACEQDO0CCyABQQFqIQFB0wAhEAzsAgsgAUEBaiEBQdQAIRAM6wILIAFBAWoiASACRw0AC0HkACEQDIIDC0HkACEQDIEDCwNAAkAgAS0AAEHwwoCAAGotAAAiEEEBRg0AIBBBfmoOA88B0AHRAdIBCyABQQFqIgEgAkcNAAtB5gAhEAyAAwsCQCABIgEgAkYNACABQQFqIQEMAwtB5wAhEAz/AgsDQAJAIAEtAABB8MSAgABqLQAAIhBBAUYNAAJAIBBBfmoOBNIB0wHUAQDVAQsgASEBQdcAIRAM5wILIAFBAWoiASACRw0AC0HoACEQDP4CCwJAIAEiASACRw0AQekAIRAM/gILAkAgAS0AACIQQXZqDhq6AdUB1QG8AdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAcoB1QHVAQDTAQsgAUEBaiEBC0EGIRAM4wILA0ACQCABLQAAQfDGgIAAai0AAEEBRg0AIAEhAQyeAgsgAUEBaiIBIAJHDQALQeoAIRAM+wILAkAgASIBIAJGDQAgAUEBaiEBDAMLQesAIRAM+gILAkAgASIBIAJHDQBB7AAhEAz6AgsgAUEBaiEBDAELAkAgASIBIAJHDQBB7QAhEAz5AgsgAUEBaiEBC0EEIRAM3gILAkAgASIUIAJHDQBB7gAhEAz3AgsgFCEBAkACQAJAIBQtAABB8MiAgABqLQAAQX9qDgfUAdUB1gEAnAIBAtcBCyAUQQFqIQEMCgsgFEEBaiEBDM0BC0EAIRAgAEEANgIcIABBm5KAgAA2AhAgAEEHNgIMIAAgFEEBajYCFAz2AgsCQANAAkAgAS0AAEHwyICAAGotAAAiEEEERg0AAkACQCAQQX9qDgfSAdMB1AHZAQAEAdkBCyABIQFB2gAhEAzgAgsgAUEBaiEBQdwAIRAM3wILIAFBAWoiASACRw0AC0HvACEQDPYCCyABQQFqIQEMywELAkAgASIUIAJHDQBB8AAhEAz1AgsgFC0AAEEvRw3UASAUQQFqIQEMBgsCQCABIhQgAkcNAEHxACEQDPQCCwJAIBQtAAAiAUEvRw0AIBRBAWohAUHdACEQDNsCCyABQXZqIgRBFksN0wFBASAEdEGJgIACcUUN0wEMygILAkAgASIBIAJGDQAgAUEBaiEBQd4AIRAM2gILQfIAIRAM8gILAkAgASIUIAJHDQBB9AAhEAzyAgsgFCEBAkAgFC0AAEHwzICAAGotAABBf2oOA8kClAIA1AELQeEAIRAM2AILAkAgASIUIAJGDQADQAJAIBQtAABB8MqAgABqLQAAIgFBA0YNAAJAIAFBf2oOAssCANUBCyAUIQFB3wAhEAzaAgsgFEEBaiIUIAJHDQALQfMAIRAM8QILQfMAIRAM8AILAkAgASIBIAJGDQAgAEGPgICAADYCCCAAIAE2AgQgASEBQeAAIRAM1wILQfUAIRAM7wILAkAgASIBIAJHDQBB9gAhEAzvAgsgAEGPgICAADYCCCAAIAE2AgQgASEBC0EDIRAM1AILA0AgAS0AAEEgRw3DAiABQQFqIgEgAkcNAAtB9wAhEAzsAgsCQCABIgEgAkcNAEH4ACEQDOwCCyABLQAAQSBHDc4BIAFBAWohAQzvAQsgACABIgEgAhCsgICAACIQDc4BIAEhAQyOAgsCQCABIgQgAkcNAEH6ACEQDOoCCyAELQAAQcwARw3RASAEQQFqIQFBEyEQDM8BCwJAIAEiBCACRw0AQfsAIRAM6QILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEANAIAQtAAAgAUHwzoCAAGotAABHDdABIAFBBUYNzgEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBB+wAhEAzoAgsCQCABIgQgAkcNAEH8ACEQDOgCCwJAAkAgBC0AAEG9f2oODADRAdEB0QHRAdEB0QHRAdEB0QHRAQHRAQsgBEEBaiEBQeYAIRAMzwILIARBAWohAUHnACEQDM4CCwJAIAEiBCACRw0AQf0AIRAM5wILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQe3PgIAAai0AAEcNzwEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQf0AIRAM5wILIABBADYCACAQQQFqIQFBECEQDMwBCwJAIAEiBCACRw0AQf4AIRAM5gILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEAJAA0AgBC0AACABQfbOgIAAai0AAEcNzgEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQf4AIRAM5gILIABBADYCACAQQQFqIQFBFiEQDMsBCwJAIAEiBCACRw0AQf8AIRAM5QILIAIgBGsgACgCACIBaiEUIAQgAWtBA2ohEAJAA0AgBC0AACABQfzOgIAAai0AAEcNzQEgAUEDRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQf8AIRAM5QILIABBADYCACAQQQFqIQFBBSEQDMoBCwJAIAEiBCACRw0AQYABIRAM5AILIAQtAABB2QBHDcsBIARBAWohAUEIIRAMyQELAkAgASIEIAJHDQBBgQEhEAzjAgsCQAJAIAQtAABBsn9qDgMAzAEBzAELIARBAWohAUHrACEQDMoCCyAEQQFqIQFB7AAhEAzJAgsCQCABIgQgAkcNAEGCASEQDOICCwJAAkAgBC0AAEG4f2oOCADLAcsBywHLAcsBywEBywELIARBAWohAUHqACEQDMkCCyAEQQFqIQFB7QAhEAzIAgsCQCABIgQgAkcNAEGDASEQDOECCyACIARrIAAoAgAiAWohECAEIAFrQQJqIRQCQANAIAQtAAAgAUGAz4CAAGotAABHDckBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgEDYCAEGDASEQDOECC0EAIRAgAEEANgIAIBRBAWohAQzGAQsCQCABIgQgAkcNAEGEASEQDOACCyACIARrIAAoAgAiAWohFCAEIAFrQQRqIRACQANAIAQtAAAgAUGDz4CAAGotAABHDcgBIAFBBEYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGEASEQDOACCyAAQQA2AgAgEEEBaiEBQSMhEAzFAQsCQCABIgQgAkcNAEGFASEQDN8CCwJAAkAgBC0AAEG0f2oOCADIAcgByAHIAcgByAEByAELIARBAWohAUHvACEQDMYCCyAEQQFqIQFB8AAhEAzFAgsCQCABIgQgAkcNAEGGASEQDN4CCyAELQAAQcUARw3FASAEQQFqIQEMgwILAkAgASIEIAJHDQBBhwEhEAzdAgsgAiAEayAAKAIAIgFqIRQgBCABa0EDaiEQAkADQCAELQAAIAFBiM+AgABqLQAARw3FASABQQNGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBhwEhEAzdAgsgAEEANgIAIBBBAWohAUEtIRAMwgELAkAgASIEIAJHDQBBiAEhEAzcAgsgAiAEayAAKAIAIgFqIRQgBCABa0EIaiEQAkADQCAELQAAIAFB0M+AgABqLQAARw3EASABQQhGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBiAEhEAzcAgsgAEEANgIAIBBBAWohAUEpIRAMwQELAkAgASIBIAJHDQBBiQEhEAzbAgtBASEQIAEtAABB3wBHDcABIAFBAWohAQyBAgsCQCABIgQgAkcNAEGKASEQDNoCCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRADQCAELQAAIAFBjM+AgABqLQAARw3BASABQQFGDa8CIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQYoBIRAM2QILAkAgASIEIAJHDQBBiwEhEAzZAgsgAiAEayAAKAIAIgFqIRQgBCABa0ECaiEQAkADQCAELQAAIAFBjs+AgABqLQAARw3BASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBiwEhEAzZAgsgAEEANgIAIBBBAWohAUECIRAMvgELAkAgASIEIAJHDQBBjAEhEAzYAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFB8M+AgABqLQAARw3AASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBjAEhEAzYAgsgAEEANgIAIBBBAWohAUEfIRAMvQELAkAgASIEIAJHDQBBjQEhEAzXAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFB8s+AgABqLQAARw2/ASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBjQEhEAzXAgsgAEEANgIAIBBBAWohAUEJIRAMvAELAkAgASIEIAJHDQBBjgEhEAzWAgsCQAJAIAQtAABBt39qDgcAvwG/Ab8BvwG/AQG/AQsgBEEBaiEBQfgAIRAMvQILIARBAWohAUH5ACEQDLwCCwJAIAEiBCACRw0AQY8BIRAM1QILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEAJAA0AgBC0AACABQZHPgIAAai0AAEcNvQEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQY8BIRAM1QILIABBADYCACAQQQFqIQFBGCEQDLoBCwJAIAEiBCACRw0AQZABIRAM1AILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQZfPgIAAai0AAEcNvAEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZABIRAM1AILIABBADYCACAQQQFqIQFBFyEQDLkBCwJAIAEiBCACRw0AQZEBIRAM0wILIAIgBGsgACgCACIBaiEUIAQgAWtBBmohEAJAA0AgBC0AACABQZrPgIAAai0AAEcNuwEgAUEGRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZEBIRAM0wILIABBADYCACAQQQFqIQFBFSEQDLgBCwJAIAEiBCACRw0AQZIBIRAM0gILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEAJAA0AgBC0AACABQaHPgIAAai0AAEcNugEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZIBIRAM0gILIABBADYCACAQQQFqIQFBHiEQDLcBCwJAIAEiBCACRw0AQZMBIRAM0QILIAQtAABBzABHDbgBIARBAWohAUEKIRAMtgELAkAgBCACRw0AQZQBIRAM0AILAkACQCAELQAAQb9/ag4PALkBuQG5AbkBuQG5AbkBuQG5AbkBuQG5AbkBAbkBCyAEQQFqIQFB/gAhEAy3AgsgBEEBaiEBQf8AIRAMtgILAkAgBCACRw0AQZUBIRAMzwILAkACQCAELQAAQb9/ag4DALgBAbgBCyAEQQFqIQFB/QAhEAy2AgsgBEEBaiEEQYABIRAMtQILAkAgBCACRw0AQZYBIRAMzgILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQafPgIAAai0AAEcNtgEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZYBIRAMzgILIABBADYCACAQQQFqIQFBCyEQDLMBCwJAIAQgAkcNAEGXASEQDM0CCwJAAkACQAJAIAQtAABBU2oOIwC4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBAbgBuAG4AbgBuAECuAG4AbgBA7gBCyAEQQFqIQFB+wAhEAy2AgsgBEEBaiEBQfwAIRAMtQILIARBAWohBEGBASEQDLQCCyAEQQFqIQRBggEhEAyzAgsCQCAEIAJHDQBBmAEhEAzMAgsgAiAEayAAKAIAIgFqIRQgBCABa0EEaiEQAkADQCAELQAAIAFBqc+AgABqLQAARw20ASABQQRGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBmAEhEAzMAgsgAEEANgIAIBBBAWohAUEZIRAMsQELAkAgBCACRw0AQZkBIRAMywILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEAJAA0AgBC0AACABQa7PgIAAai0AAEcNswEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZkBIRAMywILIABBADYCACAQQQFqIQFBBiEQDLABCwJAIAQgAkcNAEGaASEQDMoCCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRACQANAIAQtAAAgAUG0z4CAAGotAABHDbIBIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGaASEQDMoCCyAAQQA2AgAgEEEBaiEBQRwhEAyvAQsCQCAEIAJHDQBBmwEhEAzJAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFBts+AgABqLQAARw2xASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBmwEhEAzJAgsgAEEANgIAIBBBAWohAUEnIRAMrgELAkAgBCACRw0AQZwBIRAMyAILAkACQCAELQAAQax/ag4CAAGxAQsgBEEBaiEEQYYBIRAMrwILIARBAWohBEGHASEQDK4CCwJAIAQgAkcNAEGdASEQDMcCCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRACQANAIAQtAAAgAUG4z4CAAGotAABHDa8BIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGdASEQDMcCCyAAQQA2AgAgEEEBaiEBQSYhEAysAQsCQCAEIAJHDQBBngEhEAzGAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFBus+AgABqLQAARw2uASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBngEhEAzGAgsgAEEANgIAIBBBAWohAUEDIRAMqwELAkAgBCACRw0AQZ8BIRAMxQILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQe3PgIAAai0AAEcNrQEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZ8BIRAMxQILIABBADYCACAQQQFqIQFBDCEQDKoBCwJAIAQgAkcNAEGgASEQDMQCCyACIARrIAAoAgAiAWohFCAEIAFrQQNqIRACQANAIAQtAAAgAUG8z4CAAGotAABHDawBIAFBA0YNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGgASEQDMQCCyAAQQA2AgAgEEEBaiEBQQ0hEAypAQsCQCAEIAJHDQBBoQEhEAzDAgsCQAJAIAQtAABBun9qDgsArAGsAawBrAGsAawBrAGsAawBAawBCyAEQQFqIQRBiwEhEAyqAgsgBEEBaiEEQYwBIRAMqQILAkAgBCACRw0AQaIBIRAMwgILIAQtAABB0ABHDakBIARBAWohBAzpAQsCQCAEIAJHDQBBowEhEAzBAgsCQAJAIAQtAABBt39qDgcBqgGqAaoBqgGqAQCqAQsgBEEBaiEEQY4BIRAMqAILIARBAWohAUEiIRAMpgELAkAgBCACRw0AQaQBIRAMwAILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQcDPgIAAai0AAEcNqAEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQaQBIRAMwAILIABBADYCACAQQQFqIQFBHSEQDKUBCwJAIAQgAkcNAEGlASEQDL8CCwJAAkAgBC0AAEGuf2oOAwCoAQGoAQsgBEEBaiEEQZABIRAMpgILIARBAWohAUEEIRAMpAELAkAgBCACRw0AQaYBIRAMvgILAkACQAJAAkACQCAELQAAQb9/ag4VAKoBqgGqAaoBqgGqAaoBqgGqAaoBAaoBqgECqgGqAQOqAaoBBKoBCyAEQQFqIQRBiAEhEAyoAgsgBEEBaiEEQYkBIRAMpwILIARBAWohBEGKASEQDKYCCyAEQQFqIQRBjwEhEAylAgsgBEEBaiEEQZEBIRAMpAILAkAgBCACRw0AQacBIRAMvQILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQe3PgIAAai0AAEcNpQEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQacBIRAMvQILIABBADYCACAQQQFqIQFBESEQDKIBCwJAIAQgAkcNAEGoASEQDLwCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHCz4CAAGotAABHDaQBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGoASEQDLwCCyAAQQA2AgAgEEEBaiEBQSwhEAyhAQsCQCAEIAJHDQBBqQEhEAy7AgsgAiAEayAAKAIAIgFqIRQgBCABa0EEaiEQAkADQCAELQAAIAFBxc+AgABqLQAARw2jASABQQRGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBqQEhEAy7AgsgAEEANgIAIBBBAWohAUErIRAMoAELAkAgBCACRw0AQaoBIRAMugILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQcrPgIAAai0AAEcNogEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQaoBIRAMugILIABBADYCACAQQQFqIQFBFCEQDJ8BCwJAIAQgAkcNAEGrASEQDLkCCwJAAkACQAJAIAQtAABBvn9qDg8AAQKkAaQBpAGkAaQBpAGkAaQBpAGkAaQBA6QBCyAEQQFqIQRBkwEhEAyiAgsgBEEBaiEEQZQBIRAMoQILIARBAWohBEGVASEQDKACCyAEQQFqIQRBlgEhEAyfAgsCQCAEIAJHDQBBrAEhEAy4AgsgBC0AAEHFAEcNnwEgBEEBaiEEDOABCwJAIAQgAkcNAEGtASEQDLcCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHNz4CAAGotAABHDZ8BIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGtASEQDLcCCyAAQQA2AgAgEEEBaiEBQQ4hEAycAQsCQCAEIAJHDQBBrgEhEAy2AgsgBC0AAEHQAEcNnQEgBEEBaiEBQSUhEAybAQsCQCAEIAJHDQBBrwEhEAy1AgsgAiAEayAAKAIAIgFqIRQgBCABa0EIaiEQAkADQCAELQAAIAFB0M+AgABqLQAARw2dASABQQhGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBrwEhEAy1AgsgAEEANgIAIBBBAWohAUEqIRAMmgELAkAgBCACRw0AQbABIRAMtAILAkACQCAELQAAQat/ag4LAJ0BnQGdAZ0BnQGdAZ0BnQGdAQGdAQsgBEEBaiEEQZoBIRAMmwILIARBAWohBEGbASEQDJoCCwJAIAQgAkcNAEGxASEQDLMCCwJAAkAgBC0AAEG/f2oOFACcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAEBnAELIARBAWohBEGZASEQDJoCCyAEQQFqIQRBnAEhEAyZAgsCQCAEIAJHDQBBsgEhEAyyAgsgAiAEayAAKAIAIgFqIRQgBCABa0EDaiEQAkADQCAELQAAIAFB2c+AgABqLQAARw2aASABQQNGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBsgEhEAyyAgsgAEEANgIAIBBBAWohAUEhIRAMlwELAkAgBCACRw0AQbMBIRAMsQILIAIgBGsgACgCACIBaiEUIAQgAWtBBmohEAJAA0AgBC0AACABQd3PgIAAai0AAEcNmQEgAUEGRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQbMBIRAMsQILIABBADYCACAQQQFqIQFBGiEQDJYBCwJAIAQgAkcNAEG0ASEQDLACCwJAAkACQCAELQAAQbt/ag4RAJoBmgGaAZoBmgGaAZoBmgGaAQGaAZoBmgGaAZoBApoBCyAEQQFqIQRBnQEhEAyYAgsgBEEBaiEEQZ4BIRAMlwILIARBAWohBEGfASEQDJYCCwJAIAQgAkcNAEG1ASEQDK8CCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRACQANAIAQtAAAgAUHkz4CAAGotAABHDZcBIAFBBUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEG1ASEQDK8CCyAAQQA2AgAgEEEBaiEBQSghEAyUAQsCQCAEIAJHDQBBtgEhEAyuAgsgAiAEayAAKAIAIgFqIRQgBCABa0ECaiEQAkADQCAELQAAIAFB6s+AgABqLQAARw2WASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBtgEhEAyuAgsgAEEANgIAIBBBAWohAUEHIRAMkwELAkAgBCACRw0AQbcBIRAMrQILAkACQCAELQAAQbt/ag4OAJYBlgGWAZYBlgGWAZYBlgGWAZYBlgGWAQGWAQsgBEEBaiEEQaEBIRAMlAILIARBAWohBEGiASEQDJMCCwJAIAQgAkcNAEG4ASEQDKwCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHtz4CAAGotAABHDZQBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEG4ASEQDKwCCyAAQQA2AgAgEEEBaiEBQRIhEAyRAQsCQCAEIAJHDQBBuQEhEAyrAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFB8M+AgABqLQAARw2TASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBuQEhEAyrAgsgAEEANgIAIBBBAWohAUEgIRAMkAELAkAgBCACRw0AQboBIRAMqgILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQfLPgIAAai0AAEcNkgEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQboBIRAMqgILIABBADYCACAQQQFqIQFBDyEQDI8BCwJAIAQgAkcNAEG7ASEQDKkCCwJAAkAgBC0AAEG3f2oOBwCSAZIBkgGSAZIBAZIBCyAEQQFqIQRBpQEhEAyQAgsgBEEBaiEEQaYBIRAMjwILAkAgBCACRw0AQbwBIRAMqAILIAIgBGsgACgCACIBaiEUIAQgAWtBB2ohEAJAA0AgBC0AACABQfTPgIAAai0AAEcNkAEgAUEHRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQbwBIRAMqAILIABBADYCACAQQQFqIQFBGyEQDI0BCwJAIAQgAkcNAEG9ASEQDKcCCwJAAkACQCAELQAAQb5/ag4SAJEBkQGRAZEBkQGRAZEBkQGRAQGRAZEBkQGRAZEBkQECkQELIARBAWohBEGkASEQDI8CCyAEQQFqIQRBpwEhEAyOAgsgBEEBaiEEQagBIRAMjQILAkAgBCACRw0AQb4BIRAMpgILIAQtAABBzgBHDY0BIARBAWohBAzPAQsCQCAEIAJHDQBBvwEhEAylAgsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAELQAAQb9/ag4VAAECA5wBBAUGnAGcAZwBBwgJCgucAQwNDg+cAQsgBEEBaiEBQegAIRAMmgILIARBAWohAUHpACEQDJkCCyAEQQFqIQFB7gAhEAyYAgsgBEEBaiEBQfIAIRAMlwILIARBAWohAUHzACEQDJYCCyAEQQFqIQFB9gAhEAyVAgsgBEEBaiEBQfcAIRAMlAILIARBAWohAUH6ACEQDJMCCyAEQQFqIQRBgwEhEAySAgsgBEEBaiEEQYQBIRAMkQILIARBAWohBEGFASEQDJACCyAEQQFqIQRBkgEhEAyPAgsgBEEBaiEEQZgBIRAMjgILIARBAWohBEGgASEQDI0CCyAEQQFqIQRBowEhEAyMAgsgBEEBaiEEQaoBIRAMiwILAkAgBCACRg0AIABBkICAgAA2AgggACAENgIEQasBIRAMiwILQcABIRAMowILIAAgBSACEKqAgIAAIgENiwEgBSEBDFwLAkAgBiACRg0AIAZBAWohBQyNAQtBwgEhEAyhAgsDQAJAIBAtAABBdmoOBIwBAACPAQALIBBBAWoiECACRw0AC0HDASEQDKACCwJAIAcgAkYNACAAQZGAgIAANgIIIAAgBzYCBCAHIQFBASEQDIcCC0HEASEQDJ8CCwJAIAcgAkcNAEHFASEQDJ8CCwJAAkAgBy0AAEF2ag4EAc4BzgEAzgELIAdBAWohBgyNAQsgB0EBaiEFDIkBCwJAIAcgAkcNAEHGASEQDJ4CCwJAAkAgBy0AAEF2ag4XAY8BjwEBjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BAI8BCyAHQQFqIQcLQbABIRAMhAILAkAgCCACRw0AQcgBIRAMnQILIAgtAABBIEcNjQEgAEEAOwEyIAhBAWohAUGzASEQDIMCCyABIRcCQANAIBciByACRg0BIActAABBUGpB/wFxIhBBCk8NzAECQCAALwEyIhRBmTNLDQAgACAUQQpsIhQ7ATIgEEH//wNzIBRB/v8DcUkNACAHQQFqIRcgACAUIBBqIhA7ATIgEEH//wNxQegHSQ0BCwtBACEQIABBADYCHCAAQcGJgIAANgIQIABBDTYCDCAAIAdBAWo2AhQMnAILQccBIRAMmwILIAAgCCACEK6AgIAAIhBFDcoBIBBBFUcNjAEgAEHIATYCHCAAIAg2AhQgAEHJl4CAADYCECAAQRU2AgxBACEQDJoCCwJAIAkgAkcNAEHMASEQDJoCC0EAIRRBASEXQQEhFkEAIRACQAJAAkACQAJAAkACQAJAAkAgCS0AAEFQag4KlgGVAQABAgMEBQYIlwELQQIhEAwGC0EDIRAMBQtBBCEQDAQLQQUhEAwDC0EGIRAMAgtBByEQDAELQQghEAtBACEXQQAhFkEAIRQMjgELQQkhEEEBIRRBACEXQQAhFgyNAQsCQCAKIAJHDQBBzgEhEAyZAgsgCi0AAEEuRw2OASAKQQFqIQkMygELIAsgAkcNjgFB0AEhEAyXAgsCQCALIAJGDQAgAEGOgICAADYCCCAAIAs2AgRBtwEhEAz+AQtB0QEhEAyWAgsCQCAEIAJHDQBB0gEhEAyWAgsgAiAEayAAKAIAIhBqIRQgBCAQa0EEaiELA0AgBC0AACAQQfzPgIAAai0AAEcNjgEgEEEERg3pASAQQQFqIRAgBEEBaiIEIAJHDQALIAAgFDYCAEHSASEQDJUCCyAAIAwgAhCsgICAACIBDY0BIAwhAQy4AQsCQCAEIAJHDQBB1AEhEAyUAgsgAiAEayAAKAIAIhBqIRQgBCAQa0EBaiEMA0AgBC0AACAQQYHQgIAAai0AAEcNjwEgEEEBRg2OASAQQQFqIRAgBEEBaiIEIAJHDQALIAAgFDYCAEHUASEQDJMCCwJAIAQgAkcNAEHWASEQDJMCCyACIARrIAAoAgAiEGohFCAEIBBrQQJqIQsDQCAELQAAIBBBg9CAgABqLQAARw2OASAQQQJGDZABIBBBAWohECAEQQFqIgQgAkcNAAsgACAUNgIAQdYBIRAMkgILAkAgBCACRw0AQdcBIRAMkgILAkACQCAELQAAQbt/ag4QAI8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwEBjwELIARBAWohBEG7ASEQDPkBCyAEQQFqIQRBvAEhEAz4AQsCQCAEIAJHDQBB2AEhEAyRAgsgBC0AAEHIAEcNjAEgBEEBaiEEDMQBCwJAIAQgAkYNACAAQZCAgIAANgIIIAAgBDYCBEG+ASEQDPcBC0HZASEQDI8CCwJAIAQgAkcNAEHaASEQDI8CCyAELQAAQcgARg3DASAAQQE6ACgMuQELIABBAjoALyAAIAQgAhCmgICAACIQDY0BQcIBIRAM9AELIAAtAChBf2oOArcBuQG4AQsDQAJAIAQtAABBdmoOBACOAY4BAI4BCyAEQQFqIgQgAkcNAAtB3QEhEAyLAgsgAEEAOgAvIAAtAC1BBHFFDYQCCyAAQQA6AC8gAEEBOgA0IAEhAQyMAQsgEEEVRg3aASAAQQA2AhwgACABNgIUIABBp46AgAA2AhAgAEESNgIMQQAhEAyIAgsCQCAAIBAgAhC0gICAACIEDQAgECEBDIECCwJAIARBFUcNACAAQQM2AhwgACAQNgIUIABBsJiAgAA2AhAgAEEVNgIMQQAhEAyIAgsgAEEANgIcIAAgEDYCFCAAQaeOgIAANgIQIABBEjYCDEEAIRAMhwILIBBBFUYN1gEgAEEANgIcIAAgATYCFCAAQdqNgIAANgIQIABBFDYCDEEAIRAMhgILIAAoAgQhFyAAQQA2AgQgECARp2oiFiEBIAAgFyAQIBYgFBsiEBC1gICAACIURQ2NASAAQQc2AhwgACAQNgIUIAAgFDYCDEEAIRAMhQILIAAgAC8BMEGAAXI7ATAgASEBC0EqIRAM6gELIBBBFUYN0QEgAEEANgIcIAAgATYCFCAAQYOMgIAANgIQIABBEzYCDEEAIRAMggILIBBBFUYNzwEgAEEANgIcIAAgATYCFCAAQZqPgIAANgIQIABBIjYCDEEAIRAMgQILIAAoAgQhECAAQQA2AgQCQCAAIBAgARC3gICAACIQDQAgAUEBaiEBDI0BCyAAQQw2AhwgACAQNgIMIAAgAUEBajYCFEEAIRAMgAILIBBBFUYNzAEgAEEANgIcIAAgATYCFCAAQZqPgIAANgIQIABBIjYCDEEAIRAM/wELIAAoAgQhECAAQQA2AgQCQCAAIBAgARC3gICAACIQDQAgAUEBaiEBDIwBCyAAQQ02AhwgACAQNgIMIAAgAUEBajYCFEEAIRAM/gELIBBBFUYNyQEgAEEANgIcIAAgATYCFCAAQcaMgIAANgIQIABBIzYCDEEAIRAM/QELIAAoAgQhECAAQQA2AgQCQCAAIBAgARC5gICAACIQDQAgAUEBaiEBDIsBCyAAQQ42AhwgACAQNgIMIAAgAUEBajYCFEEAIRAM/AELIABBADYCHCAAIAE2AhQgAEHAlYCAADYCECAAQQI2AgxBACEQDPsBCyAQQRVGDcUBIABBADYCHCAAIAE2AhQgAEHGjICAADYCECAAQSM2AgxBACEQDPoBCyAAQRA2AhwgACABNgIUIAAgEDYCDEEAIRAM+QELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARC5gICAACIEDQAgAUEBaiEBDPEBCyAAQRE2AhwgACAENgIMIAAgAUEBajYCFEEAIRAM+AELIBBBFUYNwQEgAEEANgIcIAAgATYCFCAAQcaMgIAANgIQIABBIzYCDEEAIRAM9wELIAAoAgQhECAAQQA2AgQCQCAAIBAgARC5gICAACIQDQAgAUEBaiEBDIgBCyAAQRM2AhwgACAQNgIMIAAgAUEBajYCFEEAIRAM9gELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARC5gICAACIEDQAgAUEBaiEBDO0BCyAAQRQ2AhwgACAENgIMIAAgAUEBajYCFEEAIRAM9QELIBBBFUYNvQEgAEEANgIcIAAgATYCFCAAQZqPgIAANgIQIABBIjYCDEEAIRAM9AELIAAoAgQhECAAQQA2AgQCQCAAIBAgARC3gICAACIQDQAgAUEBaiEBDIYBCyAAQRY2AhwgACAQNgIMIAAgAUEBajYCFEEAIRAM8wELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARC3gICAACIEDQAgAUEBaiEBDOkBCyAAQRc2AhwgACAENgIMIAAgAUEBajYCFEEAIRAM8gELIABBADYCHCAAIAE2AhQgAEHNk4CAADYCECAAQQw2AgxBACEQDPEBC0IBIRELIBBBAWohAQJAIAApAyAiEkL//////////w9WDQAgACASQgSGIBGENwMgIAEhAQyEAQsgAEEANgIcIAAgATYCFCAAQa2JgIAANgIQIABBDDYCDEEAIRAM7wELIABBADYCHCAAIBA2AhQgAEHNk4CAADYCECAAQQw2AgxBACEQDO4BCyAAKAIEIRcgAEEANgIEIBAgEadqIhYhASAAIBcgECAWIBQbIhAQtYCAgAAiFEUNcyAAQQU2AhwgACAQNgIUIAAgFDYCDEEAIRAM7QELIABBADYCHCAAIBA2AhQgAEGqnICAADYCECAAQQ82AgxBACEQDOwBCyAAIBAgAhC0gICAACIBDQEgECEBC0EOIRAM0QELAkAgAUEVRw0AIABBAjYCHCAAIBA2AhQgAEGwmICAADYCECAAQRU2AgxBACEQDOoBCyAAQQA2AhwgACAQNgIUIABBp46AgAA2AhAgAEESNgIMQQAhEAzpAQsgAUEBaiEQAkAgAC8BMCIBQYABcUUNAAJAIAAgECACELuAgIAAIgENACAQIQEMcAsgAUEVRw26ASAAQQU2AhwgACAQNgIUIABB+ZeAgAA2AhAgAEEVNgIMQQAhEAzpAQsCQCABQaAEcUGgBEcNACAALQAtQQJxDQAgAEEANgIcIAAgEDYCFCAAQZaTgIAANgIQIABBBDYCDEEAIRAM6QELIAAgECACEL2AgIAAGiAQIQECQAJAAkACQAJAIAAgECACELOAgIAADhYCAQAEBAQEBAQEBAQEBAQEBAQEBAQDBAsgAEEBOgAuCyAAIAAvATBBwAByOwEwIBAhAQtBJiEQDNEBCyAAQSM2AhwgACAQNgIUIABBpZaAgAA2AhAgAEEVNgIMQQAhEAzpAQsgAEEANgIcIAAgEDYCFCAAQdWLgIAANgIQIABBETYCDEEAIRAM6AELIAAtAC1BAXFFDQFBwwEhEAzOAQsCQCANIAJGDQADQAJAIA0tAABBIEYNACANIQEMxAELIA1BAWoiDSACRw0AC0ElIRAM5wELQSUhEAzmAQsgACgCBCEEIABBADYCBCAAIAQgDRCvgICAACIERQ2tASAAQSY2AhwgACAENgIMIAAgDUEBajYCFEEAIRAM5QELIBBBFUYNqwEgAEEANgIcIAAgATYCFCAAQf2NgIAANgIQIABBHTYCDEEAIRAM5AELIABBJzYCHCAAIAE2AhQgACAQNgIMQQAhEAzjAQsgECEBQQEhFAJAAkACQAJAAkACQAJAIAAtACxBfmoOBwYFBQMBAgAFCyAAIAAvATBBCHI7ATAMAwtBAiEUDAELQQQhFAsgAEEBOgAsIAAgAC8BMCAUcjsBMAsgECEBC0ErIRAMygELIABBADYCHCAAIBA2AhQgAEGrkoCAADYCECAAQQs2AgxBACEQDOIBCyAAQQA2AhwgACABNgIUIABB4Y+AgAA2AhAgAEEKNgIMQQAhEAzhAQsgAEEAOgAsIBAhAQy9AQsgECEBQQEhFAJAAkACQAJAAkAgAC0ALEF7ag4EAwECAAULIAAgAC8BMEEIcjsBMAwDC0ECIRQMAQtBBCEUCyAAQQE6ACwgACAALwEwIBRyOwEwCyAQIQELQSkhEAzFAQsgAEEANgIcIAAgATYCFCAAQfCUgIAANgIQIABBAzYCDEEAIRAM3QELAkAgDi0AAEENRw0AIAAoAgQhASAAQQA2AgQCQCAAIAEgDhCxgICAACIBDQAgDkEBaiEBDHULIABBLDYCHCAAIAE2AgwgACAOQQFqNgIUQQAhEAzdAQsgAC0ALUEBcUUNAUHEASEQDMMBCwJAIA4gAkcNAEEtIRAM3AELAkACQANAAkAgDi0AAEF2ag4EAgAAAwALIA5BAWoiDiACRw0AC0EtIRAM3QELIAAoAgQhASAAQQA2AgQCQCAAIAEgDhCxgICAACIBDQAgDiEBDHQLIABBLDYCHCAAIA42AhQgACABNgIMQQAhEAzcAQsgACgCBCEBIABBADYCBAJAIAAgASAOELGAgIAAIgENACAOQQFqIQEMcwsgAEEsNgIcIAAgATYCDCAAIA5BAWo2AhRBACEQDNsBCyAAKAIEIQQgAEEANgIEIAAgBCAOELGAgIAAIgQNoAEgDiEBDM4BCyAQQSxHDQEgAUEBaiEQQQEhAQJAAkACQAJAAkAgAC0ALEF7ag4EAwECBAALIBAhAQwEC0ECIQEMAQtBBCEBCyAAQQE6ACwgACAALwEwIAFyOwEwIBAhAQwBCyAAIAAvATBBCHI7ATAgECEBC0E5IRAMvwELIABBADoALCABIQELQTQhEAy9AQsgACAALwEwQSByOwEwIAEhAQwCCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQsYCAgAAiBA0AIAEhAQzHAQsgAEE3NgIcIAAgATYCFCAAIAQ2AgxBACEQDNQBCyAAQQg6ACwgASEBC0EwIRAMuQELAkAgAC0AKEEBRg0AIAEhAQwECyAALQAtQQhxRQ2TASABIQEMAwsgAC0AMEEgcQ2UAUHFASEQDLcBCwJAIA8gAkYNAAJAA0ACQCAPLQAAQVBqIgFB/wFxQQpJDQAgDyEBQTUhEAy6AQsgACkDICIRQpmz5syZs+bMGVYNASAAIBFCCn4iETcDICARIAGtQv8BgyISQn+FVg0BIAAgESASfDcDICAPQQFqIg8gAkcNAAtBOSEQDNEBCyAAKAIEIQIgAEEANgIEIAAgAiAPQQFqIgQQsYCAgAAiAg2VASAEIQEMwwELQTkhEAzPAQsCQCAALwEwIgFBCHFFDQAgAC0AKEEBRw0AIAAtAC1BCHFFDZABCyAAIAFB9/sDcUGABHI7ATAgDyEBC0E3IRAMtAELIAAgAC8BMEEQcjsBMAyrAQsgEEEVRg2LASAAQQA2AhwgACABNgIUIABB8I6AgAA2AhAgAEEcNgIMQQAhEAzLAQsgAEHDADYCHCAAIAE2AgwgACANQQFqNgIUQQAhEAzKAQsCQCABLQAAQTpHDQAgACgCBCEQIABBADYCBAJAIAAgECABEK+AgIAAIhANACABQQFqIQEMYwsgAEHDADYCHCAAIBA2AgwgACABQQFqNgIUQQAhEAzKAQsgAEEANgIcIAAgATYCFCAAQbGRgIAANgIQIABBCjYCDEEAIRAMyQELIABBADYCHCAAIAE2AhQgAEGgmYCAADYCECAAQR42AgxBACEQDMgBCyAAQQA2AgALIABBgBI7ASogACAXQQFqIgEgAhCogICAACIQDQEgASEBC0HHACEQDKwBCyAQQRVHDYMBIABB0QA2AhwgACABNgIUIABB45eAgAA2AhAgAEEVNgIMQQAhEAzEAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMXgsgAEHSADYCHCAAIAE2AhQgACAQNgIMQQAhEAzDAQsgAEEANgIcIAAgFDYCFCAAQcGogIAANgIQIABBBzYCDCAAQQA2AgBBACEQDMIBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxdCyAAQdMANgIcIAAgATYCFCAAIBA2AgxBACEQDMEBC0EAIRAgAEEANgIcIAAgATYCFCAAQYCRgIAANgIQIABBCTYCDAzAAQsgEEEVRg19IABBADYCHCAAIAE2AhQgAEGUjYCAADYCECAAQSE2AgxBACEQDL8BC0EBIRZBACEXQQAhFEEBIRALIAAgEDoAKyABQQFqIQECQAJAIAAtAC1BEHENAAJAAkACQCAALQAqDgMBAAIECyAWRQ0DDAILIBQNAQwCCyAXRQ0BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQrYCAgAAiEA0AIAEhAQxcCyAAQdgANgIcIAAgATYCFCAAIBA2AgxBACEQDL4BCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQrYCAgAAiBA0AIAEhAQytAQsgAEHZADYCHCAAIAE2AhQgACAENgIMQQAhEAy9AQsgACgCBCEEIABBADYCBAJAIAAgBCABEK2AgIAAIgQNACABIQEMqwELIABB2gA2AhwgACABNgIUIAAgBDYCDEEAIRAMvAELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARCtgICAACIEDQAgASEBDKkBCyAAQdwANgIcIAAgATYCFCAAIAQ2AgxBACEQDLsBCwJAIAEtAABBUGoiEEH/AXFBCk8NACAAIBA6ACogAUEBaiEBQc8AIRAMogELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARCtgICAACIEDQAgASEBDKcBCyAAQd4ANgIcIAAgATYCFCAAIAQ2AgxBACEQDLoBCyAAQQA2AgAgF0EBaiEBAkAgAC0AKUEjTw0AIAEhAQxZCyAAQQA2AhwgACABNgIUIABB04mAgAA2AhAgAEEINgIMQQAhEAy5AQsgAEEANgIAC0EAIRAgAEEANgIcIAAgATYCFCAAQZCzgIAANgIQIABBCDYCDAy3AQsgAEEANgIAIBdBAWohAQJAIAAtAClBIUcNACABIQEMVgsgAEEANgIcIAAgATYCFCAAQZuKgIAANgIQIABBCDYCDEEAIRAMtgELIABBADYCACAXQQFqIQECQCAALQApIhBBXWpBC08NACABIQEMVQsCQCAQQQZLDQBBASAQdEHKAHFFDQAgASEBDFULQQAhECAAQQA2AhwgACABNgIUIABB94mAgAA2AhAgAEEINgIMDLUBCyAQQRVGDXEgAEEANgIcIAAgATYCFCAAQbmNgIAANgIQIABBGjYCDEEAIRAMtAELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDFQLIABB5QA2AhwgACABNgIUIAAgEDYCDEEAIRAMswELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDE0LIABB0gA2AhwgACABNgIUIAAgEDYCDEEAIRAMsgELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDE0LIABB0wA2AhwgACABNgIUIAAgEDYCDEEAIRAMsQELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDFELIABB5QA2AhwgACABNgIUIAAgEDYCDEEAIRAMsAELIABBADYCHCAAIAE2AhQgAEHGioCAADYCECAAQQc2AgxBACEQDK8BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxJCyAAQdIANgIcIAAgATYCFCAAIBA2AgxBACEQDK4BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxJCyAAQdMANgIcIAAgATYCFCAAIBA2AgxBACEQDK0BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxNCyAAQeUANgIcIAAgATYCFCAAIBA2AgxBACEQDKwBCyAAQQA2AhwgACABNgIUIABB3IiAgAA2AhAgAEEHNgIMQQAhEAyrAQsgEEE/Rw0BIAFBAWohAQtBBSEQDJABC0EAIRAgAEEANgIcIAAgATYCFCAAQf2SgIAANgIQIABBBzYCDAyoAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMQgsgAEHSADYCHCAAIAE2AhQgACAQNgIMQQAhEAynAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMQgsgAEHTADYCHCAAIAE2AhQgACAQNgIMQQAhEAymAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMRgsgAEHlADYCHCAAIAE2AhQgACAQNgIMQQAhEAylAQsgACgCBCEBIABBADYCBAJAIAAgASAUEKeAgIAAIgENACAUIQEMPwsgAEHSADYCHCAAIBQ2AhQgACABNgIMQQAhEAykAQsgACgCBCEBIABBADYCBAJAIAAgASAUEKeAgIAAIgENACAUIQEMPwsgAEHTADYCHCAAIBQ2AhQgACABNgIMQQAhEAyjAQsgACgCBCEBIABBADYCBAJAIAAgASAUEKeAgIAAIgENACAUIQEMQwsgAEHlADYCHCAAIBQ2AhQgACABNgIMQQAhEAyiAQsgAEEANgIcIAAgFDYCFCAAQcOPgIAANgIQIABBBzYCDEEAIRAMoQELIABBADYCHCAAIAE2AhQgAEHDj4CAADYCECAAQQc2AgxBACEQDKABC0EAIRAgAEEANgIcIAAgFDYCFCAAQYycgIAANgIQIABBBzYCDAyfAQsgAEEANgIcIAAgFDYCFCAAQYycgIAANgIQIABBBzYCDEEAIRAMngELIABBADYCHCAAIBQ2AhQgAEH+kYCAADYCECAAQQc2AgxBACEQDJ0BCyAAQQA2AhwgACABNgIUIABBjpuAgAA2AhAgAEEGNgIMQQAhEAycAQsgEEEVRg1XIABBADYCHCAAIAE2AhQgAEHMjoCAADYCECAAQSA2AgxBACEQDJsBCyAAQQA2AgAgEEEBaiEBQSQhEAsgACAQOgApIAAoAgQhECAAQQA2AgQgACAQIAEQq4CAgAAiEA1UIAEhAQw+CyAAQQA2AgALQQAhECAAQQA2AhwgACAENgIUIABB8ZuAgAA2AhAgAEEGNgIMDJcBCyABQRVGDVAgAEEANgIcIAAgBTYCFCAAQfCMgIAANgIQIABBGzYCDEEAIRAMlgELIAAoAgQhBSAAQQA2AgQgACAFIBAQqYCAgAAiBQ0BIBBBAWohBQtBrQEhEAx7CyAAQcEBNgIcIAAgBTYCDCAAIBBBAWo2AhRBACEQDJMBCyAAKAIEIQYgAEEANgIEIAAgBiAQEKmAgIAAIgYNASAQQQFqIQYLQa4BIRAMeAsgAEHCATYCHCAAIAY2AgwgACAQQQFqNgIUQQAhEAyQAQsgAEEANgIcIAAgBzYCFCAAQZeLgIAANgIQIABBDTYCDEEAIRAMjwELIABBADYCHCAAIAg2AhQgAEHjkICAADYCECAAQQk2AgxBACEQDI4BCyAAQQA2AhwgACAINgIUIABBlI2AgAA2AhAgAEEhNgIMQQAhEAyNAQtBASEWQQAhF0EAIRRBASEQCyAAIBA6ACsgCUEBaiEIAkACQCAALQAtQRBxDQACQAJAAkAgAC0AKg4DAQACBAsgFkUNAwwCCyAUDQEMAgsgF0UNAQsgACgCBCEQIABBADYCBCAAIBAgCBCtgICAACIQRQ09IABByQE2AhwgACAINgIUIAAgEDYCDEEAIRAMjAELIAAoAgQhBCAAQQA2AgQgACAEIAgQrYCAgAAiBEUNdiAAQcoBNgIcIAAgCDYCFCAAIAQ2AgxBACEQDIsBCyAAKAIEIQQgAEEANgIEIAAgBCAJEK2AgIAAIgRFDXQgAEHLATYCHCAAIAk2AhQgACAENgIMQQAhEAyKAQsgACgCBCEEIABBADYCBCAAIAQgChCtgICAACIERQ1yIABBzQE2AhwgACAKNgIUIAAgBDYCDEEAIRAMiQELAkAgCy0AAEFQaiIQQf8BcUEKTw0AIAAgEDoAKiALQQFqIQpBtgEhEAxwCyAAKAIEIQQgAEEANgIEIAAgBCALEK2AgIAAIgRFDXAgAEHPATYCHCAAIAs2AhQgACAENgIMQQAhEAyIAQsgAEEANgIcIAAgBDYCFCAAQZCzgIAANgIQIABBCDYCDCAAQQA2AgBBACEQDIcBCyABQRVGDT8gAEEANgIcIAAgDDYCFCAAQcyOgIAANgIQIABBIDYCDEEAIRAMhgELIABBgQQ7ASggACgCBCEQIABCADcDACAAIBAgDEEBaiIMEKuAgIAAIhBFDTggAEHTATYCHCAAIAw2AhQgACAQNgIMQQAhEAyFAQsgAEEANgIAC0EAIRAgAEEANgIcIAAgBDYCFCAAQdibgIAANgIQIABBCDYCDAyDAQsgACgCBCEQIABCADcDACAAIBAgC0EBaiILEKuAgIAAIhANAUHGASEQDGkLIABBAjoAKAxVCyAAQdUBNgIcIAAgCzYCFCAAIBA2AgxBACEQDIABCyAQQRVGDTcgAEEANgIcIAAgBDYCFCAAQaSMgIAANgIQIABBEDYCDEEAIRAMfwsgAC0ANEEBRw00IAAgBCACELyAgIAAIhBFDTQgEEEVRw01IABB3AE2AhwgACAENgIUIABB1ZaAgAA2AhAgAEEVNgIMQQAhEAx+C0EAIRAgAEEANgIcIABBr4uAgAA2AhAgAEECNgIMIAAgFEEBajYCFAx9C0EAIRAMYwtBAiEQDGILQQ0hEAxhC0EPIRAMYAtBJSEQDF8LQRMhEAxeC0EVIRAMXQtBFiEQDFwLQRchEAxbC0EYIRAMWgtBGSEQDFkLQRohEAxYC0EbIRAMVwtBHCEQDFYLQR0hEAxVC0EfIRAMVAtBISEQDFMLQSMhEAxSC0HGACEQDFELQS4hEAxQC0EvIRAMTwtBOyEQDE4LQT0hEAxNC0HIACEQDEwLQckAIRAMSwtBywAhEAxKC0HMACEQDEkLQc4AIRAMSAtB0QAhEAxHC0HVACEQDEYLQdgAIRAMRQtB2QAhEAxEC0HbACEQDEMLQeQAIRAMQgtB5QAhEAxBC0HxACEQDEALQfQAIRAMPwtBjQEhEAw+C0GXASEQDD0LQakBIRAMPAtBrAEhEAw7C0HAASEQDDoLQbkBIRAMOQtBrwEhEAw4C0GxASEQDDcLQbIBIRAMNgtBtAEhEAw1C0G1ASEQDDQLQboBIRAMMwtBvQEhEAwyC0G/ASEQDDELQcEBIRAMMAsgAEEANgIcIAAgBDYCFCAAQemLgIAANgIQIABBHzYCDEEAIRAMSAsgAEHbATYCHCAAIAQ2AhQgAEH6loCAADYCECAAQRU2AgxBACEQDEcLIABB+AA2AhwgACAMNgIUIABBypiAgAA2AhAgAEEVNgIMQQAhEAxGCyAAQdEANgIcIAAgBTYCFCAAQbCXgIAANgIQIABBFTYCDEEAIRAMRQsgAEH5ADYCHCAAIAE2AhQgACAQNgIMQQAhEAxECyAAQfgANgIcIAAgATYCFCAAQcqYgIAANgIQIABBFTYCDEEAIRAMQwsgAEHkADYCHCAAIAE2AhQgAEHjl4CAADYCECAAQRU2AgxBACEQDEILIABB1wA2AhwgACABNgIUIABByZeAgAA2AhAgAEEVNgIMQQAhEAxBCyAAQQA2AhwgACABNgIUIABBuY2AgAA2AhAgAEEaNgIMQQAhEAxACyAAQcIANgIcIAAgATYCFCAAQeOYgIAANgIQIABBFTYCDEEAIRAMPwsgAEEANgIEIAAgDyAPELGAgIAAIgRFDQEgAEE6NgIcIAAgBDYCDCAAIA9BAWo2AhRBACEQDD4LIAAoAgQhBCAAQQA2AgQCQCAAIAQgARCxgICAACIERQ0AIABBOzYCHCAAIAQ2AgwgACABQQFqNgIUQQAhEAw+CyABQQFqIQEMLQsgD0EBaiEBDC0LIABBADYCHCAAIA82AhQgAEHkkoCAADYCECAAQQQ2AgxBACEQDDsLIABBNjYCHCAAIAQ2AhQgACACNgIMQQAhEAw6CyAAQS42AhwgACAONgIUIAAgBDYCDEEAIRAMOQsgAEHQADYCHCAAIAE2AhQgAEGRmICAADYCECAAQRU2AgxBACEQDDgLIA1BAWohAQwsCyAAQRU2AhwgACABNgIUIABBgpmAgAA2AhAgAEEVNgIMQQAhEAw2CyAAQRs2AhwgACABNgIUIABBkZeAgAA2AhAgAEEVNgIMQQAhEAw1CyAAQQ82AhwgACABNgIUIABBkZeAgAA2AhAgAEEVNgIMQQAhEAw0CyAAQQs2AhwgACABNgIUIABBkZeAgAA2AhAgAEEVNgIMQQAhEAwzCyAAQRo2AhwgACABNgIUIABBgpmAgAA2AhAgAEEVNgIMQQAhEAwyCyAAQQs2AhwgACABNgIUIABBgpmAgAA2AhAgAEEVNgIMQQAhEAwxCyAAQQo2AhwgACABNgIUIABB5JaAgAA2AhAgAEEVNgIMQQAhEAwwCyAAQR42AhwgACABNgIUIABB+ZeAgAA2AhAgAEEVNgIMQQAhEAwvCyAAQQA2AhwgACAQNgIUIABB2o2AgAA2AhAgAEEUNgIMQQAhEAwuCyAAQQQ2AhwgACABNgIUIABBsJiAgAA2AhAgAEEVNgIMQQAhEAwtCyAAQQA2AgAgC0EBaiELC0G4ASEQDBILIABBADYCACAQQQFqIQFB9QAhEAwRCyABIQECQCAALQApQQVHDQBB4wAhEAwRC0HiACEQDBALQQAhECAAQQA2AhwgAEHkkYCAADYCECAAQQc2AgwgACAUQQFqNgIUDCgLIABBADYCACAXQQFqIQFBwAAhEAwOC0EBIQELIAAgAToALCAAQQA2AgAgF0EBaiEBC0EoIRAMCwsgASEBC0E4IRAMCQsCQCABIg8gAkYNAANAAkAgDy0AAEGAvoCAAGotAAAiAUEBRg0AIAFBAkcNAyAPQQFqIQEMBAsgD0EBaiIPIAJHDQALQT4hEAwiC0E+IRAMIQsgAEEAOgAsIA8hAQwBC0ELIRAMBgtBOiEQDAULIAFBAWohAUEtIRAMBAsgACABOgAsIABBADYCACAWQQFqIQFBDCEQDAMLIABBADYCACAXQQFqIQFBCiEQDAILIABBADYCAAsgAEEAOgAsIA0hAUEJIRAMAAsLQQAhECAAQQA2AhwgACALNgIUIABBzZCAgAA2AhAgAEEJNgIMDBcLQQAhECAAQQA2AhwgACAKNgIUIABB6YqAgAA2AhAgAEEJNgIMDBYLQQAhECAAQQA2AhwgACAJNgIUIABBt5CAgAA2AhAgAEEJNgIMDBULQQAhECAAQQA2AhwgACAINgIUIABBnJGAgAA2AhAgAEEJNgIMDBQLQQAhECAAQQA2AhwgACABNgIUIABBzZCAgAA2AhAgAEEJNgIMDBMLQQAhECAAQQA2AhwgACABNgIUIABB6YqAgAA2AhAgAEEJNgIMDBILQQAhECAAQQA2AhwgACABNgIUIABBt5CAgAA2AhAgAEEJNgIMDBELQQAhECAAQQA2AhwgACABNgIUIABBnJGAgAA2AhAgAEEJNgIMDBALQQAhECAAQQA2AhwgACABNgIUIABBl5WAgAA2AhAgAEEPNgIMDA8LQQAhECAAQQA2AhwgACABNgIUIABBl5WAgAA2AhAgAEEPNgIMDA4LQQAhECAAQQA2AhwgACABNgIUIABBwJKAgAA2AhAgAEELNgIMDA0LQQAhECAAQQA2AhwgACABNgIUIABBlYmAgAA2AhAgAEELNgIMDAwLQQAhECAAQQA2AhwgACABNgIUIABB4Y+AgAA2AhAgAEEKNgIMDAsLQQAhECAAQQA2AhwgACABNgIUIABB+4+AgAA2AhAgAEEKNgIMDAoLQQAhECAAQQA2AhwgACABNgIUIABB8ZmAgAA2AhAgAEECNgIMDAkLQQAhECAAQQA2AhwgACABNgIUIABBxJSAgAA2AhAgAEECNgIMDAgLQQAhECAAQQA2AhwgACABNgIUIABB8pWAgAA2AhAgAEECNgIMDAcLIABBAjYCHCAAIAE2AhQgAEGcmoCAADYCECAAQRY2AgxBACEQDAYLQQEhEAwFC0HUACEQIAEiBCACRg0EIANBCGogACAEIAJB2MKAgABBChDFgICAACADKAIMIQQgAygCCA4DAQQCAAsQyoCAgAAACyAAQQA2AhwgAEG1moCAADYCECAAQRc2AgwgACAEQQFqNgIUQQAhEAwCCyAAQQA2AhwgACAENgIUIABBypqAgAA2AhAgAEEJNgIMQQAhEAwBCwJAIAEiBCACRw0AQSIhEAwBCyAAQYmAgIAANgIIIAAgBDYCBEEhIRALIANBEGokgICAgAAgEAuvAQECfyABKAIAIQYCQAJAIAIgA0YNACAEIAZqIQQgBiADaiACayEHIAIgBkF/cyAFaiIGaiEFA0ACQCACLQAAIAQtAABGDQBBAiEEDAMLAkAgBg0AQQAhBCAFIQIMAwsgBkF/aiEGIARBAWohBCACQQFqIgIgA0cNAAsgByEGIAMhAgsgAEEBNgIAIAEgBjYCACAAIAI2AgQPCyABQQA2AgAgACAENgIAIAAgAjYCBAsKACAAEMeAgIAAC/I2AQt/I4CAgIAAQRBrIgEkgICAgAACQEEAKAKg0ICAAA0AQQAQy4CAgABBgNSEgABrIgJB2QBJDQBBACEDAkBBACgC4NOAgAAiBA0AQQBCfzcC7NOAgABBAEKAgISAgIDAADcC5NOAgABBACABQQhqQXBxQdiq1aoFcyIENgLg04CAAEEAQQA2AvTTgIAAQQBBADYCxNOAgAALQQAgAjYCzNOAgABBAEGA1ISAADYCyNOAgABBAEGA1ISAADYCmNCAgABBACAENgKs0ICAAEEAQX82AqjQgIAAA0AgA0HE0ICAAGogA0G40ICAAGoiBDYCACAEIANBsNCAgABqIgU2AgAgA0G80ICAAGogBTYCACADQczQgIAAaiADQcDQgIAAaiIFNgIAIAUgBDYCACADQdTQgIAAaiADQcjQgIAAaiIENgIAIAQgBTYCACADQdDQgIAAaiAENgIAIANBIGoiA0GAAkcNAAtBgNSEgABBeEGA1ISAAGtBD3FBAEGA1ISAAEEIakEPcRsiA2oiBEEEaiACQUhqIgUgA2siA0EBcjYCAEEAQQAoAvDTgIAANgKk0ICAAEEAIAM2ApTQgIAAQQAgBDYCoNCAgABBgNSEgAAgBWpBODYCBAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAEHsAUsNAAJAQQAoAojQgIAAIgZBECAAQRNqQXBxIABBC0kbIgJBA3YiBHYiA0EDcUUNAAJAAkAgA0EBcSAEckEBcyIFQQN0IgRBsNCAgABqIgMgBEG40ICAAGooAgAiBCgCCCICRw0AQQAgBkF+IAV3cTYCiNCAgAAMAQsgAyACNgIIIAIgAzYCDAsgBEEIaiEDIAQgBUEDdCIFQQNyNgIEIAQgBWoiBCAEKAIEQQFyNgIEDAwLIAJBACgCkNCAgAAiB00NAQJAIANFDQACQAJAIAMgBHRBAiAEdCIDQQAgA2tycSIDQQAgA2txQX9qIgMgA0EMdkEQcSIDdiIEQQV2QQhxIgUgA3IgBCAFdiIDQQJ2QQRxIgRyIAMgBHYiA0EBdkECcSIEciADIAR2IgNBAXZBAXEiBHIgAyAEdmoiBEEDdCIDQbDQgIAAaiIFIANBuNCAgABqKAIAIgMoAggiAEcNAEEAIAZBfiAEd3EiBjYCiNCAgAAMAQsgBSAANgIIIAAgBTYCDAsgAyACQQNyNgIEIAMgBEEDdCIEaiAEIAJrIgU2AgAgAyACaiIAIAVBAXI2AgQCQCAHRQ0AIAdBeHFBsNCAgABqIQJBACgCnNCAgAAhBAJAAkAgBkEBIAdBA3Z0IghxDQBBACAGIAhyNgKI0ICAACACIQgMAQsgAigCCCEICyAIIAQ2AgwgAiAENgIIIAQgAjYCDCAEIAg2AggLIANBCGohA0EAIAA2ApzQgIAAQQAgBTYCkNCAgAAMDAtBACgCjNCAgAAiCUUNASAJQQAgCWtxQX9qIgMgA0EMdkEQcSIDdiIEQQV2QQhxIgUgA3IgBCAFdiIDQQJ2QQRxIgRyIAMgBHYiA0EBdkECcSIEciADIAR2IgNBAXZBAXEiBHIgAyAEdmpBAnRBuNKAgABqKAIAIgAoAgRBeHEgAmshBCAAIQUCQANAAkAgBSgCECIDDQAgBUEUaigCACIDRQ0CCyADKAIEQXhxIAJrIgUgBCAFIARJIgUbIQQgAyAAIAUbIQAgAyEFDAALCyAAKAIYIQoCQCAAKAIMIgggAEYNACAAKAIIIgNBACgCmNCAgABJGiAIIAM2AgggAyAINgIMDAsLAkAgAEEUaiIFKAIAIgMNACAAKAIQIgNFDQMgAEEQaiEFCwNAIAUhCyADIghBFGoiBSgCACIDDQAgCEEQaiEFIAgoAhAiAw0ACyALQQA2AgAMCgtBfyECIABBv39LDQAgAEETaiIDQXBxIQJBACgCjNCAgAAiB0UNAEEAIQsCQCACQYACSQ0AQR8hCyACQf///wdLDQAgA0EIdiIDIANBgP4/akEQdkEIcSIDdCIEIARBgOAfakEQdkEEcSIEdCIFIAVBgIAPakEQdkECcSIFdEEPdiADIARyIAVyayIDQQF0IAIgA0EVanZBAXFyQRxqIQsLQQAgAmshBAJAAkACQAJAIAtBAnRBuNKAgABqKAIAIgUNAEEAIQNBACEIDAELQQAhAyACQQBBGSALQQF2ayALQR9GG3QhAEEAIQgDQAJAIAUoAgRBeHEgAmsiBiAETw0AIAYhBCAFIQggBg0AQQAhBCAFIQggBSEDDAMLIAMgBUEUaigCACIGIAYgBSAAQR12QQRxakEQaigCACIFRhsgAyAGGyEDIABBAXQhACAFDQALCwJAIAMgCHINAEEAIQhBAiALdCIDQQAgA2tyIAdxIgNFDQMgA0EAIANrcUF/aiIDIANBDHZBEHEiA3YiBUEFdkEIcSIAIANyIAUgAHYiA0ECdkEEcSIFciADIAV2IgNBAXZBAnEiBXIgAyAFdiIDQQF2QQFxIgVyIAMgBXZqQQJ0QbjSgIAAaigCACEDCyADRQ0BCwNAIAMoAgRBeHEgAmsiBiAESSEAAkAgAygCECIFDQAgA0EUaigCACEFCyAGIAQgABshBCADIAggABshCCAFIQMgBQ0ACwsgCEUNACAEQQAoApDQgIAAIAJrTw0AIAgoAhghCwJAIAgoAgwiACAIRg0AIAgoAggiA0EAKAKY0ICAAEkaIAAgAzYCCCADIAA2AgwMCQsCQCAIQRRqIgUoAgAiAw0AIAgoAhAiA0UNAyAIQRBqIQULA0AgBSEGIAMiAEEUaiIFKAIAIgMNACAAQRBqIQUgACgCECIDDQALIAZBADYCAAwICwJAQQAoApDQgIAAIgMgAkkNAEEAKAKc0ICAACEEAkACQCADIAJrIgVBEEkNACAEIAJqIgAgBUEBcjYCBEEAIAU2ApDQgIAAQQAgADYCnNCAgAAgBCADaiAFNgIAIAQgAkEDcjYCBAwBCyAEIANBA3I2AgQgBCADaiIDIAMoAgRBAXI2AgRBAEEANgKc0ICAAEEAQQA2ApDQgIAACyAEQQhqIQMMCgsCQEEAKAKU0ICAACIAIAJNDQBBACgCoNCAgAAiAyACaiIEIAAgAmsiBUEBcjYCBEEAIAU2ApTQgIAAQQAgBDYCoNCAgAAgAyACQQNyNgIEIANBCGohAwwKCwJAAkBBACgC4NOAgABFDQBBACgC6NOAgAAhBAwBC0EAQn83AuzTgIAAQQBCgICEgICAwAA3AuTTgIAAQQAgAUEMakFwcUHYqtWqBXM2AuDTgIAAQQBBADYC9NOAgABBAEEANgLE04CAAEGAgAQhBAtBACEDAkAgBCACQccAaiIHaiIGQQAgBGsiC3EiCCACSw0AQQBBMDYC+NOAgAAMCgsCQEEAKALA04CAACIDRQ0AAkBBACgCuNOAgAAiBCAIaiIFIARNDQAgBSADTQ0BC0EAIQNBAEEwNgL404CAAAwKC0EALQDE04CAAEEEcQ0EAkACQAJAQQAoAqDQgIAAIgRFDQBByNOAgAAhAwNAAkAgAygCACIFIARLDQAgBSADKAIEaiAESw0DCyADKAIIIgMNAAsLQQAQy4CAgAAiAEF/Rg0FIAghBgJAQQAoAuTTgIAAIgNBf2oiBCAAcUUNACAIIABrIAQgAGpBACADa3FqIQYLIAYgAk0NBSAGQf7///8HSw0FAkBBACgCwNOAgAAiA0UNAEEAKAK404CAACIEIAZqIgUgBE0NBiAFIANLDQYLIAYQy4CAgAAiAyAARw0BDAcLIAYgAGsgC3EiBkH+////B0sNBCAGEMuAgIAAIgAgAygCACADKAIEakYNAyAAIQMLAkAgA0F/Rg0AIAJByABqIAZNDQACQCAHIAZrQQAoAujTgIAAIgRqQQAgBGtxIgRB/v///wdNDQAgAyEADAcLAkAgBBDLgICAAEF/Rg0AIAQgBmohBiADIQAMBwtBACAGaxDLgICAABoMBAsgAyEAIANBf0cNBQwDC0EAIQgMBwtBACEADAULIABBf0cNAgtBAEEAKALE04CAAEEEcjYCxNOAgAALIAhB/v///wdLDQEgCBDLgICAACEAQQAQy4CAgAAhAyAAQX9GDQEgA0F/Rg0BIAAgA08NASADIABrIgYgAkE4ak0NAQtBAEEAKAK404CAACAGaiIDNgK404CAAAJAIANBACgCvNOAgABNDQBBACADNgK804CAAAsCQAJAAkACQEEAKAKg0ICAACIERQ0AQcjTgIAAIQMDQCAAIAMoAgAiBSADKAIEIghqRg0CIAMoAggiAw0ADAMLCwJAAkBBACgCmNCAgAAiA0UNACAAIANPDQELQQAgADYCmNCAgAALQQAhA0EAIAY2AszTgIAAQQAgADYCyNOAgABBAEF/NgKo0ICAAEEAQQAoAuDTgIAANgKs0ICAAEEAQQA2AtTTgIAAA0AgA0HE0ICAAGogA0G40ICAAGoiBDYCACAEIANBsNCAgABqIgU2AgAgA0G80ICAAGogBTYCACADQczQgIAAaiADQcDQgIAAaiIFNgIAIAUgBDYCACADQdTQgIAAaiADQcjQgIAAaiIENgIAIAQgBTYCACADQdDQgIAAaiAENgIAIANBIGoiA0GAAkcNAAsgAEF4IABrQQ9xQQAgAEEIakEPcRsiA2oiBCAGQUhqIgUgA2siA0EBcjYCBEEAQQAoAvDTgIAANgKk0ICAAEEAIAM2ApTQgIAAQQAgBDYCoNCAgAAgACAFakE4NgIEDAILIAMtAAxBCHENACAEIAVJDQAgBCAATw0AIARBeCAEa0EPcUEAIARBCGpBD3EbIgVqIgBBACgClNCAgAAgBmoiCyAFayIFQQFyNgIEIAMgCCAGajYCBEEAQQAoAvDTgIAANgKk0ICAAEEAIAU2ApTQgIAAQQAgADYCoNCAgAAgBCALakE4NgIEDAELAkAgAEEAKAKY0ICAACIITw0AQQAgADYCmNCAgAAgACEICyAAIAZqIQVByNOAgAAhAwJAAkACQAJAAkACQAJAA0AgAygCACAFRg0BIAMoAggiAw0ADAILCyADLQAMQQhxRQ0BC0HI04CAACEDA0ACQCADKAIAIgUgBEsNACAFIAMoAgRqIgUgBEsNAwsgAygCCCEDDAALCyADIAA2AgAgAyADKAIEIAZqNgIEIABBeCAAa0EPcUEAIABBCGpBD3EbaiILIAJBA3I2AgQgBUF4IAVrQQ9xQQAgBUEIakEPcRtqIgYgCyACaiICayEDAkAgBiAERw0AQQAgAjYCoNCAgABBAEEAKAKU0ICAACADaiIDNgKU0ICAACACIANBAXI2AgQMAwsCQCAGQQAoApzQgIAARw0AQQAgAjYCnNCAgABBAEEAKAKQ0ICAACADaiIDNgKQ0ICAACACIANBAXI2AgQgAiADaiADNgIADAMLAkAgBigCBCIEQQNxQQFHDQAgBEF4cSEHAkACQCAEQf8BSw0AIAYoAggiBSAEQQN2IghBA3RBsNCAgABqIgBGGgJAIAYoAgwiBCAFRw0AQQBBACgCiNCAgABBfiAId3E2AojQgIAADAILIAQgAEYaIAQgBTYCCCAFIAQ2AgwMAQsgBigCGCEJAkACQCAGKAIMIgAgBkYNACAGKAIIIgQgCEkaIAAgBDYCCCAEIAA2AgwMAQsCQCAGQRRqIgQoAgAiBQ0AIAZBEGoiBCgCACIFDQBBACEADAELA0AgBCEIIAUiAEEUaiIEKAIAIgUNACAAQRBqIQQgACgCECIFDQALIAhBADYCAAsgCUUNAAJAAkAgBiAGKAIcIgVBAnRBuNKAgABqIgQoAgBHDQAgBCAANgIAIAANAUEAQQAoAozQgIAAQX4gBXdxNgKM0ICAAAwCCyAJQRBBFCAJKAIQIAZGG2ogADYCACAARQ0BCyAAIAk2AhgCQCAGKAIQIgRFDQAgACAENgIQIAQgADYCGAsgBigCFCIERQ0AIABBFGogBDYCACAEIAA2AhgLIAcgA2ohAyAGIAdqIgYoAgQhBAsgBiAEQX5xNgIEIAIgA2ogAzYCACACIANBAXI2AgQCQCADQf8BSw0AIANBeHFBsNCAgABqIQQCQAJAQQAoAojQgIAAIgVBASADQQN2dCIDcQ0AQQAgBSADcjYCiNCAgAAgBCEDDAELIAQoAgghAwsgAyACNgIMIAQgAjYCCCACIAQ2AgwgAiADNgIIDAMLQR8hBAJAIANB////B0sNACADQQh2IgQgBEGA/j9qQRB2QQhxIgR0IgUgBUGA4B9qQRB2QQRxIgV0IgAgAEGAgA9qQRB2QQJxIgB0QQ92IAQgBXIgAHJrIgRBAXQgAyAEQRVqdkEBcXJBHGohBAsgAiAENgIcIAJCADcCECAEQQJ0QbjSgIAAaiEFAkBBACgCjNCAgAAiAEEBIAR0IghxDQAgBSACNgIAQQAgACAIcjYCjNCAgAAgAiAFNgIYIAIgAjYCCCACIAI2AgwMAwsgA0EAQRkgBEEBdmsgBEEfRht0IQQgBSgCACEAA0AgACIFKAIEQXhxIANGDQIgBEEddiEAIARBAXQhBCAFIABBBHFqQRBqIggoAgAiAA0ACyAIIAI2AgAgAiAFNgIYIAIgAjYCDCACIAI2AggMAgsgAEF4IABrQQ9xQQAgAEEIakEPcRsiA2oiCyAGQUhqIgggA2siA0EBcjYCBCAAIAhqQTg2AgQgBCAFQTcgBWtBD3FBACAFQUlqQQ9xG2pBQWoiCCAIIARBEGpJGyIIQSM2AgRBAEEAKALw04CAADYCpNCAgABBACADNgKU0ICAAEEAIAs2AqDQgIAAIAhBEGpBACkC0NOAgAA3AgAgCEEAKQLI04CAADcCCEEAIAhBCGo2AtDTgIAAQQAgBjYCzNOAgABBACAANgLI04CAAEEAQQA2AtTTgIAAIAhBJGohAwNAIANBBzYCACADQQRqIgMgBUkNAAsgCCAERg0DIAggCCgCBEF+cTYCBCAIIAggBGsiADYCACAEIABBAXI2AgQCQCAAQf8BSw0AIABBeHFBsNCAgABqIQMCQAJAQQAoAojQgIAAIgVBASAAQQN2dCIAcQ0AQQAgBSAAcjYCiNCAgAAgAyEFDAELIAMoAgghBQsgBSAENgIMIAMgBDYCCCAEIAM2AgwgBCAFNgIIDAQLQR8hAwJAIABB////B0sNACAAQQh2IgMgA0GA/j9qQRB2QQhxIgN0IgUgBUGA4B9qQRB2QQRxIgV0IgggCEGAgA9qQRB2QQJxIgh0QQ92IAMgBXIgCHJrIgNBAXQgACADQRVqdkEBcXJBHGohAwsgBCADNgIcIARCADcCECADQQJ0QbjSgIAAaiEFAkBBACgCjNCAgAAiCEEBIAN0IgZxDQAgBSAENgIAQQAgCCAGcjYCjNCAgAAgBCAFNgIYIAQgBDYCCCAEIAQ2AgwMBAsgAEEAQRkgA0EBdmsgA0EfRht0IQMgBSgCACEIA0AgCCIFKAIEQXhxIABGDQMgA0EddiEIIANBAXQhAyAFIAhBBHFqQRBqIgYoAgAiCA0ACyAGIAQ2AgAgBCAFNgIYIAQgBDYCDCAEIAQ2AggMAwsgBSgCCCIDIAI2AgwgBSACNgIIIAJBADYCGCACIAU2AgwgAiADNgIICyALQQhqIQMMBQsgBSgCCCIDIAQ2AgwgBSAENgIIIARBADYCGCAEIAU2AgwgBCADNgIIC0EAKAKU0ICAACIDIAJNDQBBACgCoNCAgAAiBCACaiIFIAMgAmsiA0EBcjYCBEEAIAM2ApTQgIAAQQAgBTYCoNCAgAAgBCACQQNyNgIEIARBCGohAwwDC0EAIQNBAEEwNgL404CAAAwCCwJAIAtFDQACQAJAIAggCCgCHCIFQQJ0QbjSgIAAaiIDKAIARw0AIAMgADYCACAADQFBACAHQX4gBXdxIgc2AozQgIAADAILIAtBEEEUIAsoAhAgCEYbaiAANgIAIABFDQELIAAgCzYCGAJAIAgoAhAiA0UNACAAIAM2AhAgAyAANgIYCyAIQRRqKAIAIgNFDQAgAEEUaiADNgIAIAMgADYCGAsCQAJAIARBD0sNACAIIAQgAmoiA0EDcjYCBCAIIANqIgMgAygCBEEBcjYCBAwBCyAIIAJqIgAgBEEBcjYCBCAIIAJBA3I2AgQgACAEaiAENgIAAkAgBEH/AUsNACAEQXhxQbDQgIAAaiEDAkACQEEAKAKI0ICAACIFQQEgBEEDdnQiBHENAEEAIAUgBHI2AojQgIAAIAMhBAwBCyADKAIIIQQLIAQgADYCDCADIAA2AgggACADNgIMIAAgBDYCCAwBC0EfIQMCQCAEQf///wdLDQAgBEEIdiIDIANBgP4/akEQdkEIcSIDdCIFIAVBgOAfakEQdkEEcSIFdCICIAJBgIAPakEQdkECcSICdEEPdiADIAVyIAJyayIDQQF0IAQgA0EVanZBAXFyQRxqIQMLIAAgAzYCHCAAQgA3AhAgA0ECdEG40oCAAGohBQJAIAdBASADdCICcQ0AIAUgADYCAEEAIAcgAnI2AozQgIAAIAAgBTYCGCAAIAA2AgggACAANgIMDAELIARBAEEZIANBAXZrIANBH0YbdCEDIAUoAgAhAgJAA0AgAiIFKAIEQXhxIARGDQEgA0EddiECIANBAXQhAyAFIAJBBHFqQRBqIgYoAgAiAg0ACyAGIAA2AgAgACAFNgIYIAAgADYCDCAAIAA2AggMAQsgBSgCCCIDIAA2AgwgBSAANgIIIABBADYCGCAAIAU2AgwgACADNgIICyAIQQhqIQMMAQsCQCAKRQ0AAkACQCAAIAAoAhwiBUECdEG40oCAAGoiAygCAEcNACADIAg2AgAgCA0BQQAgCUF+IAV3cTYCjNCAgAAMAgsgCkEQQRQgCigCECAARhtqIAg2AgAgCEUNAQsgCCAKNgIYAkAgACgCECIDRQ0AIAggAzYCECADIAg2AhgLIABBFGooAgAiA0UNACAIQRRqIAM2AgAgAyAINgIYCwJAAkAgBEEPSw0AIAAgBCACaiIDQQNyNgIEIAAgA2oiAyADKAIEQQFyNgIEDAELIAAgAmoiBSAEQQFyNgIEIAAgAkEDcjYCBCAFIARqIAQ2AgACQCAHRQ0AIAdBeHFBsNCAgABqIQJBACgCnNCAgAAhAwJAAkBBASAHQQN2dCIIIAZxDQBBACAIIAZyNgKI0ICAACACIQgMAQsgAigCCCEICyAIIAM2AgwgAiADNgIIIAMgAjYCDCADIAg2AggLQQAgBTYCnNCAgABBACAENgKQ0ICAAAsgAEEIaiEDCyABQRBqJICAgIAAIAMLCgAgABDJgICAAAviDQEHfwJAIABFDQAgAEF4aiIBIABBfGooAgAiAkF4cSIAaiEDAkAgAkEBcQ0AIAJBA3FFDQEgASABKAIAIgJrIgFBACgCmNCAgAAiBEkNASACIABqIQACQCABQQAoApzQgIAARg0AAkAgAkH/AUsNACABKAIIIgQgAkEDdiIFQQN0QbDQgIAAaiIGRhoCQCABKAIMIgIgBEcNAEEAQQAoAojQgIAAQX4gBXdxNgKI0ICAAAwDCyACIAZGGiACIAQ2AgggBCACNgIMDAILIAEoAhghBwJAAkAgASgCDCIGIAFGDQAgASgCCCICIARJGiAGIAI2AgggAiAGNgIMDAELAkAgAUEUaiICKAIAIgQNACABQRBqIgIoAgAiBA0AQQAhBgwBCwNAIAIhBSAEIgZBFGoiAigCACIEDQAgBkEQaiECIAYoAhAiBA0ACyAFQQA2AgALIAdFDQECQAJAIAEgASgCHCIEQQJ0QbjSgIAAaiICKAIARw0AIAIgBjYCACAGDQFBAEEAKAKM0ICAAEF+IAR3cTYCjNCAgAAMAwsgB0EQQRQgBygCECABRhtqIAY2AgAgBkUNAgsgBiAHNgIYAkAgASgCECICRQ0AIAYgAjYCECACIAY2AhgLIAEoAhQiAkUNASAGQRRqIAI2AgAgAiAGNgIYDAELIAMoAgQiAkEDcUEDRw0AIAMgAkF+cTYCBEEAIAA2ApDQgIAAIAEgAGogADYCACABIABBAXI2AgQPCyABIANPDQAgAygCBCICQQFxRQ0AAkACQCACQQJxDQACQCADQQAoAqDQgIAARw0AQQAgATYCoNCAgABBAEEAKAKU0ICAACAAaiIANgKU0ICAACABIABBAXI2AgQgAUEAKAKc0ICAAEcNA0EAQQA2ApDQgIAAQQBBADYCnNCAgAAPCwJAIANBACgCnNCAgABHDQBBACABNgKc0ICAAEEAQQAoApDQgIAAIABqIgA2ApDQgIAAIAEgAEEBcjYCBCABIABqIAA2AgAPCyACQXhxIABqIQACQAJAIAJB/wFLDQAgAygCCCIEIAJBA3YiBUEDdEGw0ICAAGoiBkYaAkAgAygCDCICIARHDQBBAEEAKAKI0ICAAEF+IAV3cTYCiNCAgAAMAgsgAiAGRhogAiAENgIIIAQgAjYCDAwBCyADKAIYIQcCQAJAIAMoAgwiBiADRg0AIAMoAggiAkEAKAKY0ICAAEkaIAYgAjYCCCACIAY2AgwMAQsCQCADQRRqIgIoAgAiBA0AIANBEGoiAigCACIEDQBBACEGDAELA0AgAiEFIAQiBkEUaiICKAIAIgQNACAGQRBqIQIgBigCECIEDQALIAVBADYCAAsgB0UNAAJAAkAgAyADKAIcIgRBAnRBuNKAgABqIgIoAgBHDQAgAiAGNgIAIAYNAUEAQQAoAozQgIAAQX4gBHdxNgKM0ICAAAwCCyAHQRBBFCAHKAIQIANGG2ogBjYCACAGRQ0BCyAGIAc2AhgCQCADKAIQIgJFDQAgBiACNgIQIAIgBjYCGAsgAygCFCICRQ0AIAZBFGogAjYCACACIAY2AhgLIAEgAGogADYCACABIABBAXI2AgQgAUEAKAKc0ICAAEcNAUEAIAA2ApDQgIAADwsgAyACQX5xNgIEIAEgAGogADYCACABIABBAXI2AgQLAkAgAEH/AUsNACAAQXhxQbDQgIAAaiECAkACQEEAKAKI0ICAACIEQQEgAEEDdnQiAHENAEEAIAQgAHI2AojQgIAAIAIhAAwBCyACKAIIIQALIAAgATYCDCACIAE2AgggASACNgIMIAEgADYCCA8LQR8hAgJAIABB////B0sNACAAQQh2IgIgAkGA/j9qQRB2QQhxIgJ0IgQgBEGA4B9qQRB2QQRxIgR0IgYgBkGAgA9qQRB2QQJxIgZ0QQ92IAIgBHIgBnJrIgJBAXQgACACQRVqdkEBcXJBHGohAgsgASACNgIcIAFCADcCECACQQJ0QbjSgIAAaiEEAkACQEEAKAKM0ICAACIGQQEgAnQiA3ENACAEIAE2AgBBACAGIANyNgKM0ICAACABIAQ2AhggASABNgIIIAEgATYCDAwBCyAAQQBBGSACQQF2ayACQR9GG3QhAiAEKAIAIQYCQANAIAYiBCgCBEF4cSAARg0BIAJBHXYhBiACQQF0IQIgBCAGQQRxakEQaiIDKAIAIgYNAAsgAyABNgIAIAEgBDYCGCABIAE2AgwgASABNgIIDAELIAQoAggiACABNgIMIAQgATYCCCABQQA2AhggASAENgIMIAEgADYCCAtBAEEAKAKo0ICAAEF/aiIBQX8gARs2AqjQgIAACwsEAAAAC04AAkAgAA0APwBBEHQPCwJAIABB//8DcQ0AIABBf0wNAAJAIABBEHZAACIAQX9HDQBBAEEwNgL404CAAEF/DwsgAEEQdA8LEMqAgIAAAAvyAgIDfwF+AkAgAkUNACAAIAE6AAAgAiAAaiIDQX9qIAE6AAAgAkEDSQ0AIAAgAToAAiAAIAE6AAEgA0F9aiABOgAAIANBfmogAToAACACQQdJDQAgACABOgADIANBfGogAToAACACQQlJDQAgAEEAIABrQQNxIgRqIgMgAUH/AXFBgYKECGwiATYCACADIAIgBGtBfHEiBGoiAkF8aiABNgIAIARBCUkNACADIAE2AgggAyABNgIEIAJBeGogATYCACACQXRqIAE2AgAgBEEZSQ0AIAMgATYCGCADIAE2AhQgAyABNgIQIAMgATYCDCACQXBqIAE2AgAgAkFsaiABNgIAIAJBaGogATYCACACQWRqIAE2AgAgBCADQQRxQRhyIgVrIgJBIEkNACABrUKBgICAEH4hBiADIAVqIQEDQCABIAY3AxggASAGNwMQIAEgBjcDCCABIAY3AwAgAUEgaiEBIAJBYGoiAkEfSw0ACwsgAAsLjkgBAEGACAuGSAEAAAACAAAAAwAAAAAAAAAAAAAABAAAAAUAAAAAAAAAAAAAAAYAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASW52YWxpZCBjaGFyIGluIHVybCBxdWVyeQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2JvZHkAQ29udGVudC1MZW5ndGggb3ZlcmZsb3cAQ2h1bmsgc2l6ZSBvdmVyZmxvdwBSZXNwb25zZSBvdmVyZmxvdwBJbnZhbGlkIG1ldGhvZCBmb3IgSFRUUC94LnggcmVxdWVzdABJbnZhbGlkIG1ldGhvZCBmb3IgUlRTUC94LnggcmVxdWVzdABFeHBlY3RlZCBTT1VSQ0UgbWV0aG9kIGZvciBJQ0UveC54IHJlcXVlc3QASW52YWxpZCBjaGFyIGluIHVybCBmcmFnbWVudCBzdGFydABFeHBlY3RlZCBkb3QAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9zdGF0dXMASW52YWxpZCByZXNwb25zZSBzdGF0dXMASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucwBVc2VyIGNhbGxiYWNrIGVycm9yAGBvbl9yZXNldGAgY2FsbGJhY2sgZXJyb3IAYG9uX2NodW5rX2hlYWRlcmAgY2FsbGJhY2sgZXJyb3IAYG9uX21lc3NhZ2VfYmVnaW5gIGNhbGxiYWNrIGVycm9yAGBvbl9jaHVua19leHRlbnNpb25fdmFsdWVgIGNhbGxiYWNrIGVycm9yAGBvbl9zdGF0dXNfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl92ZXJzaW9uX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fdXJsX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9oZWFkZXJfdmFsdWVfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9tZXNzYWdlX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fbWV0aG9kX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25faGVhZGVyX2ZpZWxkX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfZXh0ZW5zaW9uX25hbWVgIGNhbGxiYWNrIGVycm9yAFVuZXhwZWN0ZWQgY2hhciBpbiB1cmwgc2VydmVyAEludmFsaWQgaGVhZGVyIHZhbHVlIGNoYXIASW52YWxpZCBoZWFkZXIgZmllbGQgY2hhcgBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3ZlcnNpb24ASW52YWxpZCBtaW5vciB2ZXJzaW9uAEludmFsaWQgbWFqb3IgdmVyc2lvbgBFeHBlY3RlZCBzcGFjZSBhZnRlciB2ZXJzaW9uAEV4cGVjdGVkIENSTEYgYWZ0ZXIgdmVyc2lvbgBJbnZhbGlkIEhUVFAgdmVyc2lvbgBJbnZhbGlkIGhlYWRlciB0b2tlbgBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3VybABJbnZhbGlkIGNoYXJhY3RlcnMgaW4gdXJsAFVuZXhwZWN0ZWQgc3RhcnQgY2hhciBpbiB1cmwARG91YmxlIEAgaW4gdXJsAEVtcHR5IENvbnRlbnQtTGVuZ3RoAEludmFsaWQgY2hhcmFjdGVyIGluIENvbnRlbnQtTGVuZ3RoAER1cGxpY2F0ZSBDb250ZW50LUxlbmd0aABJbnZhbGlkIGNoYXIgaW4gdXJsIHBhdGgAQ29udGVudC1MZW5ndGggY2FuJ3QgYmUgcHJlc2VudCB3aXRoIFRyYW5zZmVyLUVuY29kaW5nAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIHNpemUAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9oZWFkZXJfdmFsdWUAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9jaHVua19leHRlbnNpb25fdmFsdWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyB2YWx1ZQBNaXNzaW5nIGV4cGVjdGVkIExGIGFmdGVyIGhlYWRlciB2YWx1ZQBJbnZhbGlkIGBUcmFuc2Zlci1FbmNvZGluZ2AgaGVhZGVyIHZhbHVlAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgcXVvdGUgdmFsdWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyBxdW90ZWQgdmFsdWUAUGF1c2VkIGJ5IG9uX2hlYWRlcnNfY29tcGxldGUASW52YWxpZCBFT0Ygc3RhdGUAb25fcmVzZXQgcGF1c2UAb25fY2h1bmtfaGVhZGVyIHBhdXNlAG9uX21lc3NhZ2VfYmVnaW4gcGF1c2UAb25fY2h1bmtfZXh0ZW5zaW9uX3ZhbHVlIHBhdXNlAG9uX3N0YXR1c19jb21wbGV0ZSBwYXVzZQBvbl92ZXJzaW9uX2NvbXBsZXRlIHBhdXNlAG9uX3VybF9jb21wbGV0ZSBwYXVzZQBvbl9jaHVua19jb21wbGV0ZSBwYXVzZQBvbl9oZWFkZXJfdmFsdWVfY29tcGxldGUgcGF1c2UAb25fbWVzc2FnZV9jb21wbGV0ZSBwYXVzZQBvbl9tZXRob2RfY29tcGxldGUgcGF1c2UAb25faGVhZGVyX2ZpZWxkX2NvbXBsZXRlIHBhdXNlAG9uX2NodW5rX2V4dGVuc2lvbl9uYW1lIHBhdXNlAFVuZXhwZWN0ZWQgc3BhY2UgYWZ0ZXIgc3RhcnQgbGluZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2NodW5rX2V4dGVuc2lvbl9uYW1lAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgbmFtZQBQYXVzZSBvbiBDT05ORUNUL1VwZ3JhZGUAUGF1c2Ugb24gUFJJL1VwZ3JhZGUARXhwZWN0ZWQgSFRUUC8yIENvbm5lY3Rpb24gUHJlZmFjZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX21ldGhvZABFeHBlY3RlZCBzcGFjZSBhZnRlciBtZXRob2QAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9oZWFkZXJfZmllbGQAUGF1c2VkAEludmFsaWQgd29yZCBlbmNvdW50ZXJlZABJbnZhbGlkIG1ldGhvZCBlbmNvdW50ZXJlZABVbmV4cGVjdGVkIGNoYXIgaW4gdXJsIHNjaGVtYQBSZXF1ZXN0IGhhcyBpbnZhbGlkIGBUcmFuc2Zlci1FbmNvZGluZ2AAU1dJVENIX1BST1hZAFVTRV9QUk9YWQBNS0FDVElWSVRZAFVOUFJPQ0VTU0FCTEVfRU5USVRZAENPUFkATU9WRURfUEVSTUFORU5UTFkAVE9PX0VBUkxZAE5PVElGWQBGQUlMRURfREVQRU5ERU5DWQBCQURfR0FURVdBWQBQTEFZAFBVVABDSEVDS09VVABHQVRFV0FZX1RJTUVPVVQAUkVRVUVTVF9USU1FT1VUAE5FVFdPUktfQ09OTkVDVF9USU1FT1VUAENPTk5FQ1RJT05fVElNRU9VVABMT0dJTl9USU1FT1VUAE5FVFdPUktfUkVBRF9USU1FT1VUAFBPU1QATUlTRElSRUNURURfUkVRVUVTVABDTElFTlRfQ0xPU0VEX1JFUVVFU1QAQ0xJRU5UX0NMT1NFRF9MT0FEX0JBTEFOQ0VEX1JFUVVFU1QAQkFEX1JFUVVFU1QASFRUUF9SRVFVRVNUX1NFTlRfVE9fSFRUUFNfUE9SVABSRVBPUlQASU1fQV9URUFQT1QAUkVTRVRfQ09OVEVOVABOT19DT05URU5UAFBBUlRJQUxfQ09OVEVOVABIUEVfSU5WQUxJRF9DT05TVEFOVABIUEVfQ0JfUkVTRVQAR0VUAEhQRV9TVFJJQ1QAQ09ORkxJQ1QAVEVNUE9SQVJZX1JFRElSRUNUAFBFUk1BTkVOVF9SRURJUkVDVABDT05ORUNUAE1VTFRJX1NUQVRVUwBIUEVfSU5WQUxJRF9TVEFUVVMAVE9PX01BTllfUkVRVUVTVFMARUFSTFlfSElOVFMAVU5BVkFJTEFCTEVfRk9SX0xFR0FMX1JFQVNPTlMAT1BUSU9OUwBTV0lUQ0hJTkdfUFJPVE9DT0xTAFZBUklBTlRfQUxTT19ORUdPVElBVEVTAE1VTFRJUExFX0NIT0lDRVMASU5URVJOQUxfU0VSVkVSX0VSUk9SAFdFQl9TRVJWRVJfVU5LTk9XTl9FUlJPUgBSQUlMR1VOX0VSUk9SAElERU5USVRZX1BST1ZJREVSX0FVVEhFTlRJQ0FUSU9OX0VSUk9SAFNTTF9DRVJUSUZJQ0FURV9FUlJPUgBJTlZBTElEX1hfRk9SV0FSREVEX0ZPUgBTRVRfUEFSQU1FVEVSAEdFVF9QQVJBTUVURVIASFBFX1VTRVIAU0VFX09USEVSAEhQRV9DQl9DSFVOS19IRUFERVIATUtDQUxFTkRBUgBTRVRVUABXRUJfU0VSVkVSX0lTX0RPV04AVEVBUkRPV04ASFBFX0NMT1NFRF9DT05ORUNUSU9OAEhFVVJJU1RJQ19FWFBJUkFUSU9OAERJU0NPTk5FQ1RFRF9PUEVSQVRJT04ATk9OX0FVVEhPUklUQVRJVkVfSU5GT1JNQVRJT04ASFBFX0lOVkFMSURfVkVSU0lPTgBIUEVfQ0JfTUVTU0FHRV9CRUdJTgBTSVRFX0lTX0ZST1pFTgBIUEVfSU5WQUxJRF9IRUFERVJfVE9LRU4ASU5WQUxJRF9UT0tFTgBGT1JCSURERU4ARU5IQU5DRV9ZT1VSX0NBTE0ASFBFX0lOVkFMSURfVVJMAEJMT0NLRURfQllfUEFSRU5UQUxfQ09OVFJPTABNS0NPTABBQ0wASFBFX0lOVEVSTkFMAFJFUVVFU1RfSEVBREVSX0ZJRUxEU19UT09fTEFSR0VfVU5PRkZJQ0lBTABIUEVfT0sAVU5MSU5LAFVOTE9DSwBQUkkAUkVUUllfV0lUSABIUEVfSU5WQUxJRF9DT05URU5UX0xFTkdUSABIUEVfVU5FWFBFQ1RFRF9DT05URU5UX0xFTkdUSABGTFVTSABQUk9QUEFUQ0gATS1TRUFSQ0gAVVJJX1RPT19MT05HAFBST0NFU1NJTkcATUlTQ0VMTEFORU9VU19QRVJTSVNURU5UX1dBUk5JTkcATUlTQ0VMTEFORU9VU19XQVJOSU5HAEhQRV9JTlZBTElEX1RSQU5TRkVSX0VOQ09ESU5HAEV4cGVjdGVkIENSTEYASFBFX0lOVkFMSURfQ0hVTktfU0laRQBNT1ZFAENPTlRJTlVFAEhQRV9DQl9TVEFUVVNfQ09NUExFVEUASFBFX0NCX0hFQURFUlNfQ09NUExFVEUASFBFX0NCX1ZFUlNJT05fQ09NUExFVEUASFBFX0NCX1VSTF9DT01QTEVURQBIUEVfQ0JfQ0hVTktfQ09NUExFVEUASFBFX0NCX0hFQURFUl9WQUxVRV9DT01QTEVURQBIUEVfQ0JfQ0hVTktfRVhURU5TSU9OX1ZBTFVFX0NPTVBMRVRFAEhQRV9DQl9DSFVOS19FWFRFTlNJT05fTkFNRV9DT01QTEVURQBIUEVfQ0JfTUVTU0FHRV9DT01QTEVURQBIUEVfQ0JfTUVUSE9EX0NPTVBMRVRFAEhQRV9DQl9IRUFERVJfRklFTERfQ09NUExFVEUAREVMRVRFAEhQRV9JTlZBTElEX0VPRl9TVEFURQBJTlZBTElEX1NTTF9DRVJUSUZJQ0FURQBQQVVTRQBOT19SRVNQT05TRQBVTlNVUFBPUlRFRF9NRURJQV9UWVBFAEdPTkUATk9UX0FDQ0VQVEFCTEUAU0VSVklDRV9VTkFWQUlMQUJMRQBSQU5HRV9OT1RfU0FUSVNGSUFCTEUAT1JJR0lOX0lTX1VOUkVBQ0hBQkxFAFJFU1BPTlNFX0lTX1NUQUxFAFBVUkdFAE1FUkdFAFJFUVVFU1RfSEVBREVSX0ZJRUxEU19UT09fTEFSR0UAUkVRVUVTVF9IRUFERVJfVE9PX0xBUkdFAFBBWUxPQURfVE9PX0xBUkdFAElOU1VGRklDSUVOVF9TVE9SQUdFAEhQRV9QQVVTRURfVVBHUkFERQBIUEVfUEFVU0VEX0gyX1VQR1JBREUAU09VUkNFAEFOTk9VTkNFAFRSQUNFAEhQRV9VTkVYUEVDVEVEX1NQQUNFAERFU0NSSUJFAFVOU1VCU0NSSUJFAFJFQ09SRABIUEVfSU5WQUxJRF9NRVRIT0QATk9UX0ZPVU5EAFBST1BGSU5EAFVOQklORABSRUJJTkQAVU5BVVRIT1JJWkVEAE1FVEhPRF9OT1RfQUxMT1dFRABIVFRQX1ZFUlNJT05fTk9UX1NVUFBPUlRFRABBTFJFQURZX1JFUE9SVEVEAEFDQ0VQVEVEAE5PVF9JTVBMRU1FTlRFRABMT09QX0RFVEVDVEVEAEhQRV9DUl9FWFBFQ1RFRABIUEVfTEZfRVhQRUNURUQAQ1JFQVRFRABJTV9VU0VEAEhQRV9QQVVTRUQAVElNRU9VVF9PQ0NVUkVEAFBBWU1FTlRfUkVRVUlSRUQAUFJFQ09ORElUSU9OX1JFUVVJUkVEAFBST1hZX0FVVEhFTlRJQ0FUSU9OX1JFUVVJUkVEAE5FVFdPUktfQVVUSEVOVElDQVRJT05fUkVRVUlSRUQATEVOR1RIX1JFUVVJUkVEAFNTTF9DRVJUSUZJQ0FURV9SRVFVSVJFRABVUEdSQURFX1JFUVVJUkVEAFBBR0VfRVhQSVJFRABQUkVDT05ESVRJT05fRkFJTEVEAEVYUEVDVEFUSU9OX0ZBSUxFRABSRVZBTElEQVRJT05fRkFJTEVEAFNTTF9IQU5EU0hBS0VfRkFJTEVEAExPQ0tFRABUUkFOU0ZPUk1BVElPTl9BUFBMSUVEAE5PVF9NT0RJRklFRABOT1RfRVhURU5ERUQAQkFORFdJRFRIX0xJTUlUX0VYQ0VFREVEAFNJVEVfSVNfT1ZFUkxPQURFRABIRUFEAEV4cGVjdGVkIEhUVFAvAABeEwAAJhMAADAQAADwFwAAnRMAABUSAAA5FwAA8BIAAAoQAAB1EgAArRIAAIITAABPFAAAfxAAAKAVAAAjFAAAiRIAAIsUAABNFQAA1BEAAM8UAAAQGAAAyRYAANwWAADBEQAA4BcAALsUAAB0FAAAfBUAAOUUAAAIFwAAHxAAAGUVAACjFAAAKBUAAAIVAACZFQAALBAAAIsZAABPDwAA1A4AAGoQAADOEAAAAhcAAIkOAABuEwAAHBMAAGYUAABWFwAAwRMAAM0TAABsEwAAaBcAAGYXAABfFwAAIhMAAM4PAABpDgAA2A4AAGMWAADLEwAAqg4AACgXAAAmFwAAxRMAAF0WAADoEQAAZxMAAGUTAADyFgAAcxMAAB0XAAD5FgAA8xEAAM8OAADOFQAADBIAALMRAAClEQAAYRAAADIXAAC7EwAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAgEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgMCAgICAgAAAgIAAgIAAgICAgICAgICAgAEAAAAAAACAgICAgICAgICAgICAgICAgICAgICAgICAgAAAAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAAIAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAgICAgIAAAICAAICAAICAgICAgICAgIAAwAEAAAAAgICAgICAgICAgICAgICAgICAgICAgICAgIAAAACAgICAgICAgICAgICAgICAgICAgICAgICAgICAgACAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsb3NlZWVwLWFsaXZlAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAQEBAQEBAQEBAgEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQFjaHVua2VkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQABAQEBAQAAAQEAAQEAAQEBAQEBAQEBAQAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGVjdGlvbmVudC1sZW5ndGhvbnJveHktY29ubmVjdGlvbgAAAAAAAAAAAAAAAAAAAHJhbnNmZXItZW5jb2RpbmdwZ3JhZGUNCg0KDQpTTQ0KDQpUVFAvQ0UvVFNQLwAAAAAAAAAAAAAAAAECAAEDAAAAAAAAAAAAAAAAAAAAAAAABAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAABAgABAwAAAAAAAAAAAAAAAAAAAAAAAAQBAQUBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAQAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAABAAACAAAAAAAAAAAAAAAAAAAAAAAAAwQAAAQEBAQEBAQEBAQEBQQEBAQEBAQEBAQEBAAEAAYHBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQABAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAQAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAAAAAAAAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAEAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAgAAAAACAAAAAAAAAAAAAAAAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwAAAAAAAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5PVU5DRUVDS09VVE5FQ1RFVEVDUklCRUxVU0hFVEVBRFNFQVJDSFJHRUNUSVZJVFlMRU5EQVJWRU9USUZZUFRJT05TQ0hTRUFZU1RBVENIR0VPUkRJUkVDVE9SVFJDSFBBUkFNRVRFUlVSQ0VCU0NSSUJFQVJET1dOQUNFSU5ETktDS1VCU0NSSUJFSFRUUC9BRFRQLw==", "base64");
}
});
// lib/client.js
var require_client = __commonJS({
"lib/client.js"(exports2, module2) {
"use strict";
var assert = require("node:assert");
var net = require("node:net");
var http = require("node:http");
var { pipeline } = require("node:stream");
var util = require_util();
var { channels } = require_diagnostics();
var timers = require_timers();
var Request = require_request2();
var DispatcherBase = require_dispatcher_base();
var {
RequestContentLengthMismatchError,
ResponseContentLengthMismatchError,
InvalidArgumentError,
RequestAbortedError,
HeadersTimeoutError,
HeadersOverflowError,
SocketError,
InformationalError,
BodyTimeoutError,
HTTPParserError,
ResponseExceededMaxSizeError,
ClientDestroyedError
} = require_errors();
var buildConnector = require_connect();
var {
kUrl,
kReset,
kServerName,
kClient,
kBusy,
kParser,
kConnect,
kBlocking,
kResuming,
kRunning,
kPending,
kSize,
kWriting,
kQueue,
kConnected,
kConnecting,
kNeedDrain,
kNoRef,
kKeepAliveDefaultTimeout,
kHostHeader,
kPendingIdx,
kRunningIdx,
kError,
kPipelining,
kSocket,
kKeepAliveTimeoutValue,
kMaxHeadersSize,
kKeepAliveMaxTimeout,
kKeepAliveTimeoutThreshold,
kHeadersTimeout,
kBodyTimeout,
kStrictContentLength,
kConnector,
kMaxRedirections,
kMaxRequests,
kCounter,
kClose,
kDestroy,
kDispatch,
kInterceptors,
kLocalAddress,
kMaxResponseSize,
kHTTPConnVersion,
// HTTP2
kHost,
kHTTP2Session,
kHTTP2SessionState,
kHTTP2BuildRequest,
kHTTP2CopyHeaders,
kHTTP1BuildRequest
} = require_symbols();
var 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;
var h2ExperimentalWarned = false;
var FastBuffer = Buffer[Symbol.species];
var kClosedResolve = Symbol("kClosedResolve");
var Client = class extends DispatcherBase {
static {
__name(this, "Client");
}
/**
*
* @param {string|URL} url
* @param {import('../types/client').Client.Options} options
*/
constructor(url, {
interceptors,
maxHeaderSize,
headersTimeout,
socketTimeout,
requestTimeout,
connectTimeout,
bodyTimeout,
idleTimeout,
keepAlive,
keepAliveTimeout,
maxKeepAliveTimeout,
keepAliveMaxTimeout,
keepAliveTimeoutThreshold,
socketPath,
pipelining,
tls,
strictContentLength,
maxCachedSessions,
maxRedirections,
connect: connect2,
maxRequestsPerClient,
localAddress,
maxResponseSize,
autoSelectFamily,
autoSelectFamilyAttemptTimeout,
// h2
allowH2,
maxConcurrentStreams
} = {}) {
super();
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 && !Number.isFinite(maxHeaderSize)) {
throw new InvalidArgumentError("invalid maxHeaderSize");
}
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 (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
throw new InvalidArgumentError("maxRedirections must be a positive number");
}
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");
}
if (typeof connect2 !== "function") {
connect2 = buildConnector({
...tls,
maxCachedSessions,
allowH2,
socketPath,
timeout: connectTimeout,
...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
...connect2
});
}
this[kInterceptors] = interceptors?.Client && Array.isArray(interceptors.Client) ? interceptors.Client : [createRedirectInterceptor({ maxRedirections })];
this[kUrl] = util.parseOrigin(url);
this[kConnector] = connect2;
this[kSocket] = null;
this[kPipelining] = pipelining != null ? pipelining : 1;
this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize;
this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout;
this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout;
this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : 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 : 3e5;
this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5;
this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength;
this[kMaxRedirections] = maxRedirections;
this[kMaxRequests] = maxRequestsPerClient;
this[kClosedResolve] = null;
this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1;
this[kHTTPConnVersion] = "h1";
this[kHTTP2Session] = null;
this[kHTTP2SessionState] = !allowH2 ? null : {
// streams: null, // Fixed queue of streams - For future support of `push`
openStreams: 0,
// Keep track of them to decide whether or not unref the session
maxConcurrentStreams: maxConcurrentStreams != null ? maxConcurrentStreams : 100
// Max peerConcurrentStreams for a Node h2 server
};
this[kHost] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}`;
this[kQueue] = [];
this[kRunningIdx] = 0;
this[kPendingIdx] = 0;
}
get pipelining() {
return this[kPipelining];
}
set pipelining(value) {
this[kPipelining] = value;
resume(this, true);
}
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[kSocket] && !this[kConnecting] && !this[kSocket].destroyed;
}
get [kBusy]() {
const socket = this[kSocket];
return socket && (socket[kReset] || socket[kWriting] || socket[kBlocking]) || this[kSize] >= (this[kPipelining] || 1) || this[kPending] > 0;
}
/* istanbul ignore: only used for test */
[kConnect](cb) {
connect(this);
this.once("connect", cb);
}
[kDispatch](opts, handler) {
const origin = opts.origin || this[kUrl].origin;
const request = this[kHTTPConnVersion] === "h2" ? Request[kHTTP2BuildRequest](origin, opts, handler) : Request[kHTTP1BuildRequest](origin, opts, handler);
this[kQueue].push(request);
if (this[kResuming]) {
} else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) {
this[kResuming] = 1;
process.nextTick(resume, this);
} else {
resume(this, true);
}
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) => {
const requests = this[kQueue].splice(this[kPendingIdx]);
for (let i = 0; i < requests.length; i++) {
const request = requests[i];
errorRequest(this, request, err);
}
const callback = /* @__PURE__ */ __name(() => {
if (this[kClosedResolve]) {
this[kClosedResolve]();
this[kClosedResolve] = null;
}
resolve();
}, "callback");
if (this[kHTTP2Session] != null) {
util.destroy(this[kHTTP2Session], err);
this[kHTTP2Session] = null;
this[kHTTP2SessionState] = null;
}
if (this[kSocket]) {
util.destroy(this[kSocket].on("close", callback), err);
} else {
queueMicrotask(callback);
}
resume(this);
});
}
};
function onHttp2SessionError(err) {
assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
this[kSocket][kError] = err;
onError(this[kClient], err);
}
__name(onHttp2SessionError, "onHttp2SessionError");
function onHttp2FrameError(type, code, id) {
const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
if (id === 0) {
this[kSocket][kError] = err;
onError(this[kClient], err);
}
}
__name(onHttp2FrameError, "onHttp2FrameError");
function onHttp2SessionEnd() {
util.destroy(this, new SocketError("other side closed"));
util.destroy(this[kSocket], new SocketError("other side closed"));
}
__name(onHttp2SessionEnd, "onHttp2SessionEnd");
function onHTTP2GoAway(code) {
const client = this[kClient];
const err = new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${code}`);
client[kSocket] = null;
client[kHTTP2Session] = null;
if (client.destroyed) {
assert(this[kPending] === 0);
const requests = client[kQueue].splice(client[kRunningIdx]);
for (let i = 0; i < requests.length; i++) {
const request = requests[i];
errorRequest(this, request, err);
}
} else if (client[kRunning] > 0) {
const request = client[kQueue][client[kRunningIdx]];
client[kQueue][client[kRunningIdx]++] = null;
errorRequest(client, request, err);
}
client[kPendingIdx] = client[kRunningIdx];
assert(client[kRunning] === 0);
client.emit(
"disconnect",
client[kUrl],
[client],
err
);
resume(client);
}
__name(onHTTP2GoAway, "onHTTP2GoAway");
var constants = require_constants3();
var createRedirectInterceptor = require_redirectInterceptor();
var EMPTY_BUF = Buffer.alloc(0);
async function lazyllhttp() {
const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0;
let 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: {
/* eslint-disable camelcase */
wasm_on_url: (p, at, len) => {
return 0;
},
wasm_on_status: (p, at, len) => {
assert.strictEqual(currentParser.ptr, p);
const start = at - currentBufferPtr + currentBufferRef.byteOffset;
return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
},
wasm_on_message_begin: (p) => {
assert.strictEqual(currentParser.ptr, p);
return currentParser.onMessageBegin() || 0;
},
wasm_on_header_field: (p, at, len) => {
assert.strictEqual(currentParser.ptr, p);
const start = at - currentBufferPtr + currentBufferRef.byteOffset;
return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
},
wasm_on_header_value: (p, at, len) => {
assert.strictEqual(currentParser.ptr, p);
const start = at - currentBufferPtr + currentBufferRef.byteOffset;
return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
},
wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
assert.strictEqual(currentParser.ptr, p);
return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0;
},
wasm_on_body: (p, at, len) => {
assert.strictEqual(currentParser.ptr, p);
const start = at - currentBufferPtr + currentBufferRef.byteOffset;
return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
},
wasm_on_message_complete: (p) => {
assert.strictEqual(currentParser.ptr, p);
return currentParser.onMessageComplete() || 0;
}
/* eslint-enable camelcase */
}
});
}
__name(lazyllhttp, "lazyllhttp");
var llhttpInstance = null;
var llhttpPromise = lazyllhttp();
llhttpPromise.catch();
var currentParser = null;
var currentBufferRef = null;
var currentBufferSize = 0;
var currentBufferPtr = null;
var TIMEOUT_HEADERS = 1;
var TIMEOUT_BODY = 2;
var TIMEOUT_IDLE = 3;
var Parser = class {
static {
__name(this, "Parser");
}
constructor(client, socket, { exports: exports3 }) {
assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0);
this.llhttp = exports3;
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 = null;
this.statusText = "";
this.upgrade = false;
this.headers = [];
this.headersSize = 0;
this.headersMaxSize = client[kMaxHeadersSize];
this.shouldKeepAlive = false;
this.paused = false;
this.resume = this.resume.bind(this);
this.bytesRead = 0;
this.keepAlive = "";
this.contentLength = "";
this.connection = "";
this.maxResponseSize = client[kMaxResponseSize];
}
setTimeout(value, type) {
this.timeoutType = type;
if (value !== this.timeoutValue) {
timers.clearTimeout(this.timeout);
if (value) {
this.timeout = timers.setTimeout(onParserTimeout, value, this);
if (this.timeout.unref) {
this.timeout.unref();
}
} else {
this.timeout = null;
}
this.timeoutValue = value;
} else if (this.timeout) {
if (this.timeout.refresh) {
this.timeout.refresh();
}
}
}
resume() {
if (this.socket.destroyed || !this.paused) {
return;
}
assert(this.ptr != null);
assert(currentParser == null);
this.llhttp.llhttp_resume(this.ptr);
assert(this.timeoutType === TIMEOUT_BODY);
if (this.timeout) {
if (this.timeout.refresh) {
this.timeout.refresh();
}
}
this.paused = false;
this.execute(this.socket.read() || EMPTY_BUF);
this.readMore();
}
readMore() {
while (!this.paused && this.ptr) {
const chunk = this.socket.read();
if (chunk === null) {
break;
}
this.execute(chunk);
}
}
execute(data) {
assert(this.ptr != null);
assert(currentParser == null);
assert(!this.paused);
const { socket, llhttp } = this;
if (data.length > currentBufferSize) {
if (currentBufferPtr) {
llhttp.free(currentBufferPtr);
}
currentBufferSize = Math.ceil(data.length / 4096) * 4096;
currentBufferPtr = llhttp.malloc(currentBufferSize);
}
new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data);
try {
let ret;
try {
currentBufferRef = data;
currentParser = this;
ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length);
} catch (err) {
throw err;
} finally {
currentParser = null;
currentBufferRef = null;
}
const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr;
if (ret === constants.ERROR.PAUSED_UPGRADE) {
this.onUpgrade(data.slice(offset));
} else if (ret === constants.ERROR.PAUSED) {
this.paused = true;
socket.unshift(data.slice(offset));
} else if (ret !== constants.ERROR.OK) {
const ptr = llhttp.llhttp_get_error_reason(this.ptr);
let message = "";
if (ptr) {
const 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.slice(offset));
}
} catch (err) {
util.destroy(socket, err);
}
}
destroy() {
assert(this.ptr != null);
assert(currentParser == null);
this.llhttp.llhttp_free(this.ptr);
this.ptr = null;
timers.clearTimeout(this.timeout);
this.timeout = null;
this.timeoutValue = null;
this.timeoutType = null;
this.paused = false;
}
onStatus(buf) {
this.statusText = buf.toString();
}
onMessageBegin() {
const { socket, client } = this;
if (socket.destroyed) {
return -1;
}
const request = client[kQueue][client[kRunningIdx]];
if (!request) {
return -1;
}
request.onResponseStarted();
}
onHeaderField(buf) {
const len = this.headers.length;
if ((len & 1) === 0) {
this.headers.push(buf);
} else {
this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
}
this.trackHeader(buf.length);
}
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]);
}
const key = this.headers[len - 2];
if (key.length === 10) {
const 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();
}
this.trackHeader(buf.length);
}
trackHeader(len) {
this.headersSize += len;
if (this.headersSize >= this.headersMaxSize) {
util.destroy(this.socket, new HeadersOverflowError());
}
}
onUpgrade(head) {
const { upgrade, client, socket, headers, statusCode } = this;
assert(upgrade);
const request = client[kQueue][client[kRunningIdx]];
assert(request);
assert(!socket.destroyed);
assert(socket === client[kSocket]);
assert(!this.paused);
assert(request.upgrade || request.method === "CONNECT");
this.statusCode = null;
this.statusText = "";
this.shouldKeepAlive = null;
assert(this.headers.length % 2 === 0);
this.headers = [];
this.headersSize = 0;
socket.unshift(head);
socket[kParser].destroy();
socket[kParser] = null;
socket[kClient] = null;
socket[kError] = null;
socket.removeListener("error", onSocketError).removeListener("readable", onSocketReadable).removeListener("end", onSocketEnd).removeListener("close", onSocketClose);
client[kSocket] = 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);
}
resume(client);
}
onHeadersComplete(statusCode, upgrade, shouldKeepAlive) {
const { client, socket, headers, statusText } = this;
if (socket.destroyed) {
return -1;
}
const request = client[kQueue][client[kRunningIdx]];
if (!request) {
return -1;
}
assert(!this.upgrade);
assert(this.statusCode < 200);
if (statusCode === 100) {
util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
return -1;
}
if (upgrade && !request.upgrade) {
util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket)));
return -1;
}
assert.strictEqual(this.timeoutType, TIMEOUT_HEADERS);
this.statusCode = statusCode;
this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD.
request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive";
if (this.statusCode >= 200) {
const 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") {
assert(client[kRunning] === 1);
this.upgrade = true;
return 2;
}
if (upgrade) {
assert(client[kRunning] === 1);
this.upgrade = true;
return 2;
}
assert(this.headers.length % 2 === 0);
this.headers = [];
this.headersSize = 0;
if (this.shouldKeepAlive && client[kPipelining]) {
const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null;
if (keepAliveTimeout != null) {
const timeout = Math.min(
keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
client[kKeepAliveMaxTimeout]
);
if (timeout <= 0) {
socket[kReset] = true;
} else {
client[kKeepAliveTimeoutValue] = timeout;
}
} else {
client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout];
}
} else {
socket[kReset] = true;
}
const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false;
if (request.aborted) {
return -1;
}
if (request.method === "HEAD") {
return 1;
}
if (statusCode < 200) {
return 1;
}
if (socket[kBlocking]) {
socket[kBlocking] = false;
resume(client);
}
return pause ? constants.ERROR.PAUSED : 0;
}
onBody(buf) {
const { client, socket, statusCode, maxResponseSize } = this;
if (socket.destroyed) {
return -1;
}
const request = client[kQueue][client[kRunningIdx]];
assert(request);
assert.strictEqual(this.timeoutType, TIMEOUT_BODY);
if (this.timeout) {
if (this.timeout.refresh) {
this.timeout.refresh();
}
}
assert(statusCode >= 200);
if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
util.destroy(socket, new ResponseExceededMaxSizeError());
return -1;
}
this.bytesRead += buf.length;
if (request.onData(buf) === false) {
return constants.ERROR.PAUSED;
}
}
onMessageComplete() {
const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this;
if (socket.destroyed && (!statusCode || shouldKeepAlive)) {
return -1;
}
if (upgrade) {
return;
}
const request = client[kQueue][client[kRunningIdx]];
assert(request);
assert(statusCode >= 100);
this.statusCode = null;
this.statusText = "";
this.bytesRead = 0;
this.contentLength = "";
this.keepAlive = "";
this.connection = "";
assert(this.headers.length % 2 === 0);
this.headers = [];
this.headersSize = 0;
if (statusCode < 200) {
return;
}
if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
util.destroy(socket, new ResponseContentLengthMismatchError());
return -1;
}
request.onComplete(headers);
client[kQueue][client[kRunningIdx]++] = null;
if (socket[kWriting]) {
assert.strictEqual(client[kRunning], 0);
util.destroy(socket, new InformationalError("reset"));
return constants.ERROR.PAUSED;
} else if (!shouldKeepAlive) {
util.destroy(socket, new InformationalError("reset"));
return constants.ERROR.PAUSED;
} else if (socket[kReset] && client[kRunning] === 0) {
util.destroy(socket, new InformationalError("reset"));
return constants.ERROR.PAUSED;
} else if (client[kPipelining] === 1) {
setImmediate(resume, client);
} else {
resume(client);
}
}
};
function onParserTimeout(parser) {
const { socket, timeoutType, client } = parser;
if (timeoutType === TIMEOUT_HEADERS) {
if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
assert(!parser.paused, "cannot be paused while waiting for headers");
util.destroy(socket, new HeadersTimeoutError());
}
} else if (timeoutType === TIMEOUT_BODY) {
if (!parser.paused) {
util.destroy(socket, new BodyTimeoutError());
}
} else if (timeoutType === TIMEOUT_IDLE) {
assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]);
util.destroy(socket, new InformationalError("socket idle timeout"));
}
}
__name(onParserTimeout, "onParserTimeout");
function onSocketReadable() {
const { [kParser]: parser } = this;
if (parser) {
parser.readMore();
}
}
__name(onSocketReadable, "onSocketReadable");
function onSocketError(err) {
const { [kClient]: client, [kParser]: parser } = this;
assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
if (client[kHTTPConnVersion] !== "h2") {
if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) {
parser.onMessageComplete();
return;
}
}
this[kError] = err;
onError(this[kClient], err);
}
__name(onSocketError, "onSocketError");
function onError(client, err) {
if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") {
assert(client[kPendingIdx] === client[kRunningIdx]);
const requests = client[kQueue].splice(client[kRunningIdx]);
for (let i = 0; i < requests.length; i++) {
const request = requests[i];
errorRequest(client, request, err);
}
assert(client[kSize] === 0);
}
}
__name(onError, "onError");
function onSocketEnd() {
const { [kParser]: parser, [kClient]: client } = this;
if (client[kHTTPConnVersion] !== "h2") {
if (parser.statusCode && !parser.shouldKeepAlive) {
parser.onMessageComplete();
return;
}
}
util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
}
__name(onSocketEnd, "onSocketEnd");
function onSocketClose() {
const { [kClient]: client, [kParser]: parser } = this;
if (client[kHTTPConnVersion] === "h1" && parser) {
if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
parser.onMessageComplete();
}
this[kParser].destroy();
this[kParser] = null;
}
const err = this[kError] || new SocketError("closed", util.getSocketInfo(this));
client[kSocket] = null;
if (client.destroyed) {
assert(client[kPending] === 0);
const requests = client[kQueue].splice(client[kRunningIdx]);
for (let i = 0; i < requests.length; i++) {
const request = requests[i];
errorRequest(client, request, err);
}
} else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") {
const request = client[kQueue][client[kRunningIdx]];
client[kQueue][client[kRunningIdx]++] = null;
errorRequest(client, request, err);
}
client[kPendingIdx] = client[kRunningIdx];
assert(client[kRunning] === 0);
client.emit("disconnect", client[kUrl], [client], err);
resume(client);
}
__name(onSocketClose, "onSocketClose");
async function connect(client) {
assert(!client[kConnecting]);
assert(!client[kSocket]);
let { host, hostname, protocol, port } = client[kUrl];
if (hostname[0] === "[") {
const idx = hostname.indexOf("]");
assert(idx !== -1);
const ip = hostname.substring(1, idx);
assert(net.isIP(ip));
hostname = ip;
}
client[kConnecting] = true;
if (channels.beforeConnect.hasSubscribers) {
channels.beforeConnect.publish({
connectParams: {
host,
hostname,
protocol,
port,
version: client[kHTTPConnVersion],
servername: client[kServerName],
localAddress: client[kLocalAddress]
},
connector: client[kConnector]
});
}
try {
const 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", () => {
}), new ClientDestroyedError());
return;
}
client[kConnecting] = false;
assert(socket);
const isH2 = socket.alpnProtocol === "h2";
if (isH2) {
if (!h2ExperimentalWarned) {
h2ExperimentalWarned = true;
process.emitWarning("H2 support is experimental, expect them to change at any time.", {
code: "UNDICI-H2"
});
}
const session = http2.connect(client[kUrl], {
createConnection: () => socket,
peerMaxConcurrentStreams: client[kHTTP2SessionState].maxConcurrentStreams
});
client[kHTTPConnVersion] = "h2";
session[kClient] = client;
session[kSocket] = socket;
session.on("error", onHttp2SessionError);
session.on("frameError", onHttp2FrameError);
session.on("end", onHttp2SessionEnd);
session.on("goaway", onHTTP2GoAway);
session.on("close", onSocketClose);
session.unref();
client[kHTTP2Session] = session;
socket[kHTTP2Session] = session;
} else {
if (!llhttpInstance) {
llhttpInstance = await llhttpPromise;
llhttpPromise = null;
}
socket[kNoRef] = false;
socket[kWriting] = false;
socket[kReset] = false;
socket[kBlocking] = false;
socket[kParser] = new Parser(client, socket, llhttpInstance);
}
socket[kCounter] = 0;
socket[kMaxRequests] = client[kMaxRequests];
socket[kClient] = client;
socket[kError] = null;
socket.on("error", onSocketError).on("readable", onSocketReadable).on("end", onSocketEnd).on("close", onSocketClose);
client[kSocket] = socket;
if (channels.connected.hasSubscribers) {
channels.connected.publish({
connectParams: {
host,
hostname,
protocol,
port,
version: client[kHTTPConnVersion],
servername: client[kServerName],
localAddress: client[kLocalAddress]
},
connector: client[kConnector],
socket
});
}
client.emit("connect", client[kUrl], [client]);
} catch (err) {
if (client.destroyed) {
return;
}
client[kConnecting] = false;
if (channels.connectError.hasSubscribers) {
channels.connectError.publish({
connectParams: {
host,
hostname,
protocol,
port,
version: client[kHTTPConnVersion],
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]) {
const request = client[kQueue][client[kPendingIdx]++];
errorRequest(client, request, err);
}
} else {
onError(client, err);
}
client.emit("connectionError", client[kUrl], [client], err);
}
resume(client);
}
__name(connect, "connect");
function emitDrain(client) {
client[kNeedDrain] = 0;
client.emit("drain", client[kUrl], [client]);
}
__name(emitDrain, "emitDrain");
function resume(client, sync) {
if (client[kResuming] === 2) {
return;
}
client[kResuming] = 2;
_resume(client, sync);
client[kResuming] = 0;
if (client[kRunningIdx] > 256) {
client[kQueue].splice(0, client[kRunningIdx]);
client[kPendingIdx] -= client[kRunningIdx];
client[kRunningIdx] = 0;
}
}
__name(resume, "resume");
function _resume(client, sync) {
while (true) {
if (client.destroyed) {
assert(client[kPending] === 0);
return;
}
if (client[kClosedResolve] && !client[kSize]) {
client[kClosedResolve]();
client[kClosedResolve] = null;
return;
}
const socket = client[kSocket];
if (socket && !socket.destroyed && socket.alpnProtocol !== "h2") {
if (client[kSize] === 0) {
if (!socket[kNoRef] && socket.unref) {
socket.unref();
socket[kNoRef] = true;
}
} else if (socket[kNoRef] && socket.ref) {
socket.ref();
socket[kNoRef] = false;
}
if (client[kSize] === 0) {
if (socket[kParser].timeoutType !== TIMEOUT_IDLE) {
socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE);
}
} else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
const request2 = client[kQueue][client[kRunningIdx]];
const headersTimeout = request2.headersTimeout != null ? request2.headersTimeout : client[kHeadersTimeout];
socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS);
}
}
}
if (client[kBusy]) {
client[kNeedDrain] = 2;
} else if (client[kNeedDrain] === 2) {
if (sync) {
client[kNeedDrain] = 1;
process.nextTick(emitDrain, client);
} else {
emitDrain(client);
}
continue;
}
if (client[kPending] === 0) {
return;
}
if (client[kRunning] >= (client[kPipelining] || 1)) {
return;
}
const request = client[kQueue][client[kPendingIdx]];
if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) {
if (client[kRunning] > 0) {
return;
}
client[kServerName] = request.servername;
if (socket && socket.servername !== request.servername) {
util.destroy(socket, new InformationalError("servername changed"));
return;
}
}
if (client[kConnecting]) {
return;
}
if (!socket && !client[kHTTP2Session]) {
connect(client);
return;
}
if (socket.destroyed || socket[kWriting] || socket[kReset] || socket[kBlocking]) {
return;
}
if (client[kRunning] > 0 && !request.idempotent) {
return;
}
if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT")) {
return;
}
if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 && (util.isStream(request.body) || util.isAsyncIterable(request.body))) {
return;
}
if (!request.aborted && write(client, request)) {
client[kPendingIdx]++;
} else {
client[kQueue].splice(client[kPendingIdx], 1);
}
}
}
__name(_resume, "_resume");
function shouldSendContentLength(method) {
return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
}
__name(shouldSendContentLength, "shouldSendContentLength");
function write(client, request) {
if (client[kHTTPConnVersion] === "h2") {
writeH2(client, client[kHTTP2Session], request);
return;
}
const { body, method, path, host, upgrade, headers, blocking, reset } = request;
const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
if (body && typeof body.read === "function") {
body.read(0);
}
const bodyLength = util.bodyLength(body);
let contentLength = bodyLength;
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]) {
errorRequest(client, request, new RequestContentLengthMismatchError());
return false;
}
process.emitWarning(new RequestContentLengthMismatchError());
}
const socket = client[kSocket];
try {
request.onConnect((err) => {
if (request.aborted || request.completed) {
return;
}
errorRequest(client, request, err || new RequestAbortedError());
util.destroy(socket, new InformationalError("aborted"));
});
} catch (err) {
errorRequest(client, request, err);
}
if (request.aborted) {
return false;
}
if (method === "HEAD") {
socket[kReset] = true;
}
if (upgrade || method === "CONNECT") {
socket[kReset] = true;
}
if (reset != null) {
socket[kReset] = reset;
}
if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) {
socket[kReset] = true;
}
if (blocking) {
socket[kBlocking] = true;
}
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\n";
} else {
header += "connection: close\r\n";
}
if (headers) {
header += headers;
}
if (channels.sendHeaders.hasSubscribers) {
channels.sendHeaders.publish({ request, headers: header, socket });
}
if (!body || bodyLength === 0) {
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");
}
request.onRequestSent();
} else if (util.isBuffer(body)) {
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);
request.onRequestSent();
if (!expectsPayload) {
socket[kReset] = true;
}
} else if (util.isBlobLike(body)) {
if (typeof body.stream === "function") {
writeIterable({ body: body.stream(), client, request, socket, contentLength, header, expectsPayload });
} else {
writeBlob({ body, client, request, socket, contentLength, header, expectsPayload });
}
} else if (util.isStream(body)) {
writeStream({ body, client, request, socket, contentLength, header, expectsPayload });
} else if (util.isIterable(body)) {
writeIterable({ body, client, request, socket, contentLength, header, expectsPayload });
} else {
assert(false);
}
return true;
}
__name(write, "write");
function writeH2(client, session, request) {
const { body, method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
let headers;
if (typeof reqHeaders === "string")
headers = Request[kHTTP2CopyHeaders](reqHeaders.trim());
else
headers = reqHeaders;
if (upgrade) {
errorRequest(client, request, new Error("Upgrade not supported for H2"));
return false;
}
if (request.aborted) {
return false;
}
let stream;
const h2State = client[kHTTP2SessionState];
headers[HTTP2_HEADER_AUTHORITY] = host || client[kHost];
headers[HTTP2_HEADER_METHOD] = method;
try {
request.onConnect((err) => {
if (request.aborted || request.completed) {
return;
}
err = err || new RequestAbortedError();
if (stream != null) {
util.destroy(stream, err);
h2State.openStreams -= 1;
if (h2State.openStreams === 0) {
session.unref();
}
}
errorRequest(client, request, err);
});
} catch (err) {
errorRequest(client, request, err);
}
if (method === "CONNECT") {
session.ref();
stream = session.request(headers, { endStream: false, signal });
if (stream.id && !stream.pending) {
request.onUpgrade(null, null, stream);
++h2State.openStreams;
} else {
stream.once("ready", () => {
request.onUpgrade(null, null, stream);
++h2State.openStreams;
});
}
stream.once("close", () => {
h2State.openStreams -= 1;
if (h2State.openStreams === 0)
session.unref();
});
return true;
}
headers[HTTP2_HEADER_PATH] = path;
headers[HTTP2_HEADER_SCHEME] = "https";
const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
if (body && typeof body.read === "function") {
body.read(0);
}
let contentLength = util.bodyLength(body);
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]) {
errorRequest(client, request, new RequestContentLengthMismatchError());
return false;
}
process.emitWarning(new RequestContentLengthMismatchError());
}
if (contentLength != null) {
assert(body, "no body must not have content length");
headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`;
}
session.ref();
const 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();
}
++h2State.openStreams;
stream.once("response", (headers2) => {
const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
request.onResponseStarted();
if (request.onHeaders(Number(statusCode), realHeaders, stream.resume.bind(stream), "") === false) {
stream.pause();
}
});
stream.once("end", () => {
request.onComplete([]);
});
stream.on("data", (chunk) => {
if (request.onData(chunk) === false) {
stream.pause();
}
});
stream.once("close", () => {
h2State.openStreams -= 1;
if (h2State.openStreams === 0) {
session.unref();
}
});
stream.once("error", function(err) {
if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
h2State.streams -= 1;
util.destroy(stream, err);
}
});
stream.once("frameError", (type, code) => {
const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
errorRequest(client, request, err);
if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
h2State.streams -= 1;
util.destroy(stream, err);
}
});
return true;
function writeBodyH2() {
if (!body) {
request.onRequestSent();
} else if (util.isBuffer(body)) {
assert(contentLength === body.byteLength, "buffer body must have content length");
stream.cork();
stream.write(body);
stream.uncork();
stream.end();
request.onBodySent(body);
request.onRequestSent();
} else if (util.isBlobLike(body)) {
if (typeof body.stream === "function") {
writeIterable({
client,
request,
contentLength,
h2stream: stream,
expectsPayload,
body: body.stream(),
socket: client[kSocket],
header: ""
});
} else {
writeBlob({
body,
client,
request,
contentLength,
expectsPayload,
h2stream: stream,
header: "",
socket: client[kSocket]
});
}
} else if (util.isStream(body)) {
writeStream({
body,
client,
request,
contentLength,
expectsPayload,
socket: client[kSocket],
h2stream: stream,
header: ""
});
} else if (util.isIterable(body)) {
writeIterable({
body,
client,
request,
contentLength,
expectsPayload,
header: "",
h2stream: stream,
socket: client[kSocket]
});
} else {
assert(false);
}
}
__name(writeBodyH2, "writeBodyH2");
}
__name(writeH2, "writeH2");
function writeStream({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
if (client[kHTTPConnVersion] === "h2") {
let onPipeData = function(chunk) {
request.onBodySent(chunk);
};
__name(onPipeData, "onPipeData");
const pipe = pipeline(
body,
h2stream,
(err) => {
if (err) {
util.destroy(body, err);
util.destroy(h2stream, err);
} else {
request.onRequestSent();
}
}
);
pipe.on("data", onPipeData);
pipe.once("end", () => {
pipe.removeListener("data", onPipeData);
util.destroy(pipe);
});
return;
}
let finished = false;
const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header });
const onData = /* @__PURE__ */ __name(function(chunk) {
if (finished) {
return;
}
try {
if (!writer.write(chunk) && this.pause) {
this.pause();
}
} catch (err) {
util.destroy(this, err);
}
}, "onData");
const onDrain = /* @__PURE__ */ __name(function() {
if (finished) {
return;
}
if (body.resume) {
body.resume();
}
}, "onDrain");
const onClose = /* @__PURE__ */ __name(function() {
queueMicrotask(() => {
body.removeListener("error", onFinished);
});
if (!finished) {
const err = new RequestAbortedError();
queueMicrotask(() => onFinished(err));
}
}, "onClose");
const onFinished = /* @__PURE__ */ __name(function(err) {
if (finished) {
return;
}
finished = true;
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);
if (!err) {
try {
writer.end();
} catch (er) {
err = er;
}
}
writer.destroy(err);
if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) {
util.destroy(body, err);
} else {
util.destroy(body);
}
}, "onFinished");
body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onClose);
if (body.resume) {
body.resume();
}
socket.on("drain", onDrain).on("error", onFinished);
}
__name(writeStream, "writeStream");
async function writeBlob({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
assert(contentLength === body.size, "blob body must have content length");
const isH2 = client[kHTTPConnVersion] === "h2";
try {
if (contentLength != null && contentLength !== body.size) {
throw new RequestContentLengthMismatchError();
}
const buffer = Buffer.from(await body.arrayBuffer());
if (isH2) {
h2stream.cork();
h2stream.write(buffer);
h2stream.uncork();
} else {
socket.cork();
socket.write(`${header}content-length: ${contentLength}\r
\r
`, "latin1");
socket.write(buffer);
socket.uncork();
}
request.onBodySent(buffer);
request.onRequestSent();
if (!expectsPayload) {
socket[kReset] = true;
}
resume(client);
} catch (err) {
util.destroy(isH2 ? h2stream : socket, err);
}
}
__name(writeBlob, "writeBlob");
async function writeIterable({ h2stream, 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) {
const cb = callback;
callback = null;
cb();
}
}
__name(onDrain, "onDrain");
const waitForDrain = /* @__PURE__ */ __name(() => new Promise((resolve, reject) => {
assert(callback === null);
if (socket[kError]) {
reject(socket[kError]);
} else {
callback = resolve;
}
}), "waitForDrain");
if (client[kHTTPConnVersion] === "h2") {
h2stream.on("close", onDrain).on("drain", onDrain);
try {
for await (const chunk of body) {
if (socket[kError]) {
throw socket[kError];
}
const res = h2stream.write(chunk);
request.onBodySent(chunk);
if (!res) {
await waitForDrain();
}
}
} catch (err) {
h2stream.destroy(err);
} finally {
request.onRequestSent();
h2stream.end();
h2stream.off("close", onDrain).off("drain", onDrain);
}
return;
}
socket.on("close", onDrain).on("drain", onDrain);
const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header });
try {
for await (const 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);
}
}
__name(writeIterable, "writeIterable");
var AsyncWriter = class {
static {
__name(this, "AsyncWriter");
}
constructor({ 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;
socket[kWriting] = true;
}
write(chunk) {
const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this;
if (socket[kError]) {
throw socket[kError];
}
if (socket.destroyed) {
return false;
}
const len = Buffer.byteLength(chunk);
if (!len) {
return true;
}
if (contentLength !== null && bytesWritten + len > contentLength) {
if (client[kStrictContentLength]) {
throw new RequestContentLengthMismatchError();
}
process.emitWarning(new RequestContentLengthMismatchError());
}
socket.cork();
if (bytesWritten === 0) {
if (!expectsPayload) {
socket[kReset] = true;
}
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;
const ret = socket.write(chunk);
socket.uncork();
request.onBodySent(chunk);
if (!ret) {
if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
if (socket[kParser].timeout.refresh) {
socket[kParser].timeout.refresh();
}
}
}
return ret;
}
end() {
const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this;
request.onRequestSent();
socket[kWriting] = false;
if (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\n0\r\n\r\n", "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();
}
}
resume(client);
}
destroy(err) {
const { socket, client } = this;
socket[kWriting] = false;
if (err) {
assert(client[kRunning] <= 1, "pipeline should only contain this request");
util.destroy(socket, err);
}
}
};
function errorRequest(client, request, err) {
try {
request.onError(err);
assert(request.aborted);
} catch (err2) {
client.emit("error", err2);
}
}
__name(errorRequest, "errorRequest");
module2.exports = Client;
}
});
// lib/pool.js
var require_pool = __commonJS({
"lib/pool.js"(exports2, module2) {
"use strict";
var {
PoolBase,
kClients,
kNeedDrain,
kAddClient,
kGetDispatcher
} = require_pool_base();
var Client = require_client();
var {
InvalidArgumentError
} = require_errors();
var util = require_util();
var { kUrl, kInterceptors } = require_symbols();
var buildConnector = require_connect();
var kOptions = Symbol("options");
var kConnections = Symbol("connections");
var kFactory = Symbol("factory");
function defaultFactory(origin, opts) {
return new Client(origin, opts);
}
__name(defaultFactory, "defaultFactory");
var Pool = class extends PoolBase {
static {
__name(this, "Pool");
}
constructor(origin, {
connections,
factory = defaultFactory,
connect,
connectTimeout,
tls,
maxCachedSessions,
socketPath,
autoSelectFamily,
autoSelectFamilyAttemptTimeout,
allowH2,
...options
} = {}) {
super();
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");
}
if (typeof connect !== "function") {
connect = buildConnector({
...tls,
maxCachedSessions,
allowH2,
socketPath,
timeout: connectTimeout,
...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
...connect
});
}
this[kInterceptors] = options.interceptors?.Pool && Array.isArray(options.interceptors.Pool) ? options.interceptors.Pool : [];
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 (const client of this[kClients]) {
if (!client[kNeedDrain]) {
return client;
}
}
if (!this[kConnections] || this[kClients].length < this[kConnections]) {
const dispatcher = this[kFactory](this[kUrl], this[kOptions]);
this[kAddClient](dispatcher);
return dispatcher;
}
}
};
module2.exports = Pool;
}
});
// lib/agent.js
var require_agent = __commonJS({
"lib/agent.js"(exports2, module2) {
"use strict";
var { InvalidArgumentError } = require_errors();
var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols();
var DispatcherBase = require_dispatcher_base();
var Pool = require_pool();
var Client = require_client();
var util = require_util();
var createRedirectInterceptor = require_redirectInterceptor();
var kOnConnect = Symbol("onConnect");
var kOnDisconnect = Symbol("onDisconnect");
var kOnConnectionError = Symbol("onConnectionError");
var kMaxRedirections = Symbol("maxRedirections");
var kOnDrain = Symbol("onDrain");
var kFactory = Symbol("factory");
var kOptions = Symbol("options");
function defaultFactory(origin, opts) {
return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
}
__name(defaultFactory, "defaultFactory");
var Agent = class extends DispatcherBase {
static {
__name(this, "Agent");
}
constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) {
super();
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");
}
if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
throw new InvalidArgumentError("maxRedirections must be a positive number");
}
if (connect && typeof connect !== "function") {
connect = { ...connect };
}
this[kInterceptors] = options.interceptors?.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })];
this[kOptions] = { ...util.deepClone(options), connect };
this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
this[kMaxRedirections] = maxRedirections;
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 (const 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]() {
const closePromises = [];
for (const client of this[kClients].values()) {
closePromises.push(client.close());
}
this[kClients].clear();
await Promise.all(closePromises);
}
async [kDestroy](err) {
const destroyPromises = [];
for (const client of this[kClients].values()) {
destroyPromises.push(client.destroy(err));
}
this[kClients].clear();
await Promise.all(destroyPromises);
}
};
module2.exports = Agent;
}
});
// lib/global.js
var require_global2 = __commonJS({
"lib/global.js"(exports2, module2) {
"use strict";
var globalDispatcher = Symbol.for("undici.globalDispatcher.1");
var { InvalidArgumentError } = require_errors();
var 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: true,
enumerable: false,
configurable: false
});
}
__name(setGlobalDispatcher, "setGlobalDispatcher");
function getGlobalDispatcher() {
return globalThis[globalDispatcher];
}
__name(getGlobalDispatcher, "getGlobalDispatcher");
module2.exports = {
setGlobalDispatcher,
getGlobalDispatcher
};
}
});
// lib/fetch/index.js
var require_fetch = __commonJS({
"lib/fetch/index.js"(exports2, module2) {
"use strict";
var {
makeNetworkError,
makeAppropriateNetworkError,
filterResponse,
makeResponse,
fromInnerResponse
} = require_response();
var { HeadersList } = require_headers();
var { Request, makeRequest } = require_request();
var zlib = require("node:zlib");
var {
bytesMatch,
makePolicyContainer,
clonePolicyContainer,
requestBadPort,
TAOCheck,
appendRequestOriginHeader,
responseLocationURL,
requestCurrentURL,
setRequestReferrerPolicyOnRedirect,
tryUpgradeRequestToAPotentiallyTrustworthyURL,
createOpaqueTimingInfo,
appendFetchMetadata,
corsCheck,
crossOriginResourcePolicyCheck,
determineRequestsReferrer,
coarsenedSharedCurrentTime,
createDeferredPromise,
isBlobLike,
sameOrigin,
isCancelled,
isAborted,
isErrorLike,
fullyReadBody,
readableStreamClose,
isomorphicEncode,
urlIsLocal,
urlIsHttpHttpsScheme,
urlHasHttpsScheme,
clampAndCoarsenConnectionTimingInfo,
simpleRangeHeaderValue,
buildContentRange,
createInflate,
extractMimeType
} = require_util2();
var { kState } = require_symbols2();
var assert = require("node:assert");
var { safelyExtractBody, extractBody } = require_body();
var {
redirectStatusSet,
nullBodyStatus,
safeMethodsSet,
requestBodyHeader,
subresourceSet
} = require_constants2();
var EE = require("node:events");
var { Readable, pipeline } = require("node:stream");
var { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor, bufferToLowerCasedHeaderName } = require_util();
var { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = require_dataURL();
var { getGlobalDispatcher } = require_global2();
var { webidl } = require_webidl();
var { STATUS_CODES } = require("node:http");
var GET_OR_HEAD = ["GET", "HEAD"];
var resolveObjectURL;
var Fetch = class extends EE {
static {
__name(this, "Fetch");
}
constructor(dispatcher) {
super();
this.dispatcher = dispatcher;
this.connection = null;
this.dump = false;
this.state = "ongoing";
this.setMaxListeners(21);
}
terminate(reason) {
if (this.state !== "ongoing") {
return;
}
this.state = "terminated";
this.connection?.destroy(reason);
this.emit("terminated", reason);
}
// https://fetch.spec.whatwg.org/#fetch-controller-abort
abort(error) {
if (this.state !== "ongoing") {
return;
}
this.state = "aborted";
if (!error) {
error = new DOMException("The operation was aborted.", "AbortError");
}
this.serializedAbortReason = error;
this.connection?.destroy(error);
this.emit("terminated", error);
}
};
function fetch2(input, init = void 0) {
webidl.argumentLengthCheck(arguments, 1, { header: "globalThis.fetch" });
const p = createDeferredPromise();
let requestObject;
try {
requestObject = new Request(input, init);
} catch (e) {
p.reject(e);
return p.promise;
}
const request = requestObject[kState];
if (requestObject.signal.aborted) {
abortFetch(p, request, null, requestObject.signal.reason);
return p.promise;
}
const globalObject = request.client.globalObject;
if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") {
request.serviceWorkers = "none";
}
let responseObject = null;
const relevantRealm = null;
let locallyAborted = false;
let controller = null;
addAbortListener(
requestObject.signal,
() => {
locallyAborted = true;
assert(controller != null);
controller.abort(requestObject.signal.reason);
abortFetch(p, request, responseObject, requestObject.signal.reason);
}
);
const handleFetchDone = /* @__PURE__ */ __name((response) => finalizeAndReportTiming(response, "fetch"), "handleFetchDone");
const processResponse = /* @__PURE__ */ __name((response) => {
if (locallyAborted) {
return Promise.resolve();
}
if (response.aborted) {
abortFetch(p, request, responseObject, controller.serializedAbortReason);
return Promise.resolve();
}
if (response.type === "error") {
p.reject(new TypeError("fetch failed", { cause: response.error }));
return Promise.resolve();
}
responseObject = fromInnerResponse(response, "immutable", relevantRealm);
p.resolve(responseObject);
}, "processResponse");
controller = fetching({
request,
processResponseEndOfBody: handleFetchDone,
processResponse,
dispatcher: init?.dispatcher ?? getGlobalDispatcher()
// undici
});
return p.promise;
}
__name(fetch2, "fetch");
function finalizeAndReportTiming(response, initiatorType = "other") {
if (response.type === "error" && response.aborted) {
return;
}
if (!response.urlList?.length) {
return;
}
const originalURL = response.urlList[0];
let timingInfo = response.timingInfo;
let 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
);
}
__name(finalizeAndReportTiming, "finalizeAndReportTiming");
var markResourceTiming = nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 2 ? performance.markResourceTiming : () => {
};
function abortFetch(p, request, responseObject, error) {
p.reject(error);
if (request.body != 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;
}
const response = responseObject[kState];
if (response.body != null && isReadable(response.body?.stream)) {
response.body.stream.cancel(error).catch((err) => {
if (err.code === "ERR_INVALID_STATE") {
return;
}
throw err;
});
}
}
__name(abortFetch, "abortFetch");
function fetching({
request,
processRequestBodyChunkLength,
processRequestEndOfBody,
processResponse,
processResponseEndOfBody,
processResponseConsumeBody,
useParallelQueue = false,
dispatcher
// undici
}) {
assert(dispatcher);
let taskDestination = null;
let crossOriginIsolatedCapability = false;
if (request.client != null) {
taskDestination = request.client.globalObject;
crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability;
}
const currentTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability);
const timingInfo = createOpaqueTimingInfo({
startTime: currentTime
});
const fetchParams = {
controller: new Fetch(dispatcher),
request,
timingInfo,
processRequestBodyChunkLength,
processRequestEndOfBody,
processResponse,
processResponseConsumeBody,
processResponseEndOfBody,
taskDestination,
crossOriginIsolatedCapability
};
assert(!request.body || request.body.stream);
if (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", true)) {
const value = "*/*";
request.headersList.append("accept", value, true);
}
if (!request.headersList.contains("accept-language", true)) {
request.headersList.append("accept-language", "*", true);
}
if (request.priority === null) {
}
if (subresourceSet.has(request.destination)) {
}
mainFetch(fetchParams).catch((err) => {
fetchParams.controller.terminate(err);
});
return fetchParams.controller;
}
__name(fetching, "fetching");
async function mainFetch(fetchParams, recursive = false) {
const request = fetchParams.request;
let response = null;
if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) {
response = makeNetworkError("local URLs only");
}
tryUpgradeRequestToAPotentiallyTrustworthyURL(request);
if (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) {
response = await (async () => {
const currentURL = requestCurrentURL(request);
if (
// - request’s current URL’s origin is same origin with request’s origin,
// and request’s response tainting is "basic"
sameOrigin(currentURL, request.url) && request.responseTainting === "basic" || // request’s current URL’s scheme is "data"
currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket"
(request.mode === "navigate" || request.mode === "websocket")
) {
request.responseTainting = "basic";
return await schemeFetch(fetchParams);
}
if (request.mode === "same-origin") {
return makeNetworkError('request mode cannot be "same-origin"');
}
if (request.mode === "no-cors") {
if (request.redirect !== "follow") {
return makeNetworkError(
'redirect mode cannot be "follow" for "no-cors" request'
);
}
request.responseTainting = "opaque";
return await schemeFetch(fetchParams);
}
if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) {
return makeNetworkError("URL scheme must be a HTTP(S) scheme");
}
request.responseTainting = "cors";
return 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(false);
}
}
let internalResponse = response.status === 0 ? response : response.internalResponse;
if (internalResponse.urlList.length === 0) {
internalResponse.urlList.push(...request.urlList);
}
if (!request.timingAllowFailed) {
response.timingAllowPassed = true;
}
if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request.headers.contains("range", true)) {
response = internalResponse = makeNetworkError();
}
if (response.status !== 0 && (request.method === "HEAD" || request.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) {
internalResponse.body = null;
fetchParams.controller.dump = true;
}
if (request.integrity) {
const processBodyError = /* @__PURE__ */ __name((reason) => fetchFinale(fetchParams, makeNetworkError(reason)), "processBodyError");
if (request.responseTainting === "opaque" || response.body == null) {
processBodyError(response.error);
return;
}
const processBody = /* @__PURE__ */ __name((bytes) => {
if (!bytesMatch(bytes, request.integrity)) {
processBodyError("integrity mismatch");
return;
}
response.body = safelyExtractBody(bytes)[0];
fetchFinale(fetchParams, response);
}, "processBody");
await fullyReadBody(response.body, processBody, processBodyError);
} else {
fetchFinale(fetchParams, response);
}
}
__name(mainFetch, "mainFetch");
function schemeFetch(fetchParams) {
if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
return Promise.resolve(makeAppropriateNetworkError(fetchParams));
}
const { request } = fetchParams;
const { 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;
}
const blobURLEntry = requestCurrentURL(request);
if (blobURLEntry.search.length !== 0) {
return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource."));
}
const blob = resolveObjectURL(blobURLEntry.toString());
if (request.method !== "GET" || !isBlobLike(blob)) {
return Promise.resolve(makeNetworkError("invalid method"));
}
const response = makeResponse();
const fullLength = blob.size;
const serializedFullLength = isomorphicEncode(`${fullLength}`);
const type = blob.type;
if (!request.headersList.contains("range", true)) {
const bodyWithType = extractBody(blob);
response.statusText = "OK";
response.body = bodyWithType[0];
response.headersList.set("content-length", serializedFullLength, true);
response.headersList.set("content-type", type, true);
} else {
response.rangeRequested = true;
const rangeHeader = request.headersList.get("range", true);
const rangeValue = simpleRangeHeaderValue(rangeHeader, true);
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;
}
}
const slicedBlob = blob.slice(rangeStart, rangeEnd, type);
const slicedBodyWithType = extractBody(slicedBlob);
response.body = slicedBodyWithType[0];
const serializedSlicedLength = isomorphicEncode(`${slicedBlob.size}`);
const contentRange = buildContentRange(rangeStart, rangeEnd, fullLength);
response.status = 206;
response.statusText = "Partial Content";
response.headersList.set("content-length", serializedSlicedLength, true);
response.headersList.set("content-type", type, true);
response.headersList.set("content-range", contentRange, true);
}
return Promise.resolve(response);
}
case "data:": {
const currentURL = requestCurrentURL(request);
const dataURLStruct = dataURLProcessor(currentURL);
if (dataURLStruct === "failure") {
return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
}
const 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"));
}
}
}
__name(schemeFetch, "schemeFetch");
function finalizeResponse(fetchParams, response) {
fetchParams.request.done = true;
if (fetchParams.processResponseDone != null) {
queueMicrotask(() => fetchParams.processResponseDone(response));
}
}
__name(finalizeResponse, "finalizeResponse");
function fetchFinale(fetchParams, response) {
let timingInfo = fetchParams.timingInfo;
const processResponseEndOfBody = /* @__PURE__ */ __name(() => {
const 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 = response.cacheState;
const bodyInfo = response.bodyInfo;
if (!response.timingAllowPassed) {
timingInfo = createOpaqueTimingInfo(timingInfo);
cacheState = "";
}
let responseStatus = 0;
if (fetchParams.request.mode !== "navigator" || !response.hasCrossOriginRedirects) {
responseStatus = response.status;
const 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);
}
};
const processResponseEndOfBodyTask = /* @__PURE__ */ __name(() => {
fetchParams.request.done = true;
if (fetchParams.processResponseEndOfBody != null) {
queueMicrotask(() => fetchParams.processResponseEndOfBody(response));
}
if (fetchParams.request.initiatorType != null) {
fetchParams.controller.reportTimingSteps();
}
}, "processResponseEndOfBodyTask");
queueMicrotask(() => processResponseEndOfBodyTask());
}, "processResponseEndOfBody");
if (fetchParams.processResponse != null) {
queueMicrotask(() => fetchParams.processResponse(response));
}
const internalResponse = response.type === "error" ? response : response.internalResponse ?? response;
if (internalResponse.body == null) {
processResponseEndOfBody();
} else {
const transformStream = new TransformStream({
start() {
},
transform(chunk, controller) {
controller.enqueue(chunk);
},
flush: processResponseEndOfBody
});
internalResponse.body.stream.pipeThrough(transformStream);
const byteStream = new ReadableStream({
readableStream: transformStream.readable,
async start() {
this._bodyReader = this.readableStream.getReader();
},
async pull(controller) {
while (controller.desiredSize >= 0) {
const { done, value } = await this._bodyReader.read();
if (done) {
queueMicrotask(() => readableStreamClose(controller));
break;
}
controller.enqueue(value);
}
},
queuingStrategy: new ByteLengthQueuingStrategy({ highWaterMark: 16384 }),
type: "bytes"
});
internalResponse.body.stream = byteStream;
}
}
__name(fetchFinale, "fetchFinale");
async function httpFetch(fetchParams) {
const request = fetchParams.request;
let response = null;
let actualResponse = null;
const timingInfo = fetchParams.timingInfo;
if (request.serviceWorkers === "all") {
}
if (response === null) {
if (request.redirect === "follow") {
request.serviceWorkers = "none";
}
actualResponse = response = await httpNetworkOrCacheFetch(fetchParams);
if (request.responseTainting === "cors" && corsCheck(request, response) === "failure") {
return makeNetworkError("cors failure");
}
if (TAOCheck(request, response) === "failure") {
request.timingAllowFailed = true;
}
}
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, false);
}
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(false);
}
}
response.timingInfo = timingInfo;
return response;
}
__name(httpFetch, "httpFetch");
function httpRedirectFetch(fetchParams, response) {
const request = fetchParams.request;
const actualResponse = response.internalResponse ? response.internalResponse : response;
let locationURL;
try {
locationURL = responseLocationURL(
actualResponse,
requestCurrentURL(request).hash
);
if (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"));
}
request.redirectCount += 1;
if (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 (const headerName of requestBodyHeader) {
request.headersList.delete(headerName);
}
}
if (!sameOrigin(requestCurrentURL(request), locationURL)) {
request.headersList.delete("authorization", true);
request.headersList.delete("proxy-authorization", true);
request.headersList.delete("cookie", true);
request.headersList.delete("host", true);
}
if (request.body != null) {
assert(request.body.source != null);
request.body = safelyExtractBody(request.body.source)[0];
}
const timingInfo = fetchParams.timingInfo;
timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
if (timingInfo.redirectStartTime === 0) {
timingInfo.redirectStartTime = timingInfo.startTime;
}
request.urlList.push(locationURL);
setRequestReferrerPolicyOnRedirect(request, actualResponse);
return mainFetch(fetchParams, true);
}
__name(httpRedirectFetch, "httpRedirectFetch");
async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) {
const request = fetchParams.request;
let httpFetchParams = null;
let httpRequest = null;
let response = null;
const httpCache = null;
const revalidatingFlag = false;
if (request.window === "no-window" && request.redirect === "error") {
httpFetchParams = fetchParams;
httpRequest = request;
} else {
httpRequest = makeRequest(request);
httpFetchParams = { ...fetchParams };
httpFetchParams.request = httpRequest;
}
const includeCredentials = request.credentials === "include" || request.credentials === "same-origin" && request.responseTainting === "basic";
const contentLength = httpRequest.body ? httpRequest.body.length : null;
let 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, true);
}
if (contentLength != null && httpRequest.keepalive) {
}
if (httpRequest.referrer instanceof URL) {
httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href), true);
}
appendRequestOriginHeader(httpRequest);
appendFetchMetadata(httpRequest);
if (!httpRequest.headersList.contains("user-agent", true)) {
httpRequest.headersList.append("user-agent", false ? "undici" : "node", true);
}
if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since", true) || httpRequest.headersList.contains("if-none-match", true) || httpRequest.headersList.contains("if-unmodified-since", true) || httpRequest.headersList.contains("if-match", true) || httpRequest.headersList.contains("if-range", true))) {
httpRequest.cache = "no-store";
}
if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control", true)) {
httpRequest.headersList.append("cache-control", "max-age=0", true);
}
if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") {
if (!httpRequest.headersList.contains("pragma", true)) {
httpRequest.headersList.append("pragma", "no-cache", true);
}
if (!httpRequest.headersList.contains("cache-control", true)) {
httpRequest.headersList.append("cache-control", "no-cache", true);
}
}
if (httpRequest.headersList.contains("range", true)) {
httpRequest.headersList.append("accept-encoding", "identity", true);
}
if (!httpRequest.headersList.contains("accept-encoding", true)) {
if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) {
httpRequest.headersList.append("accept-encoding", "br, gzip, deflate", true);
} else {
httpRequest.headersList.append("accept-encoding", "gzip, deflate", true);
}
}
httpRequest.headersList.delete("host", true);
if (includeCredentials) {
}
if (httpCache == null) {
httpRequest.cache = "no-store";
}
if (httpRequest.mode !== "no-store" && httpRequest.mode !== "reload") {
}
if (response == null) {
if (httpRequest.mode === "only-if-cached") {
return makeNetworkError("only if cached");
}
const 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;
}
}
response.urlList = [...httpRequest.urlList];
if (httpRequest.headersList.contains("range", true)) {
response.rangeRequested = true;
}
response.requestIncludesCredentials = includeCredentials;
if (response.status === 407) {
if (request.window === "no-window") {
return makeNetworkError();
}
if (isCancelled(fetchParams)) {
return makeAppropriateNetworkError(fetchParams);
}
return makeNetworkError("proxy authentication required");
}
if (
// response’s status is 421
response.status === 421 && // isNewConnectionFetch is false
!isNewConnectionFetch && // request’s body is null, or request’s body is non-null and request’s body’s source is non-null
(request.body == null || request.body.source != null)
) {
if (isCancelled(fetchParams)) {
return makeAppropriateNetworkError(fetchParams);
}
fetchParams.controller.connection.destroy();
response = await httpNetworkOrCacheFetch(
fetchParams,
isAuthenticationFetch,
true
);
}
if (isAuthenticationFetch) {
}
return response;
}
__name(httpNetworkOrCacheFetch, "httpNetworkOrCacheFetch");
async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) {
assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed);
fetchParams.controller.connection = {
abort: null,
destroyed: false,
destroy(err, abort = true) {
if (!this.destroyed) {
this.destroyed = true;
if (abort) {
this.abort?.(err ?? new DOMException("The operation was aborted.", "AbortError"));
}
}
}
};
const request = fetchParams.request;
let response = null;
const timingInfo = fetchParams.timingInfo;
const httpCache = null;
if (httpCache == null) {
request.cache = "no-store";
}
const newConnection = forceNewConnection ? "yes" : "no";
if (request.mode === "websocket") {
} else {
}
let requestBody = null;
if (request.body == null && fetchParams.processRequestEndOfBody) {
queueMicrotask(() => fetchParams.processRequestEndOfBody());
} else if (request.body != null) {
const processBodyChunk = /* @__PURE__ */ __name(async function* (bytes) {
if (isCancelled(fetchParams)) {
return;
}
yield bytes;
fetchParams.processRequestBodyChunkLength?.(bytes.byteLength);
}, "processBodyChunk");
const processEndOfBody = /* @__PURE__ */ __name(() => {
if (isCancelled(fetchParams)) {
return;
}
if (fetchParams.processRequestEndOfBody) {
fetchParams.processRequestEndOfBody();
}
}, "processEndOfBody");
const processBodyError = /* @__PURE__ */ __name((e) => {
if (isCancelled(fetchParams)) {
return;
}
if (e.name === "AbortError") {
fetchParams.controller.abort();
} else {
fetchParams.controller.terminate(e);
}
}, "processBodyError");
requestBody = async function* () {
try {
for await (const bytes of request.body.stream) {
yield* processBodyChunk(bytes);
}
processEndOfBody();
} catch (err) {
processBodyError(err);
}
}();
}
try {
const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody });
if (socket) {
response = makeResponse({ status, statusText, headersList, socket });
} else {
const iterator = body[Symbol.asyncIterator]();
fetchParams.controller.next = () => iterator.next();
response = makeResponse({ status, statusText, headersList });
}
} catch (err) {
if (err.name === "AbortError") {
fetchParams.controller.connection.destroy();
return makeAppropriateNetworkError(fetchParams, err);
}
return makeNetworkError(err);
}
const pullAlgorithm = /* @__PURE__ */ __name(async () => {
await fetchParams.controller.resume();
}, "pullAlgorithm");
const cancelAlgorithm = /* @__PURE__ */ __name((reason) => {
fetchParams.controller.abort(reason);
}, "cancelAlgorithm");
const stream = new ReadableStream(
{
highWaterMark: 16384,
async start(controller) {
fetchParams.controller.controller = controller;
},
async pull(controller) {
await pullAlgorithm(controller);
},
async cancel(reason) {
await cancelAlgorithm(reason);
},
type: "bytes",
queuingStrategy: new ByteLengthQueuingStrategy({ highWaterMark: 16384 })
}
);
response.body = { stream };
fetchParams.controller.on("terminated", onAborted);
fetchParams.controller.resume = async () => {
while (true) {
let bytes;
let isFailure;
try {
const { 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 = true;
}
}
if (bytes === void 0) {
readableStreamClose(fetchParams.controller.controller);
finalizeResponse(fetchParams, response);
return;
}
timingInfo.decodedBodySize += bytes?.byteLength ?? 0;
if (isFailure) {
fetchParams.controller.terminate(bytes);
return;
}
const 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)) {
response.aborted = true;
if (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();
}
__name(onAborted, "onAborted");
return response;
function dispatch({ body }) {
const url = requestCurrentURL(request);
const 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) {
const { connection } = fetchParams.controller;
timingInfo.finalConnectionTimingInfo = clampAndCoarsenConnectionTimingInfo(void 0, timingInfo.postRedirectStartTime, fetchParams.crossOriginIsolatedCapability);
if (connection.destroyed) {
abort(new DOMException("The operation was aborted.", "AbortError"));
} else {
fetchParams.controller.on("terminated", abort);
this.abort = connection.abort = abort;
}
timingInfo.finalNetworkRequestStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
},
onResponseStarted() {
timingInfo.finalNetworkResponseStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
},
onHeaders(status, rawHeaders, resume, statusText) {
if (status < 200) {
return;
}
let codings = [];
let location = "";
const headersList = new HeadersList();
if (Array.isArray(rawHeaders)) {
for (let i = 0; i < rawHeaders.length; i += 2) {
headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true);
}
const contentEncoding = headersList.get("content-encoding", true);
if (contentEncoding) {
codings = contentEncoding.toLowerCase().split(",").map((x) => x.trim());
}
location = headersList.get("location", true);
} else {
const keys = Object.keys(rawHeaders);
for (let i = 0; i < keys.length; ++i) {
headersList.append(keys[i], rawHeaders[keys[i]], true);
}
const contentEncoding = rawHeaders["content-encoding"];
if (contentEncoding) {
codings = contentEncoding.toLowerCase().split(",").map((x) => x.trim()).reverse();
}
location = rawHeaders.location;
}
this.body = new Readable({ read: resume });
const decoders = [];
const willFollow = location && request.redirect === "follow" && redirectStatusSet.has(status);
if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) {
for (let i = 0; i < codings.length; ++i) {
const coding = codings[i];
if (coding === "x-gzip" || coding === "gzip") {
decoders.push(zlib.createGunzip({
// Be less strict when decoding compressed responses, since sometimes
// servers send slightly invalid responses that are still accepted
// by common browsers.
// Always using Z_SYNC_FLUSH is what cURL does.
flush: zlib.constants.Z_SYNC_FLUSH,
finishFlush: zlib.constants.Z_SYNC_FLUSH
}));
} else if (coding === "deflate") {
decoders.push(createInflate());
} else if (coding === "br") {
decoders.push(zlib.createBrotliDecompress());
} else {
decoders.length = 0;
break;
}
}
}
resolve({
status,
statusText,
headersList,
body: decoders.length ? pipeline(this.body, ...decoders, () => {
}) : this.body.on("error", () => {
})
});
return true;
},
onData(chunk) {
if (fetchParams.controller.dump) {
return;
}
const bytes = chunk;
timingInfo.encodedBodySize += bytes.byteLength;
return this.body.push(bytes);
},
onComplete() {
if (this.abort) {
fetchParams.controller.off("terminated", this.abort);
}
fetchParams.controller.ended = true;
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;
}
const headersList = new HeadersList();
for (let i = 0; i < rawHeaders.length; i += 2) {
headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true);
}
resolve({
status,
statusText: STATUS_CODES[status],
headersList,
socket
});
return true;
}
}
));
}
__name(dispatch, "dispatch");
}
__name(httpNetworkFetch, "httpNetworkFetch");
module2.exports = {
fetch: fetch2,
Fetch,
fetching,
finalizeAndReportTiming
};
}
});
// lib/websocket/constants.js
var require_constants4 = __commonJS({
"lib/websocket/constants.js"(exports2, module2) {
"use strict";
var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
var staticPropertyDescriptors = {
enumerable: true,
writable: false,
configurable: false
};
var states = {
CONNECTING: 0,
OPEN: 1,
CLOSING: 2,
CLOSED: 3
};
var opcodes = {
CONTINUATION: 0,
TEXT: 1,
BINARY: 2,
CLOSE: 8,
PING: 9,
PONG: 10
};
var maxUnsigned16Bit = 2 ** 16 - 1;
var parserStates = {
INFO: 0,
PAYLOADLENGTH_16: 2,
PAYLOADLENGTH_64: 3,
READ_DATA: 4
};
var emptyBuffer = Buffer.allocUnsafe(0);
module2.exports = {
uid,
staticPropertyDescriptors,
states,
opcodes,
maxUnsigned16Bit,
parserStates,
emptyBuffer
};
}
});
// lib/websocket/symbols.js
var require_symbols3 = __commonJS({
"lib/websocket/symbols.js"(exports2, module2) {
"use strict";
module2.exports = {
kWebSocketURL: Symbol("url"),
kReadyState: Symbol("ready state"),
kController: Symbol("controller"),
kResponse: Symbol("response"),
kBinaryType: Symbol("binary type"),
kSentClose: Symbol("sent close"),
kReceivedClose: Symbol("received close"),
kByteParser: Symbol("byte parser")
};
}
});
// lib/websocket/events.js
var require_events = __commonJS({
"lib/websocket/events.js"(exports2, module2) {
"use strict";
var { webidl } = require_webidl();
var { kEnumerableProperty } = require_util();
var { MessagePort } = require("node:worker_threads");
var MessageEvent = class _MessageEvent extends Event {
static {
__name(this, "MessageEvent");
}
#eventInit;
constructor(type, eventInitDict = {}) {
webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent constructor" });
type = webidl.converters.DOMString(type);
eventInitDict = webidl.converters.MessageEventInit(eventInitDict);
super(type, eventInitDict);
this.#eventInit = eventInitDict;
}
get data() {
webidl.brandCheck(this, _MessageEvent);
return this.#eventInit.data;
}
get origin() {
webidl.brandCheck(this, _MessageEvent);
return this.#eventInit.origin;
}
get lastEventId() {
webidl.brandCheck(this, _MessageEvent);
return this.#eventInit.lastEventId;
}
get source() {
webidl.brandCheck(this, _MessageEvent);
return this.#eventInit.source;
}
get ports() {
webidl.brandCheck(this, _MessageEvent);
if (!Object.isFrozen(this.#eventInit.ports)) {
Object.freeze(this.#eventInit.ports);
}
return this.#eventInit.ports;
}
initMessageEvent(type, bubbles = false, cancelable = false, data = null, origin = "", lastEventId = "", source = null, ports = []) {
webidl.brandCheck(this, _MessageEvent);
webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent.initMessageEvent" });
return new _MessageEvent(type, {
bubbles,
cancelable,
data,
origin,
lastEventId,
source,
ports
});
}
};
var CloseEvent = class _CloseEvent extends Event {
static {
__name(this, "CloseEvent");
}
#eventInit;
constructor(type, eventInitDict = {}) {
webidl.argumentLengthCheck(arguments, 1, { header: "CloseEvent constructor" });
type = webidl.converters.DOMString(type);
eventInitDict = webidl.converters.CloseEventInit(eventInitDict);
super(type, eventInitDict);
this.#eventInit = eventInitDict;
}
get wasClean() {
webidl.brandCheck(this, _CloseEvent);
return this.#eventInit.wasClean;
}
get code() {
webidl.brandCheck(this, _CloseEvent);
return this.#eventInit.code;
}
get reason() {
webidl.brandCheck(this, _CloseEvent);
return this.#eventInit.reason;
}
};
var ErrorEvent = class _ErrorEvent extends Event {
static {
__name(this, "ErrorEvent");
}
#eventInit;
constructor(type, eventInitDict) {
webidl.argumentLengthCheck(arguments, 1, { header: "ErrorEvent constructor" });
super(type, eventInitDict);
type = webidl.converters.DOMString(type);
eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {});
this.#eventInit = eventInitDict;
}
get message() {
webidl.brandCheck(this, _ErrorEvent);
return this.#eventInit.message;
}
get filename() {
webidl.brandCheck(this, _ErrorEvent);
return this.#eventInit.filename;
}
get lineno() {
webidl.brandCheck(this, _ErrorEvent);
return this.#eventInit.lineno;
}
get colno() {
webidl.brandCheck(this, _ErrorEvent);
return this.#eventInit.colno;
}
get error() {
webidl.brandCheck(this, _ErrorEvent);
return this.#eventInit.error;
}
};
Object.defineProperties(MessageEvent.prototype, {
[Symbol.toStringTag]: {
value: "MessageEvent",
configurable: true
},
data: kEnumerableProperty,
origin: kEnumerableProperty,
lastEventId: kEnumerableProperty,
source: kEnumerableProperty,
ports: kEnumerableProperty,
initMessageEvent: kEnumerableProperty
});
Object.defineProperties(CloseEvent.prototype, {
[Symbol.toStringTag]: {
value: "CloseEvent",
configurable: true
},
reason: kEnumerableProperty,
code: kEnumerableProperty,
wasClean: kEnumerableProperty
});
Object.defineProperties(ErrorEvent.prototype, {
[Symbol.toStringTag]: {
value: "ErrorEvent",
configurable: true
},
message: kEnumerableProperty,
filename: kEnumerableProperty,
lineno: kEnumerableProperty,
colno: kEnumerableProperty,
error: kEnumerableProperty
});
webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort);
webidl.converters["sequence<MessagePort>"] = webidl.sequenceConverter(
webidl.converters.MessagePort
);
var eventInit = [
{
key: "bubbles",
converter: webidl.converters.boolean,
defaultValue: false
},
{
key: "cancelable",
converter: webidl.converters.boolean,
defaultValue: false
},
{
key: "composed",
converter: webidl.converters.boolean,
defaultValue: false
}
];
webidl.converters.MessageEventInit = webidl.dictionaryConverter([
...eventInit,
{
key: "data",
converter: webidl.converters.any,
defaultValue: null
},
{
key: "origin",
converter: webidl.converters.USVString,
defaultValue: ""
},
{
key: "lastEventId",
converter: webidl.converters.DOMString,
defaultValue: ""
},
{
key: "source",
// Node doesn't implement WindowProxy or ServiceWorker, so the only
// valid value for source is a MessagePort.
converter: webidl.nullableConverter(webidl.converters.MessagePort),
defaultValue: null
},
{
key: "ports",
converter: webidl.converters["sequence<MessagePort>"],
get defaultValue() {
return [];
}
}
]);
webidl.converters.CloseEventInit = webidl.dictionaryConverter([
...eventInit,
{
key: "wasClean",
converter: webidl.converters.boolean,
defaultValue: false
},
{
key: "code",
converter: webidl.converters["unsigned short"],
defaultValue: 0
},
{
key: "reason",
converter: webidl.converters.USVString,
defaultValue: ""
}
]);
webidl.converters.ErrorEventInit = webidl.dictionaryConverter([
...eventInit,
{
key: "message",
converter: webidl.converters.DOMString,
defaultValue: ""
},
{
key: "filename",
converter: webidl.converters.USVString,
defaultValue: ""
},
{
key: "lineno",
converter: webidl.converters["unsigned long"],
defaultValue: 0
},
{
key: "colno",
converter: webidl.converters["unsigned long"],
defaultValue: 0
},
{
key: "error",
converter: webidl.converters.any
}
]);
module2.exports = {
MessageEvent,
CloseEvent,
ErrorEvent
};
}
});
// lib/websocket/util.js
var require_util3 = __commonJS({
"lib/websocket/util.js"(exports2, module2) {
"use strict";
var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols3();
var { states, opcodes } = require_constants4();
var { MessageEvent, ErrorEvent } = require_events();
function isEstablished(ws) {
return ws[kReadyState] === states.OPEN;
}
__name(isEstablished, "isEstablished");
function isClosing(ws) {
return ws[kReadyState] === states.CLOSING;
}
__name(isClosing, "isClosing");
function isClosed(ws) {
return ws[kReadyState] === states.CLOSED;
}
__name(isClosed, "isClosed");
function fireEvent(e, target, eventConstructor = Event, eventInitDict = {}) {
const event = new eventConstructor(e, eventInitDict);
target.dispatchEvent(event);
}
__name(fireEvent, "fireEvent");
function websocketMessageReceived(ws, type, data) {
if (ws[kReadyState] !== states.OPEN) {
return;
}
let dataForEvent;
if (type === opcodes.TEXT) {
try {
dataForEvent = new TextDecoder("utf-8", { fatal: true }).decode(data);
} catch {
failWebsocketConnection(ws, "Received invalid UTF-8 in text frame.");
return;
}
} else if (type === opcodes.BINARY) {
if (ws[kBinaryType] === "blob") {
dataForEvent = new Blob([data]);
} else {
dataForEvent = new Uint8Array(data).buffer;
}
}
fireEvent("message", ws, MessageEvent, {
origin: ws[kWebSocketURL].origin,
data: dataForEvent
});
}
__name(websocketMessageReceived, "websocketMessageReceived");
function isValidSubprotocol(protocol) {
if (protocol.length === 0) {
return false;
}
for (const char of protocol) {
const code = char.charCodeAt(0);
if (code < 33 || code > 126 || char === "(" || char === ")" || char === "<" || char === ">" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}" || code === 32 || // SP
code === 9) {
return false;
}
}
return true;
}
__name(isValidSubprotocol, "isValidSubprotocol");
function isValidStatusCode(code) {
if (code >= 1e3 && code < 1015) {
return code !== 1004 && // reserved
code !== 1005 && // "MUST NOT be set as a status code"
code !== 1006;
}
return code >= 3e3 && code <= 4999;
}
__name(isValidStatusCode, "isValidStatusCode");
function failWebsocketConnection(ws, reason) {
const { [kController]: controller, [kResponse]: response } = ws;
controller.abort();
if (response?.socket && !response.socket.destroyed) {
response.socket.destroy();
}
if (reason) {
fireEvent("error", ws, ErrorEvent, {
error: new Error(reason)
});
}
}
__name(failWebsocketConnection, "failWebsocketConnection");
module2.exports = {
isEstablished,
isClosing,
isClosed,
fireEvent,
isValidSubprotocol,
isValidStatusCode,
failWebsocketConnection,
websocketMessageReceived
};
}
});
// lib/websocket/connection.js
var require_connection = __commonJS({
"lib/websocket/connection.js"(exports2, module2) {
"use strict";
var { uid, states } = require_constants4();
var {
kReadyState,
kSentClose,
kByteParser,
kReceivedClose
} = require_symbols3();
var { fireEvent, failWebsocketConnection } = require_util3();
var { channels } = require_diagnostics();
var { CloseEvent } = require_events();
var { makeRequest } = require_request();
var { fetching } = require_fetch();
var { Headers } = require_headers();
var { getGlobalDispatcher } = require_global2();
var { kHeadersList } = require_symbols();
var crypto;
try {
crypto = require("node:crypto");
} catch {
}
function establishWebSocketConnection(url, protocols, ws, onEstablish, options) {
const requestURL = url;
requestURL.protocol = url.protocol === "ws:" ? "http:" : "https:";
const request = makeRequest({
urlList: [requestURL],
serviceWorkers: "none",
referrer: "no-referrer",
mode: "websocket",
credentials: "include",
cache: "no-store",
redirect: "error"
});
if (options.headers) {
const headersList = new Headers(options.headers)[kHeadersList];
request.headersList = headersList;
}
const keyValue = crypto.randomBytes(16).toString("base64");
request.headersList.append("sec-websocket-key", keyValue);
request.headersList.append("sec-websocket-version", "13");
for (const protocol of protocols) {
request.headersList.append("sec-websocket-protocol", protocol);
}
const permessageDeflate = "";
const controller = fetching({
request,
useParallelQueue: true,
dispatcher: options.dispatcher ?? getGlobalDispatcher(),
processResponse(response) {
if (response.type === "error" || response.status !== 101) {
failWebsocketConnection(ws, "Received network error or non-101 status code.");
return;
}
if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) {
failWebsocketConnection(ws, "Server did not respond with sent protocols.");
return;
}
if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") {
failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".');
return;
}
if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") {
failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".');
return;
}
const secWSAccept = response.headersList.get("Sec-WebSocket-Accept");
const digest = crypto.createHash("sha1").update(keyValue + uid).digest("base64");
if (secWSAccept !== digest) {
failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header.");
return;
}
const secExtension = response.headersList.get("Sec-WebSocket-Extensions");
if (secExtension !== null && secExtension !== permessageDeflate) {
failWebsocketConnection(ws, "Received different permessage-deflate than the one set.");
return;
}
const secProtocol = response.headersList.get("Sec-WebSocket-Protocol");
if (secProtocol !== null && secProtocol !== request.headersList.get("Sec-WebSocket-Protocol")) {
failWebsocketConnection(ws, "Protocol was not set in the opening handshake.");
return;
}
response.socket.on("data", onSocketData);
response.socket.on("close", onSocketClose);
response.socket.on("error", onSocketError);
if (channels.open.hasSubscribers) {
channels.open.publish({
address: response.socket.address(),
protocol: secProtocol,
extensions: secExtension
});
}
onEstablish(response);
}
});
return controller;
}
__name(establishWebSocketConnection, "establishWebSocketConnection");
function onSocketData(chunk) {
if (!this.ws[kByteParser].write(chunk)) {
this.pause();
}
}
__name(onSocketData, "onSocketData");
function onSocketClose() {
const { ws } = this;
const wasClean = ws[kSentClose] && ws[kReceivedClose];
let code = 1005;
let reason = "";
const result = ws[kByteParser].closingInfo;
if (result) {
code = result.code ?? 1005;
reason = result.reason;
} else if (!ws[kSentClose]) {
code = 1006;
}
ws[kReadyState] = states.CLOSED;
fireEvent("close", ws, CloseEvent, {
wasClean,
code,
reason
});
if (channels.close.hasSubscribers) {
channels.close.publish({
websocket: ws,
code,
reason
});
}
}
__name(onSocketClose, "onSocketClose");
function onSocketError(error) {
const { ws } = this;
ws[kReadyState] = states.CLOSING;
if (channels.socketError.hasSubscribers) {
channels.socketError.publish(error);
}
this.destroy();
}
__name(onSocketError, "onSocketError");
module2.exports = {
establishWebSocketConnection
};
}
});
// lib/websocket/frame.js
var require_frame = __commonJS({
"lib/websocket/frame.js"(exports2, module2) {
"use strict";
var { maxUnsigned16Bit } = require_constants4();
var crypto;
try {
crypto = require("node:crypto");
} catch {
}
var WebsocketFrameSend = class {
static {
__name(this, "WebsocketFrameSend");
}
/**
* @param {Buffer|undefined} data
*/
constructor(data) {
this.frameData = data;
this.maskKey = crypto.randomBytes(4);
}
createFrame(opcode) {
const bodyLength = this.frameData?.byteLength ?? 0;
let payloadLength = bodyLength;
let offset = 6;
if (bodyLength > maxUnsigned16Bit) {
offset += 8;
payloadLength = 127;
} else if (bodyLength > 125) {
offset += 2;
payloadLength = 126;
}
const buffer = Buffer.allocUnsafe(bodyLength + offset);
buffer[0] = buffer[1] = 0;
buffer[0] |= 128;
buffer[0] = (buffer[0] & 240) + opcode;
buffer[offset - 4] = this.maskKey[0];
buffer[offset - 3] = this.maskKey[1];
buffer[offset - 2] = this.maskKey[2];
buffer[offset - 1] = this.maskKey[3];
buffer[1] = payloadLength;
if (payloadLength === 126) {
buffer.writeUInt16BE(bodyLength, 2);
} else if (payloadLength === 127) {
buffer[2] = buffer[3] = 0;
buffer.writeUIntBE(bodyLength, 4, 6);
}
buffer[1] |= 128;
for (let i = 0; i < bodyLength; i++) {
buffer[offset + i] = this.frameData[i] ^ this.maskKey[i % 4];
}
return buffer;
}
};
module2.exports = {
WebsocketFrameSend
};
}
});
// lib/websocket/receiver.js
var require_receiver = __commonJS({
"lib/websocket/receiver.js"(exports2, module2) {
"use strict";
var { Writable } = require("node:stream");
var { parserStates, opcodes, states, emptyBuffer } = require_constants4();
var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols3();
var { channels } = require_diagnostics();
var { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require_util3();
var { WebsocketFrameSend } = require_frame();
var ByteParser = class extends Writable {
static {
__name(this, "ByteParser");
}
#buffers = [];
#byteOffset = 0;
#state = parserStates.INFO;
#info = {};
#fragments = [];
constructor(ws) {
super();
this.ws = ws;
}
/**
* @param {Buffer} chunk
* @param {() => void} callback
*/
_write(chunk, _, callback) {
this.#buffers.push(chunk);
this.#byteOffset += chunk.length;
this.run(callback);
}
/**
* Runs whenever a new chunk is received.
* Callback is called whenever there are no more chunks buffering,
* or not enough bytes are buffered to parse.
*/
run(callback) {
while (true) {
if (this.#state === parserStates.INFO) {
if (this.#byteOffset < 2) {
return callback();
}
const buffer = this.consume(2);
this.#info.fin = (buffer[0] & 128) !== 0;
this.#info.opcode = buffer[0] & 15;
this.#info.originalOpcode ??= this.#info.opcode;
this.#info.fragmented = !this.#info.fin && this.#info.opcode !== opcodes.CONTINUATION;
if (this.#info.fragmented && this.#info.opcode !== opcodes.BINARY && this.#info.opcode !== opcodes.TEXT) {
failWebsocketConnection(this.ws, "Invalid frame type was fragmented.");
return;
}
const payloadLength = buffer[1] & 127;
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 (this.#info.fragmented && payloadLength > 125) {
failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes.");
return;
} else if ((this.#info.opcode === opcodes.PING || this.#info.opcode === opcodes.PONG || this.#info.opcode === opcodes.CLOSE) && payloadLength > 125) {
failWebsocketConnection(this.ws, "Payload length for control frame exceeded 125 bytes.");
return;
} else if (this.#info.opcode === opcodes.CLOSE) {
if (payloadLength === 1) {
failWebsocketConnection(this.ws, "Received close frame with a 1-byte body.");
return;
}
const body = this.consume(payloadLength);
this.#info.closeInfo = this.parseCloseBody(false, body);
if (!this.ws[kSentClose]) {
let body2 = emptyBuffer;
if (this.#info.closeInfo.code) {
body2 = Buffer.allocUnsafe(2);
body2.writeUInt16BE(this.#info.closeInfo.code, 0);
}
const closeFrame = new WebsocketFrameSend(body2);
this.ws[kResponse].socket.write(
closeFrame.createFrame(opcodes.CLOSE),
(err) => {
if (!err) {
this.ws[kSentClose] = true;
}
}
);
}
this.ws[kReadyState] = states.CLOSING;
this.ws[kReceivedClose] = true;
this.end();
return;
} else if (this.#info.opcode === opcodes.PING) {
const body = this.consume(payloadLength);
if (!this.ws[kReceivedClose]) {
const frame = new WebsocketFrameSend(body);
this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG));
if (channels.ping.hasSubscribers) {
channels.ping.publish({
payload: body
});
}
}
this.#state = parserStates.INFO;
if (this.#byteOffset > 0) {
continue;
} else {
callback();
return;
}
} else if (this.#info.opcode === opcodes.PONG) {
const body = this.consume(payloadLength);
if (channels.pong.hasSubscribers) {
channels.pong.publish({
payload: body
});
}
if (this.#byteOffset > 0) {
continue;
} else {
callback();
return;
}
}
} else if (this.#state === parserStates.PAYLOADLENGTH_16) {
if (this.#byteOffset < 2) {
return callback();
}
const 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();
}
const buffer = this.consume(8);
const upper = buffer.readUInt32BE(0);
if (upper > 2 ** 31 - 1) {
failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes.");
return;
}
const 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();
} else if (this.#byteOffset >= this.#info.payloadLength) {
const body = this.consume(this.#info.payloadLength);
this.#fragments.push(body);
if (!this.#info.fragmented || this.#info.fin && this.#info.opcode === opcodes.CONTINUATION) {
const fullMessage = Buffer.concat(this.#fragments);
websocketMessageReceived(this.ws, this.#info.originalOpcode, fullMessage);
this.#info = {};
this.#fragments.length = 0;
}
this.#state = parserStates.INFO;
}
}
if (this.#byteOffset === 0) {
callback();
break;
}
}
}
/**
* Take n bytes from the buffered Buffers
* @param {number} n
* @returns {Buffer|null}
*/
consume(n) {
if (n > this.#byteOffset) {
return null;
} else if (n === 0) {
return emptyBuffer;
}
if (this.#buffers[0].length === n) {
this.#byteOffset -= this.#buffers[0].length;
return this.#buffers.shift();
}
const buffer = Buffer.allocUnsafe(n);
let offset = 0;
while (offset !== n) {
const next = this.#buffers[0];
const { length } = next;
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 += next.length;
}
}
this.#byteOffset -= n;
return buffer;
}
parseCloseBody(onlyCode, data) {
let code;
if (data.length >= 2) {
code = data.readUInt16BE(0);
}
if (onlyCode) {
if (!isValidStatusCode(code)) {
return null;
}
return { code };
}
let reason = data.subarray(2);
if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) {
reason = reason.subarray(3);
}
if (code !== void 0 && !isValidStatusCode(code)) {
return null;
}
try {
reason = new TextDecoder("utf-8", { fatal: true }).decode(reason);
} catch {
return null;
}
return { code, reason };
}
get closingInfo() {
return this.#info.closeInfo;
}
};
module2.exports = {
ByteParser
};
}
});
// lib/websocket/websocket.js
var require_websocket = __commonJS({
"lib/websocket/websocket.js"(exports2, module2) {
"use strict";
var { webidl } = require_webidl();
var { URLSerializer } = require_dataURL();
var { getGlobalOrigin } = require_global();
var { staticPropertyDescriptors, states, opcodes, emptyBuffer } = require_constants4();
var {
kWebSocketURL,
kReadyState,
kController,
kBinaryType,
kResponse,
kSentClose,
kByteParser
} = require_symbols3();
var { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = require_util3();
var { establishWebSocketConnection } = require_connection();
var { WebsocketFrameSend } = require_frame();
var { ByteParser } = require_receiver();
var { kEnumerableProperty, isBlobLike } = require_util();
var { getGlobalDispatcher } = require_global2();
var { types } = require("node:util");
var experimentalWarned = false;
var WebSocket = class _WebSocket extends EventTarget {
static {
__name(this, "WebSocket");
}
#events = {
open: null,
error: null,
close: null,
message: null
};
#bufferedAmount = 0;
#protocol = "";
#extensions = "";
/**
* @param {string} url
* @param {string|string[]} protocols
*/
constructor(url, protocols = []) {
super();
webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket constructor" });
if (!experimentalWarned) {
experimentalWarned = true;
process.emitWarning("WebSockets are experimental, expect them to change at any time.", {
code: "UNDICI-WS"
});
}
const options = webidl.converters["DOMString or sequence<DOMString> or WebSocketInit"](protocols);
url = webidl.converters.USVString(url);
protocols = options.protocols;
const baseURL = getGlobalOrigin();
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: protocol, got ${urlRecord.protocol}`,
"SyntaxError"
);
}
if (urlRecord.hash || urlRecord.href.endsWith("#")) {
throw new DOMException("Got fragment", "SyntaxError");
}
if (typeof protocols === "string") {
protocols = [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");
}
this[kWebSocketURL] = new URL(urlRecord.href);
this[kController] = establishWebSocketConnection(
urlRecord,
protocols,
this,
(response) => this.#onConnectionEstablished(response),
options
);
this[kReadyState] = _WebSocket.CONNECTING;
this[kBinaryType] = "blob";
}
/**
* @see https://websockets.spec.whatwg.org/#dom-websocket-close
* @param {number|undefined} code
* @param {string|undefined} reason
*/
close(code = void 0, reason = void 0) {
webidl.brandCheck(this, _WebSocket);
if (code !== void 0) {
code = webidl.converters["unsigned short"](code, { clamp: true });
}
if (reason !== void 0) {
reason = webidl.converters.USVString(reason);
}
if (code !== void 0) {
if (code !== 1e3 && (code < 3e3 || code > 4999)) {
throw new DOMException("invalid code", "InvalidAccessError");
}
}
let reasonByteLength = 0;
if (reason !== void 0) {
reasonByteLength = Buffer.byteLength(reason);
if (reasonByteLength > 123) {
throw new DOMException(
`Reason must be less than 123 bytes; received ${reasonByteLength}`,
"SyntaxError"
);
}
}
if (this[kReadyState] === _WebSocket.CLOSING || this[kReadyState] === _WebSocket.CLOSED) {
} else if (!isEstablished(this)) {
failWebsocketConnection(this, "Connection was closed before it was established.");
this[kReadyState] = _WebSocket.CLOSING;
} else if (!isClosing(this)) {
const frame = new WebsocketFrameSend();
if (code !== void 0 && reason === void 0) {
frame.frameData = Buffer.allocUnsafe(2);
frame.frameData.writeUInt16BE(code, 0);
} else if (code !== void 0 && reason !== void 0) {
frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength);
frame.frameData.writeUInt16BE(code, 0);
frame.frameData.write(reason, 2, "utf-8");
} else {
frame.frameData = emptyBuffer;
}
const socket = this[kResponse].socket;
socket.write(frame.createFrame(opcodes.CLOSE), (err) => {
if (!err) {
this[kSentClose] = true;
}
});
this[kReadyState] = states.CLOSING;
} else {
this[kReadyState] = _WebSocket.CLOSING;
}
}
/**
* @see https://websockets.spec.whatwg.org/#dom-websocket-send
* @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data
*/
send(data) {
webidl.brandCheck(this, _WebSocket);
webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket.send" });
data = webidl.converters.WebSocketSendData(data);
if (this[kReadyState] === _WebSocket.CONNECTING) {
throw new DOMException("Sent before connected.", "InvalidStateError");
}
if (!isEstablished(this) || isClosing(this)) {
return;
}
const socket = this[kResponse].socket;
if (typeof data === "string") {
const value = Buffer.from(data);
const frame = new WebsocketFrameSend(value);
const buffer = frame.createFrame(opcodes.TEXT);
this.#bufferedAmount += value.byteLength;
socket.write(buffer, () => {
this.#bufferedAmount -= value.byteLength;
});
} else if (types.isArrayBuffer(data)) {
const value = Buffer.from(data);
const frame = new WebsocketFrameSend(value);
const buffer = frame.createFrame(opcodes.BINARY);
this.#bufferedAmount += value.byteLength;
socket.write(buffer, () => {
this.#bufferedAmount -= value.byteLength;
});
} else if (ArrayBuffer.isView(data)) {
const ab = Buffer.from(data, data.byteOffset, data.byteLength);
const frame = new WebsocketFrameSend(ab);
const buffer = frame.createFrame(opcodes.BINARY);
this.#bufferedAmount += ab.byteLength;
socket.write(buffer, () => {
this.#bufferedAmount -= ab.byteLength;
});
} else if (isBlobLike(data)) {
const frame = new WebsocketFrameSend();
data.arrayBuffer().then((ab) => {
const value = Buffer.from(ab);
frame.frameData = value;
const buffer = frame.createFrame(opcodes.BINARY);
this.#bufferedAmount += value.byteLength;
socket.write(buffer, () => {
this.#bufferedAmount -= value.byteLength;
});
});
}
}
get readyState() {
webidl.brandCheck(this, _WebSocket);
return this[kReadyState];
}
get bufferedAmount() {
webidl.brandCheck(this, _WebSocket);
return this.#bufferedAmount;
}
get url() {
webidl.brandCheck(this, _WebSocket);
return URLSerializer(this[kWebSocketURL]);
}
get extensions() {
webidl.brandCheck(this, _WebSocket);
return this.#extensions;
}
get protocol() {
webidl.brandCheck(this, _WebSocket);
return this.#protocol;
}
get onopen() {
webidl.brandCheck(this, _WebSocket);
return this.#events.open;
}
set onopen(fn) {
webidl.brandCheck(this, _WebSocket);
if (this.#events.open) {
this.removeEventListener("open", this.#events.open);
}
if (typeof fn === "function") {
this.#events.open = fn;
this.addEventListener("open", fn);
} else {
this.#events.open = null;
}
}
get onerror() {
webidl.brandCheck(this, _WebSocket);
return this.#events.error;
}
set onerror(fn) {
webidl.brandCheck(this, _WebSocket);
if (this.#events.error) {
this.removeEventListener("error", this.#events.error);
}
if (typeof fn === "function") {
this.#events.error = fn;
this.addEventListener("error", fn);
} else {
this.#events.error = null;
}
}
get onclose() {
webidl.brandCheck(this, _WebSocket);
return this.#events.close;
}
set onclose(fn) {
webidl.brandCheck(this, _WebSocket);
if (this.#events.close) {
this.removeEventListener("close", this.#events.close);
}
if (typeof fn === "function") {
this.#events.close = fn;
this.addEventListener("close", fn);
} else {
this.#events.close = null;
}
}
get onmessage() {
webidl.brandCheck(this, _WebSocket);
return this.#events.message;
}
set onmessage(fn) {
webidl.brandCheck(this, _WebSocket);
if (this.#events.message) {
this.removeEventListener("message", this.#events.message);
}
if (typeof fn === "function") {
this.#events.message = fn;
this.addEventListener("message", fn);
} else {
this.#events.message = null;
}
}
get binaryType() {
webidl.brandCheck(this, _WebSocket);
return this[kBinaryType];
}
set binaryType(type) {
webidl.brandCheck(this, _WebSocket);
if (type !== "blob" && type !== "arraybuffer") {
this[kBinaryType] = "blob";
} else {
this[kBinaryType] = type;
}
}
/**
* @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
*/
#onConnectionEstablished(response) {
this[kResponse] = response;
const parser = new ByteParser(this);
parser.on("drain", /* @__PURE__ */ __name(function onParserDrain() {
this.ws[kResponse].socket.resume();
}, "onParserDrain"));
response.socket.ws = this;
this[kByteParser] = parser;
this[kReadyState] = states.OPEN;
const extensions = response.headersList.get("sec-websocket-extensions");
if (extensions !== null) {
this.#extensions = extensions;
}
const protocol = response.headersList.get("sec-websocket-protocol");
if (protocol !== null) {
this.#protocol = protocol;
}
fireEvent("open", this);
}
};
WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING;
WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN;
WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING;
WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED;
Object.defineProperties(WebSocket.prototype, {
CONNECTING: staticPropertyDescriptors,
OPEN: staticPropertyDescriptors,
CLOSING: staticPropertyDescriptors,
CLOSED: staticPropertyDescriptors,
url: kEnumerableProperty,
readyState: kEnumerableProperty,
bufferedAmount: kEnumerableProperty,
onopen: kEnumerableProperty,
onerror: kEnumerableProperty,
onclose: kEnumerableProperty,
close: kEnumerableProperty,
onmessage: kEnumerableProperty,
binaryType: kEnumerableProperty,
send: kEnumerableProperty,
extensions: kEnumerableProperty,
protocol: kEnumerableProperty,
[Symbol.toStringTag]: {
value: "WebSocket",
writable: false,
enumerable: false,
configurable: true
}
});
Object.defineProperties(WebSocket, {
CONNECTING: staticPropertyDescriptors,
OPEN: staticPropertyDescriptors,
CLOSING: staticPropertyDescriptors,
CLOSED: staticPropertyDescriptors
});
webidl.converters["sequence<DOMString>"] = webidl.sequenceConverter(
webidl.converters.DOMString
);
webidl.converters["DOMString or sequence<DOMString>"] = function(V) {
if (webidl.util.Type(V) === "Object" && Symbol.iterator in V) {
return webidl.converters["sequence<DOMString>"](V);
}
return webidl.converters.DOMString(V);
};
webidl.converters.WebSocketInit = webidl.dictionaryConverter([
{
key: "protocols",
converter: webidl.converters["DOMString or sequence<DOMString>"],
get defaultValue() {
return [];
}
},
{
key: "dispatcher",
converter: (V) => V,
get defaultValue() {
return getGlobalDispatcher();
}
},
{
key: "headers",
converter: webidl.nullableConverter(webidl.converters.HeadersInit)
}
]);
webidl.converters["DOMString or sequence<DOMString> or WebSocketInit"] = function(V) {
if (webidl.util.Type(V) === "Object" && !(Symbol.iterator in V)) {
return webidl.converters.WebSocketInit(V);
}
return { protocols: webidl.converters["DOMString or sequence<DOMString>"](V) };
};
webidl.converters.WebSocketSendData = function(V) {
if (webidl.util.Type(V) === "Object") {
if (isBlobLike(V)) {
return webidl.converters.Blob(V, { strict: false });
}
if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
return webidl.converters.BufferSource(V);
}
}
return webidl.converters.USVString(V);
};
module2.exports = {
WebSocket
};
}
});
// lib/eventsource/util.js
var require_util4 = __commonJS({
"lib/eventsource/util.js"(exports2, module2) {
"use strict";
function isValidLastEventId(value) {
return value.indexOf("\0") === -1;
}
__name(isValidLastEventId, "isValidLastEventId");
function isASCIINumber(value) {
if (value.length === 0)
return false;
for (let i = 0; i < value.length; i++) {
if (value.charCodeAt(i) < 48 || value.charCodeAt(i) > 57)
return false;
}
return true;
}
__name(isASCIINumber, "isASCIINumber");
function delay(ms) {
return new Promise((resolve) => {
setTimeout(resolve, ms).unref();
});
}
__name(delay, "delay");
module2.exports = {
isValidLastEventId,
isASCIINumber,
delay
};
}
});
// lib/eventsource/eventsource-stream.js
var require_eventsource_stream = __commonJS({
"lib/eventsource/eventsource-stream.js"(exports2, module2) {
"use strict";
var { Transform } = require("node:stream");
var { isASCIINumber, isValidLastEventId } = require_util4();
var BOM = [239, 187, 191];
var LF = 10;
var CR = 13;
var COLON = 58;
var SPACE = 32;
var EventSourceStream = class extends Transform {
static {
__name(this, "EventSourceStream");
}
/**
* @type {eventSourceSettings}
*/
state = null;
/**
* Leading byte-order-mark check.
* @type {boolean}
*/
checkBOM = true;
/**
* @type {boolean}
*/
crlfCheck = false;
/**
* @type {boolean}
*/
eventEndCheck = false;
/**
* @type {Buffer}
*/
buffer = null;
pos = 0;
event = {
data: void 0,
event: void 0,
id: void 0,
retry: void 0
};
/**
* @param {object} options
* @param {eventSourceSettings} options.eventSourceSettings
* @param {Function} [options.push]
*/
constructor(options = {}) {
options.readableObjectMode = true;
super(options);
this.state = options.eventSourceSettings || {};
if (options.push) {
this.push = options.push;
}
}
/**
* @param {Buffer} chunk
* @param {string} _encoding
* @param {Function} callback
* @returns {void}
*/
_transform(chunk, _encoding, callback) {
if (chunk.length === 0) {
callback();
return;
}
if (this.buffer) {
this.buffer = Buffer.concat([this.buffer, chunk]);
} else {
this.buffer = chunk;
}
if (this.checkBOM) {
switch (this.buffer.length) {
case 1:
if (this.buffer[0] === BOM[0]) {
callback();
return;
}
this.checkBOM = false;
callback();
return;
case 2:
if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1]) {
callback();
return;
}
this.checkBOM = false;
break;
case 3:
if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1] && this.buffer[2] === BOM[2]) {
this.buffer = Buffer.alloc(0);
this.checkBOM = false;
callback();
return;
}
this.checkBOM = false;
break;
default:
if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1] && this.buffer[2] === BOM[2]) {
this.buffer = this.buffer.subarray(3);
}
this.checkBOM = false;
break;
}
}
while (this.pos < this.buffer.length) {
if (this.eventEndCheck) {
if (this.crlfCheck) {
if (this.buffer[this.pos] === LF) {
this.buffer = this.buffer.subarray(this.pos + 1);
this.pos = 0;
this.crlfCheck = false;
continue;
}
this.crlfCheck = false;
}
if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
if (this.buffer[this.pos] === CR) {
this.crlfCheck = true;
}
this.buffer = this.buffer.subarray(this.pos + 1);
this.pos = 0;
if (this.event.data !== void 0 || this.event.event || this.event.id || this.event.retry) {
this.processEvent(this.event);
}
this.clearEvent();
continue;
}
this.eventEndCheck = false;
continue;
}
if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
if (this.buffer[this.pos] === CR) {
this.crlfCheck = true;
}
this.parseLine(this.buffer.subarray(0, this.pos), this.event);
this.buffer = this.buffer.subarray(this.pos + 1);
this.pos = 0;
this.eventEndCheck = true;
continue;
}
this.pos++;
}
callback();
}
/**
* @param {Buffer} line
* @param {EventStreamEvent} event
*/
parseLine(line, event) {
if (line.length === 0) {
return;
}
const colonPosition = line.indexOf(COLON);
if (colonPosition === 0) {
return;
}
let field = "";
let value = "";
if (colonPosition !== -1) {
field = line.subarray(0, colonPosition).toString("utf8");
let valueStart = colonPosition + 1;
if (line[valueStart] === SPACE) {
++valueStart;
}
value = line.subarray(valueStart).toString("utf8");
} else {
field = line.toString("utf8");
value = "";
}
switch (field) {
case "data":
if (event[field] === void 0) {
event[field] = value;
} else {
event[field] += `
${value}`;
}
break;
case "retry":
if (isASCIINumber(value)) {
event[field] = value;
}
break;
case "id":
if (isValidLastEventId(value)) {
event[field] = value;
}
break;
case "event":
if (value.length > 0) {
event[field] = value;
}
break;
}
}
/**
* @param {EventSourceStreamEvent} event
*/
processEvent(event) {
if (event.retry && isASCIINumber(event.retry)) {
this.state.reconnectionTime = parseInt(event.retry, 10);
}
if (event.id && isValidLastEventId(event.id)) {
this.state.lastEventId = event.id;
}
if (event.data !== void 0) {
this.push({
type: event.event || "message",
options: {
data: event.data,
lastEventId: this.state.lastEventId,
origin: this.state.origin
}
});
}
}
clearEvent() {
this.event = {
data: void 0,
event: void 0,
id: void 0,
retry: void 0
};
}
};
module2.exports = {
EventSourceStream
};
}
});
// lib/eventsource/eventsource.js
var require_eventsource = __commonJS({
"lib/eventsource/eventsource.js"(exports2, module2) {
"use strict";
var { pipeline } = require("node:stream");
var { fetching } = require_fetch();
var { makeRequest } = require_request();
var { getGlobalOrigin } = require_global();
var { webidl } = require_webidl();
var { EventSourceStream } = require_eventsource_stream();
var { parseMIMEType } = require_dataURL();
var { MessageEvent } = require_events();
var { isNetworkError } = require_response();
var { getGlobalDispatcher } = require_global2();
var { delay } = require_util4();
var experimentalWarned = false;
var defaultReconnectionTime = 3e3;
var CONNECTING = 0;
var OPEN = 1;
var CLOSED = 2;
var ANONYMOUS = "anonymous";
var USE_CREDENTIALS = "use-credentials";
var EventSource = class _EventSource extends EventTarget {
static {
__name(this, "EventSource");
}
#events = {
open: null,
error: null,
message: null
};
#url = null;
#withCredentials = false;
#readyState = CONNECTING;
#request = null;
#controller = null;
/**
* @type {object}
* @property {string} lastEventId
* @property {number} reconnectionTime
* @property {any} reconnectionTimer
*/
#settings = null;
/**
* Creates a new EventSource object.
* @param {string} url
* @param {EventSourceInit} [eventSourceInitDict]
* @see https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface
*/
constructor(url, eventSourceInitDict = {}) {
super();
webidl.argumentLengthCheck(arguments, 1, { header: "EventSource constructor" });
if (!experimentalWarned) {
experimentalWarned = true;
process.emitWarning("EventSource is experimental, expect them to change at any time.", {
code: "UNDICI-ES"
});
}
url = webidl.converters.USVString(url);
eventSourceInitDict = webidl.converters.EventSourceInitDict(eventSourceInitDict);
this.#settings = {
origin: getGlobalOrigin(),
policyContainer: {
referrerPolicy: "no-referrer"
},
lastEventId: "",
reconnectionTime: defaultReconnectionTime
};
let urlRecord;
try {
urlRecord = new URL(url, this.#settings.origin);
this.#settings.origin = urlRecord.origin;
} catch (e) {
throw new DOMException(e, "SyntaxError");
}
this.#url = urlRecord.href;
let corsAttributeState = ANONYMOUS;
if (eventSourceInitDict.withCredentials) {
corsAttributeState = USE_CREDENTIALS;
this.#withCredentials = true;
}
const initRequest = {
redirect: "follow",
keepalive: true,
// @see https://html.spec.whatwg.org/multipage/urls-and-fetching.html#cors-settings-attributes
mode: "cors",
credentials: corsAttributeState === "anonymous" ? "same-origin" : "omit",
referrer: "no-referrer"
};
initRequest.client = this.#settings;
initRequest.headersList = [["accept", { name: "accept", value: "text/event-stream" }]];
initRequest.cache = "no-store";
initRequest.initiator = "other";
initRequest.urlList = [new URL(this.#url)];
this.#request = makeRequest(initRequest);
this.#connect();
}
/**
* Returns the state of this EventSource object's connection. It can have the
* values described below.
* @returns {0|1|2}
* @readonly
*/
get readyState() {
return this.#readyState;
}
/**
* Returns the URL providing the event stream.
* @readonly
* @returns {string}
*/
get url() {
return this.#url;
}
/**
* Returns a boolean indicating whether the EventSource object was
* instantiated with CORS credentials set (true), or not (false, the default).
*/
get withCredentials() {
return this.#withCredentials;
}
#connect() {
if (this.#readyState === CLOSED)
return;
this.#readyState = CONNECTING;
const fetchParam = {
request: this.#request
};
const processEventSourceEndOfBody = /* @__PURE__ */ __name((response) => {
if (isNetworkError(response)) {
this.dispatchEvent(new Event("error"));
this.close();
}
this.#reconnect();
}, "processEventSourceEndOfBody");
fetchParam.processResponseEndOfBody = processEventSourceEndOfBody;
fetchParam.processResponse = (response) => {
if (isNetworkError(response)) {
if (response.aborted) {
this.close();
this.dispatchEvent(new Event("error"));
return;
} else {
this.#reconnect();
return;
}
}
const contentType = response.headersList.get("content-type", true);
const mimeType = contentType !== null ? parseMIMEType(contentType) : "failure";
const contentTypeValid = mimeType !== "failure" && mimeType.essence === "text/event-stream";
if (response.status !== 200 || contentTypeValid === false) {
this.close();
this.dispatchEvent(new Event("error"));
return;
}
this.#readyState = OPEN;
this.dispatchEvent(new Event("open"));
this.#settings.origin = response.urlList[response.urlList.length - 1].origin;
const eventSourceStream = new EventSourceStream({
eventSourceSettings: this.#settings,
push: (event) => {
this.dispatchEvent(new MessageEvent(
event.type,
event.options
));
}
});
pipeline(
response.body.stream,
eventSourceStream,
(error) => {
if (error?.aborted === false) {
this.close();
this.dispatchEvent(new Event("error"));
}
}
);
};
this.#controller = fetching({
...fetchParam,
dispatcher: getGlobalDispatcher()
});
}
/**
* @see https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model
* @returns {Promise<void>}
*/
async #reconnect() {
if (this.#readyState === CLOSED)
return;
this.#readyState = CONNECTING;
this.dispatchEvent(new Event("error"));
await delay(this.#settings.reconnectionTime);
if (this.#readyState !== CONNECTING)
return;
if (this.#settings.lastEventId !== "") {
this.#request.headersList.set("last-event-id", this.#settings.lastEventId, true);
}
this.#connect();
}
/**
* Closes the connection, if any, and sets the readyState attribute to
* CLOSED.
*/
close() {
webidl.brandCheck(this, _EventSource);
if (this.#readyState === CLOSED)
return;
this.#readyState = CLOSED;
clearTimeout(this.#settings.reconnectionTimer);
this.#controller.abort();
if (this.#request) {
this.#request = null;
}
}
get onopen() {
return this.#events.open;
}
set onopen(fn) {
if (this.#events.open) {
this.removeEventListener("open", this.#events.open);
}
if (typeof fn === "function") {
this.#events.open = fn;
this.addEventListener("open", fn);
} else {
this.#events.open = null;
}
}
get onmessage() {
return this.#events.message;
}
set onmessage(fn) {
if (this.#events.message) {
this.removeEventListener("message", this.#events.message);
}
if (typeof fn === "function") {
this.#events.message = fn;
this.addEventListener("message", fn);
} else {
this.#events.message = null;
}
}
get onerror() {
return this.#events.error;
}
set onerror(fn) {
if (this.#events.error) {
this.removeEventListener("error", this.#events.error);
}
if (typeof fn === "function") {
this.#events.error = fn;
this.addEventListener("error", fn);
} else {
this.#events.error = null;
}
}
};
var constantsPropertyDescriptors = {
CONNECTING: {
__proto__: null,
configurable: false,
enumerable: true,
value: CONNECTING,
writable: false
},
OPEN: {
__proto__: null,
configurable: false,
enumerable: true,
value: OPEN,
writable: false
},
CLOSED: {
__proto__: null,
configurable: false,
enumerable: true,
value: CLOSED,
writable: false
}
};
Object.defineProperties(EventSource, constantsPropertyDescriptors);
Object.defineProperties(EventSource.prototype, constantsPropertyDescriptors);
webidl.converters.EventSourceInitDict = webidl.dictionaryConverter([
{ key: "withCredentials", converter: webidl.converters.boolean, defaultValue: false }
]);
module2.exports = {
EventSource,
defaultReconnectionTime
};
}
});
// index-fetch.js
var fetchImpl = require_fetch().fetch;
module.exports.fetch = /* @__PURE__ */ __name(function fetch(resource, init = void 0) {
return fetchImpl(resource, init).catch((err) => {
if (typeof err === "object") {
Error.captureStackTrace(err, this);
}
throw err;
});
}, "fetch");
module.exports.FormData = require_formdata().FormData;
module.exports.Headers = require_headers().Headers;
module.exports.Response = require_response().Response;
module.exports.Request = require_request().Request;
module.exports.WebSocket = require_websocket().WebSocket;
module.exports.EventSource = require_eventsource().EventSource;
/*! Bundled license information:
undici/lib/fetch/body.js:
(*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)
undici/lib/websocket/frame.js:
(*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
*/
Zerion Mini Shell 1.0