"use strict";
var __getOwnPropNames = Object.getOwnPropertyNames;
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("pipelinig"),
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")
};
}
});
// 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"),
kHeadersCaseInsensitive: Symbol("headers case insensitive")
};
}
});
// lib/core/errors.js
var require_errors = __commonJS({
"lib/core/errors.js"(exports2, module2) {
"use strict";
var UndiciError = class extends Error {
constructor(message) {
super(message);
this.name = "UndiciError";
this.code = "UND_ERR";
}
};
var ConnectTimeoutError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, ConnectTimeoutError);
this.name = "ConnectTimeoutError";
this.message = message || "Connect Timeout Error";
this.code = "UND_ERR_CONNECT_TIMEOUT";
}
};
var HeadersTimeoutError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, HeadersTimeoutError);
this.name = "HeadersTimeoutError";
this.message = message || "Headers Timeout Error";
this.code = "UND_ERR_HEADERS_TIMEOUT";
}
};
var HeadersOverflowError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, HeadersOverflowError);
this.name = "HeadersOverflowError";
this.message = message || "Headers Overflow Error";
this.code = "UND_ERR_HEADERS_OVERFLOW";
}
};
var BodyTimeoutError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, BodyTimeoutError);
this.name = "BodyTimeoutError";
this.message = message || "Body Timeout Error";
this.code = "UND_ERR_BODY_TIMEOUT";
}
};
var ResponseStatusCodeError = class extends UndiciError {
constructor(message, statusCode, headers, body) {
super(message);
Error.captureStackTrace(this, ResponseStatusCodeError);
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 {
constructor(message) {
super(message);
Error.captureStackTrace(this, InvalidArgumentError);
this.name = "InvalidArgumentError";
this.message = message || "Invalid Argument Error";
this.code = "UND_ERR_INVALID_ARG";
}
};
var InvalidReturnValueError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, InvalidReturnValueError);
this.name = "InvalidReturnValueError";
this.message = message || "Invalid Return Value Error";
this.code = "UND_ERR_INVALID_RETURN_VALUE";
}
};
var RequestAbortedError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, RequestAbortedError);
this.name = "AbortError";
this.message = message || "Request aborted";
this.code = "UND_ERR_ABORTED";
}
};
var InformationalError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, InformationalError);
this.name = "InformationalError";
this.message = message || "Request information";
this.code = "UND_ERR_INFO";
}
};
var RequestContentLengthMismatchError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, RequestContentLengthMismatchError);
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 {
constructor(message) {
super(message);
Error.captureStackTrace(this, ResponseContentLengthMismatchError);
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 {
constructor(message) {
super(message);
Error.captureStackTrace(this, ClientDestroyedError);
this.name = "ClientDestroyedError";
this.message = message || "The client is destroyed";
this.code = "UND_ERR_DESTROYED";
}
};
var ClientClosedError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, ClientClosedError);
this.name = "ClientClosedError";
this.message = message || "The client is closed";
this.code = "UND_ERR_CLOSED";
}
};
var SocketError = class extends UndiciError {
constructor(message, socket) {
super(message);
Error.captureStackTrace(this, SocketError);
this.name = "SocketError";
this.message = message || "Socket error";
this.code = "UND_ERR_SOCKET";
this.socket = socket;
}
};
var NotSupportedError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, NotSupportedError);
this.name = "NotSupportedError";
this.message = message || "Not supported error";
this.code = "UND_ERR_NOT_SUPPORTED";
}
};
var BalancedPoolMissingUpstreamError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, NotSupportedError);
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 {
constructor(message, code, data) {
super(message);
Error.captureStackTrace(this, HTTPParserError);
this.name = "HTTPParserError";
this.code = code ? `HPE_${code}` : void 0;
this.data = data ? data.toString() : void 0;
}
};
var ResponseExceededMaxSizeError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, ResponseExceededMaxSizeError);
this.name = "ResponseExceededMaxSizeError";
this.message = message || "Response content exceeded max size";
this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE";
}
};
module2.exports = {
HTTPParserError,
UndiciError,
HeadersTimeoutError,
HeadersOverflowError,
BodyTimeoutError,
RequestContentLengthMismatchError,
ConnectTimeoutError,
ResponseStatusCodeError,
InvalidArgumentError,
InvalidReturnValueError,
RequestAbortedError,
ClientDestroyedError,
ClientClosedError,
InformationalError,
SocketError,
NotSupportedError,
ResponseContentLengthMismatchError,
BalancedPoolMissingUpstreamError,
ResponseExceededMaxSizeError
};
}
});
// lib/core/util.js
var require_util = __commonJS({
"lib/core/util.js"(exports2, module2) {
"use strict";
var assert = require("assert");
var { kDestroyed, kBodyUsed } = require_symbols();
var { IncomingMessage } = require("http");
var stream = require("stream");
var net = require("net");
var { InvalidArgumentError } = require_errors();
var { Blob: Blob2 } = require("buffer");
var nodeUtil = require("util");
var { stringify } = require("querystring");
function nop() {
}
function isStream(obj) {
return obj && typeof obj.pipe === "function";
}
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]);
}
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;
}
function parseURL(url) {
if (typeof url === "string") {
url = new URL(url);
}
if (!url || typeof url !== "object") {
throw new InvalidArgumentError("invalid url");
}
if (url.port != null && url.port !== "" && !Number.isFinite(parseInt(url.port))) {
throw new InvalidArgumentError("invalid port");
}
if (url.path != null && typeof url.path !== "string") {
throw new InvalidArgumentError("invalid path");
}
if (url.pathname != null && typeof url.pathname !== "string") {
throw new InvalidArgumentError("invalid pathname");
}
if (url.hostname != null && typeof url.hostname !== "string") {
throw new InvalidArgumentError("invalid hostname");
}
if (url.origin != null && typeof url.origin !== "string") {
throw new InvalidArgumentError("invalid origin");
}
if (!/^https?:/.test(url.origin || url.protocol)) {
throw new InvalidArgumentError("invalid protocol");
}
if (!(url instanceof URL)) {
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;
}
function parseOrigin(url) {
url = parseURL(url);
if (url.pathname !== "/" || url.search || url.hash) {
throw new InvalidArgumentError("invalid url");
}
return url;
}
function getHostname(host) {
if (host[0] === "[") {
const idx2 = host.indexOf("]");
assert(idx2 !== -1);
return host.substr(1, idx2 - 1);
}
const idx = host.indexOf(":");
if (idx === -1)
return host;
return host.substr(0, idx);
}
function getServerName(host) {
if (!host) {
return null;
}
assert.strictEqual(typeof host, "string");
const servername = getHostname(host);
if (net.isIP(servername)) {
return "";
}
return servername;
}
function deepClone(obj) {
return JSON.parse(JSON.stringify(obj));
}
function isAsyncIterable(obj) {
return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function");
}
function isIterable(obj) {
return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function"));
}
function bodyLength(body) {
if (body == null) {
return 0;
} else if (isStream(body)) {
const state = body._readableState;
return state && 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;
}
function isDestroyed(stream2) {
return !stream2 || !!(stream2.destroyed || stream2[kDestroyed]);
}
function isReadableAborted(stream2) {
const state = stream2 && stream2._readableState;
return isDestroyed(stream2) && state && !state.endEmitted;
}
function destroy(stream2, err) {
if (!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;
}
}
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;
}
function parseHeaders(headers, obj = {}) {
for (let i = 0; i < headers.length; i += 2) {
const key = headers[i].toString().toLowerCase();
let val = obj[key];
if (!val) {
if (Array.isArray(headers[i + 1])) {
obj[key] = headers[i + 1];
} else {
obj[key] = headers[i + 1].toString();
}
} else {
if (!Array.isArray(val)) {
val = [val];
obj[key] = val;
}
val.push(headers[i + 1].toString());
}
}
return obj;
}
function parseRawHeaders(headers) {
return headers.map((header) => header.toString());
}
function isBuffer(buffer) {
return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
}
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");
}
}
}
function isDisturbed(body) {
return !!(body && (stream.isDisturbed ? stream.isDisturbed(body) || body[kBodyUsed] : body[kBodyUsed] || body.readableDidRead || body._readableState && body._readableState.dataEmitted || isReadableAborted(body)));
}
function isErrored(body) {
return !!(body && (stream.isErrored ? stream.isErrored(body) : /state: 'errored'/.test(
nodeUtil.inspect(body)
)));
}
function isReadable(body) {
return !!(body && (stream.isReadable ? stream.isReadable(body) : /state: 'readable'/.test(
nodeUtil.inspect(body)
)));
}
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
};
}
var ReadableStream;
function ReadableStreamFrom(iterable) {
if (!ReadableStream) {
ReadableStream = require("stream/web").ReadableStream;
}
if (ReadableStream.from) {
return ReadableStream.from(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();
});
} else {
const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
controller.enqueue(new Uint8Array(buf));
}
return controller.desiredSize > 0;
},
async cancel(reason) {
await iterator.return();
}
},
0
);
}
function isFormDataLike(chunk) {
return chunk && chunk.constructor && chunk.constructor.name === "FormData";
}
var kEnumerableProperty = /* @__PURE__ */ Object.create(null);
kEnumerableProperty.enumerable = true;
module2.exports = {
kEnumerableProperty,
nop,
isDisturbed,
isErrored,
isReadable,
toUSVString: nodeUtil.toUSVString || ((val) => `${val}`),
isReadableAborted,
isBlobLike,
parseOrigin,
parseURL,
getServerName,
isStream,
isIterable,
isAsyncIterable,
isDestroyed,
parseRawHeaders,
parseHeaders,
parseKeepAliveTimeout,
destroy,
bodyLength,
deepClone,
ReadableStreamFrom,
isBuffer,
validateHandler,
getSocketInfo,
isFormDataLike,
buildURL
};
}
});
// lib/fetch/constants.js
var require_constants = __commonJS({
"lib/fetch/constants.js"(exports2, module2) {
"use strict";
var { MessageChannel, receiveMessageOnPort } = require("worker_threads");
var corsSafeListedMethods = ["GET", "HEAD", "POST"];
var nullBodyStatus = [101, 204, 205, 304];
var redirectStatus = [301, 302, 303, 307, 308];
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 referrerPolicy = [
"",
"no-referrer",
"no-referrer-when-downgrade",
"same-origin",
"origin",
"strict-origin",
"origin-when-cross-origin",
"strict-origin-when-cross-origin",
"unsafe-url"
];
var requestRedirect = ["follow", "manual", "error"];
var safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"];
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"
];
var requestDuplex = [
"half"
];
var forbiddenMethods = ["CONNECT", "TRACE", "TRACK"];
var subresource = [
"audio",
"audioworklet",
"font",
"image",
"manifest",
"paintworklet",
"script",
"style",
"track",
"video",
"xslt",
""
];
var DOMException = globalThis.DOMException ?? (() => {
try {
atob("~");
} catch (err) {
return Object.getPrototypeOf(err).constructor;
}
})();
var channel;
var structuredClone = globalThis.structuredClone ?? // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js
// structuredClone was added in v17.0.0, but fetch supports v16.8
function structuredClone2(value, options = void 0) {
if (arguments.length === 0) {
throw new TypeError("missing argument");
}
if (!channel) {
channel = new MessageChannel();
}
channel.port1.unref();
channel.port2.unref();
channel.port1.postMessage(value, options?.transfer);
return receiveMessageOnPort(channel.port2).message;
};
module2.exports = {
DOMException,
structuredClone,
subresource,
forbiddenMethods,
requestBodyHeader,
referrerPolicy,
requestRedirect,
requestMode,
requestCredentials,
requestCache,
redirectStatus,
corsSafeListedMethods,
nullBodyStatus,
safeMethods,
badPorts,
requestDuplex
};
}
});
// lib/fetch/util.js
var require_util2 = __commonJS({
"lib/fetch/util.js"(exports2, module2) {
"use strict";
var { redirectStatus, badPorts, referrerPolicy: referrerPolicyTokens } = require_constants();
var { performance: performance2 } = require("perf_hooks");
var { isBlobLike, toUSVString, ReadableStreamFrom } = require_util();
var assert = require("assert");
var { isUint8Array } = require("util/types");
var crypto;
try {
crypto = require("crypto");
} catch {
}
function responseURL(response) {
const urlList = response.urlList;
const length = urlList.length;
return length === 0 ? null : urlList[length - 1].toString();
}
function responseLocationURL(response, requestFragment) {
if (!redirectStatus.includes(response.status)) {
return null;
}
let location = response.headersList.get("location");
location = location ? new URL(location, responseURL(response)) : null;
if (location && !location.hash) {
location.hash = requestFragment;
}
return location;
}
function requestCurrentURL(request) {
return request.urlList[request.urlList.length - 1];
}
function requestBadPort(request) {
const url = requestCurrentURL(request);
if (/^https?:/.test(url.protocol) && badPorts.includes(url.port)) {
return "blocked";
}
return "allowed";
}
function isErrorLike(object) {
return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException");
}
function isValidReasonPhrase(statusText) {
for (let i = 0; i < statusText.length; ++i) {
const c = statusText.charCodeAt(i);
if (!(c === 9 || // HTAB
c >= 32 && c <= 126 || // SP / VCHAR
c >= 128 && c <= 255)) {
return false;
}
}
return true;
}
function isTokenChar(c) {
return !(c >= 127 || c <= 32 || c === "(" || c === ")" || c === "<" || c === ">" || c === "@" || c === "," || c === ";" || c === ":" || c === "\\" || c === '"' || c === "/" || c === "[" || c === "]" || c === "?" || c === "=" || c === "{" || c === "}");
}
function isValidHTTPToken(characters) {
if (!characters || typeof characters !== "string") {
return false;
}
for (let i = 0; i < characters.length; ++i) {
const c = characters.charCodeAt(i);
if (c > 127 || !isTokenChar(c)) {
return false;
}
}
return true;
}
function isValidHeaderName(potentialValue) {
if (potentialValue.length === 0) {
return false;
}
return isValidHTTPToken(potentialValue);
}
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;
}
function setRequestReferrerPolicyOnRedirect(request, actualResponse) {
const { headersList } = actualResponse;
const policyHeader = (headersList.get("referrer-policy") ?? "").split(",");
let policy = "";
if (policyHeader.length > 0) {
for (let i = policyHeader.length; i !== 0; i--) {
const token = policyHeader[i - 1].trim();
if (referrerPolicyTokens.includes(token)) {
policy = token;
break;
}
}
}
if (policy !== "") {
request.referrerPolicy = policy;
}
}
function crossOriginResourcePolicyCheck() {
return "allowed";
}
function corsCheck() {
return "success";
}
function TAOCheck() {
return "success";
}
function appendFetchMetadata(httpRequest) {
let header = null;
header = httpRequest.mode;
httpRequest.headersList.set("sec-fetch-mode", header);
}
function appendRequestOriginHeader(request) {
let serializedOrigin = request.origin;
if (request.responseTainting === "cors" || request.mode === "websocket") {
if (serializedOrigin) {
request.headersList.append("Origin", serializedOrigin);
}
} 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 (/^https:/.test(request.origin) && !/^https:/.test(requestCurrentURL(request))) {
serializedOrigin = null;
}
break;
case "same-origin":
if (!sameOrigin(request, requestCurrentURL(request))) {
serializedOrigin = null;
}
break;
default:
}
if (serializedOrigin) {
request.headersList.append("Origin", serializedOrigin);
}
}
}
function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
return performance2.now();
}
function createOpaqueTimingInfo(timingInfo) {
return {
startTime: timingInfo.startTime ?? 0,
redirectStartTime: 0,
redirectEndTime: 0,
postRedirectStartTime: timingInfo.startTime ?? 0,
finalServiceWorkerStartTime: 0,
finalNetworkResponseStartTime: 0,
finalNetworkRequestStartTime: 0,
endTime: 0,
encodedBodySize: 0,
decodedBodySize: 0,
finalConnectionTimingInfo: null
};
}
function makePolicyContainer() {
return {};
}
function clonePolicyContainer() {
return {};
}
function determineRequestsReferrer(request) {
const policy = request.referrerPolicy;
if (policy == null || policy === "" || policy === "no-referrer") {
return "no-referrer";
}
const environment = request.client;
let referrerSource = null;
if (request.referrer === "client") {
if (request.client?.globalObject?.constructor?.name === "Window") {
const origin = environment.globalObject.self?.origin ?? environment.globalObject.location?.origin;
if (origin == null || origin === "null")
return "no-referrer";
referrerSource = new URL(environment.globalObject.location.href);
} else {
if (environment?.globalObject?.location == null) {
return "no-referrer";
}
referrerSource = new URL(environment.globalObject.location.href);
}
} else if (request.referrer instanceof URL) {
referrerSource = request.referrer;
} else {
return "no-referrer";
}
const urlProtocol = referrerSource.protocol;
if (urlProtocol === "about:" || urlProtocol === "data:" || urlProtocol === "blob:") {
return "no-referrer";
}
let temp;
let referrerOrigin;
const referrerUrl = (temp = stripURLForReferrer(referrerSource)).length > 4096 ? referrerOrigin = stripURLForReferrer(referrerSource, true) : temp;
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":
if (areSameOrigin)
return referrerOrigin;
case "strict-origin":
case "no-referrer-when-downgrade":
default:
return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin;
}
function stripURLForReferrer(url, originOnly = false) {
const urlObject = new URL(url.href);
urlObject.username = "";
urlObject.password = "";
urlObject.hash = "";
return originOnly ? urlObject.origin : urlObject.href;
}
}
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;
}
}
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;
const expectedValue = item.hash;
const actualValue = crypto.createHash(algorithm).update(bytes).digest("base64");
if (actualValue === expectedValue) {
return true;
}
}
return false;
}
var parseHashWithOptions = /((?<algo>sha256|sha384|sha512)-(?<hash>[A-z0-9+/]{1}.*={0,2}))( +[\x21-\x7e]?)?/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;
}
function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) {
}
function sameOrigin(A, B) {
if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) {
return true;
}
return false;
}
function createDeferredPromise() {
let res;
let rej;
const promise = new Promise((resolve, reject) => {
res = resolve;
rej = reject;
});
return { promise, resolve: res, reject: rej };
}
function isAborted(fetchParams) {
return fetchParams.controller.state === "aborted";
}
function isCancelled(fetchParams) {
return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated";
}
function normalizeMethod(method) {
return /^(DELETE|GET|HEAD|OPTIONS|POST|PUT)$/i.test(method) ? method.toUpperCase() : method;
}
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;
}
var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
function makeIterator(iterator, name, kind) {
const object = {
index: 0,
kind,
target: iterator
};
const i = {
next() {
if (Object.getPrototypeOf(this) !== i) {
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 pair = values[index];
object.index = index + 1;
return iteratorResult(pair, kind2);
},
// The class string of an iterator prototype object for a given interface is the
// result of concatenating the identifier of the interface and the string " Iterator".
[Symbol.toStringTag]: `${name} Iterator`
};
Object.setPrototypeOf(i, esIteratorPrototype);
return Object.setPrototypeOf({}, i);
}
function iteratorResult(pair, kind) {
let result;
switch (kind) {
case "key": {
result = pair[0];
break;
}
case "value": {
result = pair[1];
break;
}
case "key+value": {
result = pair;
break;
}
}
return { value: result, done: false };
}
function fullyReadBody(body, processBody, processBodyError) {
const successSteps = (bytes) => queueMicrotask(() => processBody(bytes));
const errorSteps = (error) => queueMicrotask(() => processBodyError(error));
let reader;
try {
reader = body.stream.getReader();
} catch (e) {
errorSteps(e);
return;
}
readAllBytes(reader, successSteps, errorSteps);
}
var ReadableStream = globalThis.ReadableStream;
function isReadableStreamLike(stream) {
if (!ReadableStream) {
ReadableStream = require("stream/web").ReadableStream;
}
return stream instanceof ReadableStream || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function";
}
var MAXIMUM_ARGUMENT_LENGTH = 65535;
function isomorphicDecode(input) {
if (input.length < MAXIMUM_ARGUMENT_LENGTH) {
return String.fromCharCode(...input);
}
return input.reduce((previous, current) => previous + String.fromCharCode(current), "");
}
function readableStreamClose(controller) {
try {
controller.close();
} catch (err) {
if (!err.message.includes("Controller is already closed")) {
throw err;
}
}
}
function isomorphicEncode(input) {
for (let i = 0; i < input.length; i++) {
assert(input.charCodeAt(i) <= 255);
}
return input;
}
async function readAllBytes(reader, successSteps, failureSteps) {
const bytes = [];
let byteLength = 0;
while (true) {
let done;
let chunk;
try {
({ done, value: chunk } = await reader.read());
} catch (e) {
failureSteps(e);
return;
}
if (done) {
successSteps(Buffer.concat(bytes, byteLength));
return;
}
if (!isUint8Array(chunk)) {
failureSteps(new TypeError("Received non-Uint8Array chunk"));
return;
}
bytes.push(chunk);
byteLength += chunk.length;
}
}
var hasOwn = Object.hasOwn || ((dict, key) => Object.prototype.hasOwnProperty.call(dict, key));
module2.exports = {
isAborted,
isCancelled,
createDeferredPromise,
ReadableStreamFrom,
toUSVString,
tryUpgradeRequestToAPotentiallyTrustworthyURL,
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,
hasOwn,
isErrorLike,
fullyReadBody,
bytesMatch,
isReadableStreamLike,
readableStreamClose,
isomorphicEncode,
isomorphicDecode
};
}
});
// lib/fetch/webidl.js
var require_webidl = __commonJS({
"lib/fetch/webidl.js"(exports2, module2) {
"use strict";
var { types } = require("util");
var { hasOwn, 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 && !(V instanceof I)) {
throw new TypeError("Illegal invocation");
} else {
return V?.[Symbol.toStringTag] === I.prototype[Symbol.toStringTag];
}
};
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.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 (!hasOwn(dictionary, key)) {
throw webidl.errors.exception({
header: "Dictionary",
message: `Missing required key "${key}".`
});
}
}
let value = dictionary[key];
const hasDefault = 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++) {
const charCode = x.charCodeAt(index);
if (charCode > 255) {
throw new TypeError(
`Cannot convert argument to a ByteString because the character at index ${index} has a value of ${charCode} 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);
}
if (types.isTypedArray(V)) {
return webidl.converters.TypedArray(V, V.constructor);
}
if (types.isDataView(V)) {
return webidl.converters.DataView(V, opts);
}
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 } = require_symbols();
var { kGuard, kHeadersCaseInsensitive } = require_symbols2();
var { kEnumerableProperty } = require_util();
var {
makeIterator,
isValidHeaderName,
isValidHeaderValue
} = require_util2();
var { webidl } = require_webidl();
var kHeadersMap = Symbol("headers map");
var kHeadersSortedMap = Symbol("headers map sorted");
function headerValueNormalize(potentialValue) {
let i = potentialValue.length;
while (/[\r\n\t ]/.test(potentialValue.charAt(--i)))
;
return potentialValue.slice(0, i + 1).replace(/^[\r\n\t ]+/, "");
}
function fill(headers, object) {
if (Array.isArray(object)) {
for (const header of object) {
if (header.length !== 2) {
throw webidl.errors.exception({
header: "Headers constructor",
message: `expected name/value pair to be length 2, found ${header.length}.`
});
}
headers.append(header[0], header[1]);
}
} else if (typeof object === "object" && object !== null) {
for (const [key, value] of Object.entries(object)) {
headers.append(key, value);
}
} else {
throw webidl.errors.conversionFailed({
prefix: "Headers constructor",
argument: "Argument 1",
types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
});
}
}
var HeadersList = class {
/** @type {[string, string][]|null} */
cookies = null;
constructor(init) {
if (init instanceof HeadersList) {
this[kHeadersMap] = new Map(init[kHeadersMap]);
this[kHeadersSortedMap] = init[kHeadersSortedMap];
} else {
this[kHeadersMap] = new Map(init);
this[kHeadersSortedMap] = null;
}
}
// https://fetch.spec.whatwg.org/#header-list-contains
contains(name) {
name = name.toLowerCase();
return this[kHeadersMap].has(name);
}
clear() {
this[kHeadersMap].clear();
this[kHeadersSortedMap] = null;
}
// https://fetch.spec.whatwg.org/#concept-header-list-append
append(name, value) {
this[kHeadersSortedMap] = null;
const lowercaseName = name.toLowerCase();
const exists = this[kHeadersMap].get(lowercaseName);
if (exists) {
this[kHeadersMap].set(lowercaseName, { name: exists.name, value: `${exists.value}, ${value}` });
} else {
this[kHeadersMap].set(lowercaseName, { name, value });
}
if (lowercaseName === "set-cookie") {
this.cookies ??= [];
this.cookies.push([name, value]);
}
}
// https://fetch.spec.whatwg.org/#concept-header-list-set
set(name, value) {
this[kHeadersSortedMap] = null;
const lowercaseName = name.toLowerCase();
if (lowercaseName === "set-cookie") {
this.cookies = [[name, value]];
}
return this[kHeadersMap].set(lowercaseName, { name, value });
}
// https://fetch.spec.whatwg.org/#concept-header-list-delete
delete(name) {
this[kHeadersSortedMap] = null;
name = name.toLowerCase();
if (name === "set-cookie") {
this.cookies = null;
}
return this[kHeadersMap].delete(name);
}
// https://fetch.spec.whatwg.org/#concept-header-list-get
get(name) {
if (!this.contains(name)) {
return null;
}
return this[kHeadersMap].get(name.toLowerCase())?.value ?? null;
}
*[Symbol.iterator]() {
for (const [name, { value }] of this[kHeadersMap]) {
yield [name, value];
}
}
get [kHeadersCaseInsensitive]() {
const flatList = [];
for (const { name, value } of this[kHeadersMap].values()) {
flatList.push(name, value);
}
return flatList;
}
};
var Headers = class {
constructor(init = void 0) {
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);
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 (this[kGuard] === "immutable") {
throw new TypeError("immutable");
} else if (this[kGuard] === "request-no-cors") {
}
return this[kHeadersList].append(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)) {
return;
}
return this[kHeadersList].delete(name);
}
// 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);
}
// 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);
}
// 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") {
}
return this[kHeadersList].set(name, value);
}
get [kHeadersSortedMap]() {
if (!this[kHeadersList][kHeadersSortedMap]) {
this[kHeadersList][kHeadersSortedMap] = new Map([...this[kHeadersList]].sort((a, b) => a[0] < b[0] ? -1 : 1));
}
return this[kHeadersList][kHeadersSortedMap];
}
keys() {
webidl.brandCheck(this, Headers);
return makeIterator(
() => [...this[kHeadersSortedMap].entries()],
"Headers",
"key"
);
}
values() {
webidl.brandCheck(this, Headers);
return makeIterator(
() => [...this[kHeadersSortedMap].entries()],
"Headers",
"value"
);
}
entries() {
webidl.brandCheck(this, Headers);
return makeIterator(
() => [...this[kHeadersSortedMap].entries()],
"Headers",
"key+value"
);
}
/**
* @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.apply(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,
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
};
}
});
// ../../../usr/share/nodejs/busboy/lib/utils.js
var require_utils = __commonJS({
"../../../usr/share/nodejs/busboy/lib/utils.js"(exports2, module2) {
"use strict";
function parseContentType(str) {
if (str.length === 0)
return;
const params = /* @__PURE__ */ Object.create(null);
let i = 0;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (TOKEN[code] !== 1) {
if (code !== 47 || i === 0)
return;
break;
}
}
if (i === str.length)
return;
const type = str.slice(0, i).toLowerCase();
const subtypeStart = ++i;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (TOKEN[code] !== 1) {
if (i === subtypeStart)
return;
if (parseContentTypeParams(str, i, params) === void 0)
return;
break;
}
}
if (i === subtypeStart)
return;
const subtype = str.slice(subtypeStart, i).toLowerCase();
return { type, subtype, params };
}
function parseContentTypeParams(str, i, params) {
while (i < str.length) {
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (code !== 32 && code !== 9)
break;
}
if (i === str.length)
break;
if (str.charCodeAt(i++) !== 59)
return;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (code !== 32 && code !== 9)
break;
}
if (i === str.length)
return;
let name;
const nameStart = i;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (TOKEN[code] !== 1) {
if (code !== 61)
return;
break;
}
}
if (i === str.length)
return;
name = str.slice(nameStart, i);
++i;
if (i === str.length)
return;
let value = "";
let valueStart;
if (str.charCodeAt(i) === 34) {
valueStart = ++i;
let escaping = false;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (code === 92) {
if (escaping) {
valueStart = i;
escaping = false;
} else {
value += str.slice(valueStart, i);
escaping = true;
}
continue;
}
if (code === 34) {
if (escaping) {
valueStart = i;
escaping = false;
continue;
}
value += str.slice(valueStart, i);
break;
}
if (escaping) {
valueStart = i - 1;
escaping = false;
}
if (QDTEXT[code] !== 1)
return;
}
if (i === str.length)
return;
++i;
} else {
valueStart = i;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (TOKEN[code] !== 1) {
if (i === valueStart)
return;
break;
}
}
value = str.slice(valueStart, i);
}
name = name.toLowerCase();
if (params[name] === void 0)
params[name] = value;
}
return params;
}
function parseDisposition(str, defDecoder) {
if (str.length === 0)
return;
const params = /* @__PURE__ */ Object.create(null);
let i = 0;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (TOKEN[code] !== 1) {
if (parseDispositionParams(str, i, params, defDecoder) === void 0)
return;
break;
}
}
const type = str.slice(0, i).toLowerCase();
return { type, params };
}
function parseDispositionParams(str, i, params, defDecoder) {
while (i < str.length) {
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (code !== 32 && code !== 9)
break;
}
if (i === str.length)
break;
if (str.charCodeAt(i++) !== 59)
return;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (code !== 32 && code !== 9)
break;
}
if (i === str.length)
return;
let name;
const nameStart = i;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (TOKEN[code] !== 1) {
if (code === 61)
break;
return;
}
}
if (i === str.length)
return;
let value = "";
let valueStart;
let charset;
name = str.slice(nameStart, i);
if (name.charCodeAt(name.length - 1) === 42) {
const charsetStart = ++i;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (CHARSET[code] !== 1) {
if (code !== 39)
return;
break;
}
}
if (i === str.length)
return;
charset = str.slice(charsetStart, i);
++i;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (code === 39)
break;
}
if (i === str.length)
return;
++i;
if (i === str.length)
return;
valueStart = i;
let encode = 0;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (EXTENDED_VALUE[code] !== 1) {
if (code === 37) {
let hexUpper;
let hexLower;
if (i + 2 < str.length && (hexUpper = HEX_VALUES[str.charCodeAt(i + 1)]) !== -1 && (hexLower = HEX_VALUES[str.charCodeAt(i + 2)]) !== -1) {
const byteVal = (hexUpper << 4) + hexLower;
value += str.slice(valueStart, i);
value += String.fromCharCode(byteVal);
i += 2;
valueStart = i + 1;
if (byteVal >= 128)
encode = 2;
else if (encode === 0)
encode = 1;
continue;
}
return;
}
break;
}
}
value += str.slice(valueStart, i);
value = convertToUTF8(value, charset, encode);
if (value === void 0)
return;
} else {
++i;
if (i === str.length)
return;
if (str.charCodeAt(i) === 34) {
valueStart = ++i;
let escaping = false;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (code === 92) {
if (escaping) {
valueStart = i;
escaping = false;
} else {
value += str.slice(valueStart, i);
escaping = true;
}
continue;
}
if (code === 34) {
if (escaping) {
valueStart = i;
escaping = false;
continue;
}
value += str.slice(valueStart, i);
break;
}
if (escaping) {
valueStart = i - 1;
escaping = false;
}
if (QDTEXT[code] !== 1)
return;
}
if (i === str.length)
return;
++i;
} else {
valueStart = i;
for (; i < str.length; ++i) {
const code = str.charCodeAt(i);
if (TOKEN[code] !== 1) {
if (i === valueStart)
return;
break;
}
}
value = str.slice(valueStart, i);
}
value = defDecoder(value, 2);
if (value === void 0)
return;
}
name = name.toLowerCase();
if (params[name] === void 0)
params[name] = value;
}
return params;
}
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);
}
}
}
var decoders = {
utf8: (data, hint) => {
if (data.length === 0)
return "";
if (typeof data === "string") {
if (hint < 2)
return data;
data = Buffer.from(data, "latin1");
}
return data.utf8Slice(0, data.length);
},
latin1: (data, hint) => {
if (data.length === 0)
return "";
if (typeof data === "string")
return data;
return data.latin1Slice(0, data.length);
},
utf16le: (data, hint) => {
if (data.length === 0)
return "";
if (typeof data === "string")
data = Buffer.from(data, "latin1");
return data.ucs2Slice(0, data.length);
},
base64: (data, hint) => {
if (data.length === 0)
return "";
if (typeof data === "string")
data = Buffer.from(data, "latin1");
return data.base64Slice(0, data.length);
},
other: (data, hint) => {
if (data.length === 0)
return "";
if (typeof data === "string")
data = Buffer.from(data, "latin1");
try {
const decoder = new TextDecoder(exports2);
return decoder.decode(data);
} catch {
}
}
};
function convertToUTF8(data, charset, hint) {
const decode = getDecoder(charset);
if (decode)
return decode(data, hint);
}
function basename(path) {
if (typeof path !== "string")
return "";
for (let 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;
}
var TOKEN = [
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,
0,
1,
1,
1,
1,
1,
0,
0,
1,
1,
0,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
0,
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,
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,
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,
0,
0,
0,
0,
0,
0,
0
];
var QDTEXT = [
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
];
var CHARSET = [
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,
0,
1,
1,
1,
1,
0,
0,
0,
0,
1,
0,
1,
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,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
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,
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,
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,
0,
0,
0,
0,
0,
0,
0
];
var EXTENDED_VALUE = [
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,
0,
1,
1,
0,
1,
0,
0,
0,
0,
1,
0,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
0,
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,
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,
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,
0,
0,
0,
0,
0,
0,
0
];
var HEX_VALUES = [
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
10,
11,
12,
13,
14,
15,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
10,
11,
12,
13,
14,
15,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1
];
module2.exports = {
basename,
convertToUTF8,
getDecoder,
parseContentType,
parseDisposition
};
}
});
// ../../../usr/share/nodejs/streamsearch/lib/sbmh.js
var require_sbmh = __commonJS({
"../../../usr/share/nodejs/streamsearch/lib/sbmh.js"(exports2, module2) {
"use strict";
function memcmp(buf1, pos1, buf2, pos2, num) {
for (let i = 0; i < num; ++i) {
if (buf1[pos1 + i] !== buf2[pos2 + i])
return false;
}
return true;
}
var SBMH = class {
constructor(needle, cb) {
if (typeof cb !== "function")
throw new Error("Missing match callback");
if (typeof needle === "string")
needle = Buffer.from(needle);
else if (!Buffer.isBuffer(needle))
throw new Error(`Expected Buffer for needle, got ${typeof needle}`);
const needleLen = needle.length;
this.maxMatches = Infinity;
this.matches = 0;
this._cb = cb;
this._lookbehindSize = 0;
this._needle = needle;
this._bufPos = 0;
this._lookbehind = Buffer.allocUnsafe(needleLen);
this._occ = [
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen,
needleLen
];
if (needleLen > 1) {
for (let i = 0; i < needleLen - 1; ++i)
this._occ[needle[i]] = needleLen - 1 - i;
}
}
reset() {
this.matches = 0;
this._lookbehindSize = 0;
this._bufPos = 0;
}
push(chunk, pos) {
let result;
if (!Buffer.isBuffer(chunk))
chunk = Buffer.from(chunk, "latin1");
const chunkLen = chunk.length;
this._bufPos = pos || 0;
while (result !== chunkLen && this.matches < this.maxMatches)
result = feed(this, chunk);
return result;
}
destroy() {
const lbSize = this._lookbehindSize;
if (lbSize)
this._cb(false, this._lookbehind, 0, lbSize, false);
this.reset();
}
};
function feed(self, data) {
const len = data.length;
const needle = self._needle;
const needleLen = needle.length;
let pos = -self._lookbehindSize;
const lastNeedleCharPos = needleLen - 1;
const lastNeedleChar = needle[lastNeedleCharPos];
const end = len - needleLen;
const occ = self._occ;
const lookbehind = self._lookbehind;
if (pos < 0) {
while (pos < 0 && pos <= end) {
const nextPos = pos + lastNeedleCharPos;
const ch = nextPos < 0 ? lookbehind[self._lookbehindSize + nextPos] : data[nextPos];
if (ch === lastNeedleChar && matchNeedle(self, data, pos, lastNeedleCharPos)) {
self._lookbehindSize = 0;
++self.matches;
if (pos > -self._lookbehindSize)
self._cb(true, lookbehind, 0, self._lookbehindSize + pos, false);
else
self._cb(true, void 0, 0, 0, true);
return self._bufPos = pos + needleLen;
}
pos += occ[ch];
}
while (pos < 0 && !matchNeedle(self, data, pos, len - pos))
++pos;
if (pos < 0) {
const bytesToCutOff = self._lookbehindSize + pos;
if (bytesToCutOff > 0) {
self._cb(false, lookbehind, 0, bytesToCutOff, false);
}
self._lookbehindSize -= bytesToCutOff;
lookbehind.copy(lookbehind, 0, bytesToCutOff, self._lookbehindSize);
lookbehind.set(data, self._lookbehindSize);
self._lookbehindSize += len;
self._bufPos = len;
return len;
}
self._cb(false, lookbehind, 0, self._lookbehindSize, false);
self._lookbehindSize = 0;
}
pos += self._bufPos;
const firstNeedleChar = needle[0];
while (pos <= end) {
const ch = data[pos + lastNeedleCharPos];
if (ch === lastNeedleChar && data[pos] === firstNeedleChar && memcmp(needle, 0, data, pos, lastNeedleCharPos)) {
++self.matches;
if (pos > 0)
self._cb(true, data, self._bufPos, pos, true);
else
self._cb(true, void 0, 0, 0, true);
return self._bufPos = pos + needleLen;
}
pos += occ[ch];
}
while (pos < len) {
if (data[pos] !== firstNeedleChar || !memcmp(data, pos, needle, 0, len - pos)) {
++pos;
continue;
}
data.copy(lookbehind, 0, pos, len);
self._lookbehindSize = len - pos;
break;
}
if (pos > 0)
self._cb(false, data, self._bufPos, pos < len ? pos : len, true);
self._bufPos = len;
return len;
}
function matchNeedle(self, data, pos, len) {
const lb = self._lookbehind;
const lbSize = self._lookbehindSize;
const needle = self._needle;
for (let i = 0; i < len; ++i, ++pos) {
const ch = pos < 0 ? lb[lbSize + pos] : data[pos];
if (ch !== needle[i])
return false;
}
return true;
}
module2.exports = SBMH;
}
});
// ../../../usr/share/nodejs/busboy/lib/types/multipart.js
var require_multipart = __commonJS({
"../../../usr/share/nodejs/busboy/lib/types/multipart.js"(exports2, module2) {
"use strict";
var { Readable, Writable } = require("stream");
var StreamSearch = require_sbmh();
var {
basename,
convertToUTF8,
getDecoder,
parseContentType,
parseDisposition
} = require_utils();
var BUF_CRLF = Buffer.from("\r\n");
var BUF_CR = Buffer.from("\r");
var BUF_DASH = Buffer.from("-");
function noop() {
}
var MAX_HEADER_PAIRS = 2e3;
var MAX_HEADER_SIZE = 16 * 1024;
var HPARSER_NAME = 0;
var HPARSER_PRE_OWS = 1;
var HPARSER_VALUE = 2;
var HeaderParser = class {
constructor(cb) {
this.header = /* @__PURE__ */ Object.create(null);
this.pairCount = 0;
this.byteCount = 0;
this.state = HPARSER_NAME;
this.name = "";
this.value = "";
this.crlf = 0;
this.cb = cb;
}
reset() {
this.header = /* @__PURE__ */ Object.create(null);
this.pairCount = 0;
this.byteCount = 0;
this.state = HPARSER_NAME;
this.name = "";
this.value = "";
this.crlf = 0;
}
push(chunk, pos, end) {
let start = pos;
while (pos < end) {
switch (this.state) {
case HPARSER_NAME: {
let done = false;
for (; pos < end; ++pos) {
if (this.byteCount === MAX_HEADER_SIZE)
return -1;
++this.byteCount;
const code = chunk[pos];
if (TOKEN[code] !== 1) {
if (code !== 58)
return -1;
this.name += chunk.latin1Slice(start, pos);
if (this.name.length === 0)
return -1;
++pos;
done = true;
this.state = HPARSER_PRE_OWS;
break;
}
}
if (!done) {
this.name += chunk.latin1Slice(start, pos);
break;
}
}
case HPARSER_PRE_OWS: {
let done = false;
for (; pos < end; ++pos) {
if (this.byteCount === MAX_HEADER_SIZE)
return -1;
++this.byteCount;
const code = chunk[pos];
if (code !== 32 && code !== 9) {
start = pos;
done = true;
this.state = HPARSER_VALUE;
break;
}
}
if (!done)
break;
}
case HPARSER_VALUE:
switch (this.crlf) {
case 0:
for (; pos < end; ++pos) {
if (this.byteCount === MAX_HEADER_SIZE)
return -1;
++this.byteCount;
const code = chunk[pos];
if (FIELD_VCHAR[code] !== 1) {
if (code !== 13)
return -1;
++this.crlf;
break;
}
}
this.value += chunk.latin1Slice(start, pos++);
break;
case 1:
if (this.byteCount === MAX_HEADER_SIZE)
return -1;
++this.byteCount;
if (chunk[pos++] !== 10)
return -1;
++this.crlf;
break;
case 2: {
if (this.byteCount === MAX_HEADER_SIZE)
return -1;
++this.byteCount;
const code = chunk[pos];
if (code === 32 || code === 9) {
start = pos;
this.crlf = 0;
} else {
if (++this.pairCount < MAX_HEADER_PAIRS) {
this.name = this.name.toLowerCase();
if (this.header[this.name] === void 0)
this.header[this.name] = [this.value];
else
this.header[this.name].push(this.value);
}
if (code === 13) {
++this.crlf;
++pos;
} else {
start = pos;
this.crlf = 0;
this.state = HPARSER_NAME;
this.name = "";
this.value = "";
}
}
break;
}
case 3: {
if (this.byteCount === MAX_HEADER_SIZE)
return -1;
++this.byteCount;
if (chunk[pos++] !== 10)
return -1;
const header = this.header;
this.reset();
this.cb(header);
return pos;
}
}
break;
}
}
return pos;
}
};
var FileStream = class extends Readable {
constructor(opts, owner) {
super(opts);
this.truncated = false;
this._readcb = null;
this.once("end", () => {
this._read();
if (--owner._fileEndsLeft === 0 && owner._finalcb) {
const cb = owner._finalcb;
owner._finalcb = null;
process.nextTick(cb);
}
});
}
_read(n) {
const cb = this._readcb;
if (cb) {
this._readcb = null;
cb();
}
}
};
var ignoreData = {
push: (chunk, pos) => {
},
destroy: () => {
}
};
function callAndUnsetCb(self, err) {
const cb = self._writecb;
self._writecb = null;
if (err)
self.destroy(err);
else if (cb)
cb();
}
function nullDecoder(val, hint) {
return val;
}
var Multipart = class extends Writable {
constructor(cfg) {
const streamOpts = {
autoDestroy: true,
emitClose: true,
highWaterMark: typeof cfg.highWaterMark === "number" ? cfg.highWaterMark : void 0
};
super(streamOpts);
if (!cfg.conType.params || typeof cfg.conType.params.boundary !== "string")
throw new Error("Multipart: Boundary not found");
const boundary = cfg.conType.params.boundary;
const paramDecoder = typeof cfg.defParamCharset === "string" && cfg.defParamCharset ? getDecoder(cfg.defParamCharset) : nullDecoder;
const defCharset = cfg.defCharset || "utf8";
const preservePath = cfg.preservePath;
const fileOpts = {
autoDestroy: true,
emitClose: true,
highWaterMark: typeof cfg.fileHwm === "number" ? cfg.fileHwm : void 0
};
const limits = cfg.limits;
const fieldSizeLimit = limits && typeof limits.fieldSize === "number" ? limits.fieldSize : 1 * 1024 * 1024;
const fileSizeLimit = limits && typeof limits.fileSize === "number" ? limits.fileSize : Infinity;
const filesLimit = limits && typeof limits.files === "number" ? limits.files : Infinity;
const fieldsLimit = limits && typeof limits.fields === "number" ? limits.fields : Infinity;
const partsLimit = limits && typeof limits.parts === "number" ? limits.parts : Infinity;
let parts = -1;
let fields = 0;
let files = 0;
let skipPart = false;
this._fileEndsLeft = 0;
this._fileStream = void 0;
this._complete = false;
let fileSize = 0;
let field;
let fieldSize = 0;
let partCharset;
let partEncoding;
let partType;
let partName;
let partTruncated = false;
let hitFilesLimit = false;
let hitFieldsLimit = false;
this._hparser = null;
const hparser = new HeaderParser((header) => {
this._hparser = null;
skipPart = false;
partType = "text/plain";
partCharset = defCharset;
partEncoding = "7bit";
partName = void 0;
partTruncated = false;
let filename;
if (!header["content-disposition"]) {
skipPart = true;
return;
}
const disp = parseDisposition(
header["content-disposition"][0],
paramDecoder
);
if (!disp || disp.type !== "form-data") {
skipPart = true;
return;
}
if (disp.params) {
if (disp.params.name)
partName = disp.params.name;
if (disp.params["filename*"])
filename = disp.params["filename*"];
else if (disp.params.filename)
filename = disp.params.filename;
if (filename !== void 0 && !preservePath)
filename = basename(filename);
}
if (header["content-type"]) {
const conType = parseContentType(header["content-type"][0]);
if (conType) {
partType = `${conType.type}/${conType.subtype}`;
if (conType.params && typeof conType.params.charset === "string")
partCharset = conType.params.charset.toLowerCase();
}
}
if (header["content-transfer-encoding"])
partEncoding = header["content-transfer-encoding"][0].toLowerCase();
if (partType === "application/octet-stream" || filename !== void 0) {
if (files === filesLimit) {
if (!hitFilesLimit) {
hitFilesLimit = true;
this.emit("filesLimit");
}
skipPart = true;
return;
}
++files;
if (this.listenerCount("file") === 0) {
skipPart = true;
return;
}
fileSize = 0;
this._fileStream = new FileStream(fileOpts, this);
++this._fileEndsLeft;
this.emit(
"file",
partName,
this._fileStream,
{
filename,
encoding: partEncoding,
mimeType: partType
}
);
} else {
if (fields === fieldsLimit) {
if (!hitFieldsLimit) {
hitFieldsLimit = true;
this.emit("fieldsLimit");
}
skipPart = true;
return;
}
++fields;
if (this.listenerCount("field") === 0) {
skipPart = true;
return;
}
field = [];
fieldSize = 0;
}
});
let matchPostBoundary = 0;
const ssCb = (isMatch, data, start, end, isDataSafe) => {
retrydata:
while (data) {
if (this._hparser !== null) {
const ret = this._hparser.push(data, start, end);
if (ret === -1) {
this._hparser = null;
hparser.reset();
this.emit("error", new Error("Malformed part header"));
break;
}
start = ret;
}
if (start === end)
break;
if (matchPostBoundary !== 0) {
if (matchPostBoundary === 1) {
switch (data[start]) {
case 45:
matchPostBoundary = 2;
++start;
break;
case 13:
matchPostBoundary = 3;
++start;
break;
default:
matchPostBoundary = 0;
}
if (start === end)
return;
}
if (matchPostBoundary === 2) {
matchPostBoundary = 0;
if (data[start] === 45) {
this._complete = true;
this._bparser = ignoreData;
return;
}
const writecb = this._writecb;
this._writecb = noop;
ssCb(false, BUF_DASH, 0, 1, false);
this._writecb = writecb;
} else if (matchPostBoundary === 3) {
matchPostBoundary = 0;
if (data[start] === 10) {
++start;
if (parts >= partsLimit)
break;
this._hparser = hparser;
if (start === end)
break;
continue retrydata;
} else {
const writecb = this._writecb;
this._writecb = noop;
ssCb(false, BUF_CR, 0, 1, false);
this._writecb = writecb;
}
}
}
if (!skipPart) {
if (this._fileStream) {
let chunk;
const actualLen = Math.min(end - start, fileSizeLimit - fileSize);
if (!isDataSafe) {
chunk = Buffer.allocUnsafe(actualLen);
data.copy(chunk, 0, start, start + actualLen);
} else {
chunk = data.slice(start, start + actualLen);
}
fileSize += chunk.length;
if (fileSize === fileSizeLimit) {
if (chunk.length > 0)
this._fileStream.push(chunk);
this._fileStream.emit("limit");
this._fileStream.truncated = true;
skipPart = true;
} else if (!this._fileStream.push(chunk)) {
if (this._writecb)
this._fileStream._readcb = this._writecb;
this._writecb = null;
}
} else if (field !== void 0) {
let chunk;
const actualLen = Math.min(
end - start,
fieldSizeLimit - fieldSize
);
if (!isDataSafe) {
chunk = Buffer.allocUnsafe(actualLen);
data.copy(chunk, 0, start, start + actualLen);
} else {
chunk = data.slice(start, start + actualLen);
}
fieldSize += actualLen;
field.push(chunk);
if (fieldSize === fieldSizeLimit) {
skipPart = true;
partTruncated = true;
}
}
}
break;
}
if (isMatch) {
matchPostBoundary = 1;
if (this._fileStream) {
this._fileStream.push(null);
this._fileStream = null;
} else if (field !== void 0) {
let data2;
switch (field.length) {
case 0:
data2 = "";
break;
case 1:
data2 = convertToUTF8(field[0], partCharset, 0);
break;
default:
data2 = convertToUTF8(
Buffer.concat(field, fieldSize),
partCharset,
0
);
}
field = void 0;
fieldSize = 0;
this.emit(
"field",
partName,
data2,
{
nameTruncated: false,
valueTruncated: partTruncated,
encoding: partEncoding,
mimeType: partType
}
);
}
if (++parts === partsLimit)
this.emit("partsLimit");
}
};
this._bparser = new StreamSearch(`\r
--${boundary}`, ssCb);
this._writecb = null;
this._finalcb = null;
this.write(BUF_CRLF);
}
static detect(conType) {
return conType.type === "multipart" && conType.subtype === "form-data";
}
_write(chunk, enc, cb) {
this._writecb = cb;
this._bparser.push(chunk, 0);
if (this._writecb)
callAndUnsetCb(this);
}
_destroy(err, cb) {
this._hparser = null;
this._bparser = ignoreData;
if (!err)
err = checkEndState(this);
const fileStream = this._fileStream;
if (fileStream) {
this._fileStream = null;
fileStream.destroy(err);
}
cb(err);
}
_final(cb) {
this._bparser.destroy();
if (!this._complete)
return cb(new Error("Unexpected end of form"));
if (this._fileEndsLeft)
this._finalcb = finalcb.bind(null, this, cb);
else
finalcb(this, cb);
}
};
function finalcb(self, cb, err) {
if (err)
return cb(err);
err = checkEndState(self);
cb(err);
}
function checkEndState(self) {
if (self._hparser)
return new Error("Malformed part header");
const fileStream = self._fileStream;
if (fileStream) {
self._fileStream = null;
fileStream.destroy(new Error("Unexpected end of file"));
}
if (!self._complete)
return new Error("Unexpected end of form");
}
var TOKEN = [
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,
0,
1,
1,
1,
1,
1,
0,
0,
1,
1,
0,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
0,
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,
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,
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,
0,
0,
0,
0,
0,
0,
0
];
var FIELD_VCHAR = [
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
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,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
];
module2.exports = Multipart;
}
});
// ../../../usr/share/nodejs/busboy/lib/types/urlencoded.js
var require_urlencoded = __commonJS({
"../../../usr/share/nodejs/busboy/lib/types/urlencoded.js"(exports2, module2) {
"use strict";
var { Writable } = require("stream");
var { getDecoder } = require_utils();
var URLEncoded = class extends Writable {
constructor(cfg) {
const streamOpts = {
autoDestroy: true,
emitClose: true,
highWaterMark: typeof cfg.highWaterMark === "number" ? cfg.highWaterMark : void 0
};
super(streamOpts);
let charset = cfg.defCharset || "utf8";
if (cfg.conType.params && typeof cfg.conType.params.charset === "string")
charset = cfg.conType.params.charset;
this.charset = charset;
const limits = cfg.limits;
this.fieldSizeLimit = limits && typeof limits.fieldSize === "number" ? limits.fieldSize : 1 * 1024 * 1024;
this.fieldsLimit = limits && typeof limits.fields === "number" ? limits.fields : Infinity;
this.fieldNameSizeLimit = limits && typeof limits.fieldNameSize === "number" ? limits.fieldNameSize : 100;
this._inKey = true;
this._keyTrunc = false;
this._valTrunc = false;
this._bytesKey = 0;
this._bytesVal = 0;
this._fields = 0;
this._key = "";
this._val = "";
this._byte = -2;
this._lastPos = 0;
this._encode = 0;
this._decoder = getDecoder(charset);
}
static detect(conType) {
return conType.type === "application" && conType.subtype === "x-www-form-urlencoded";
}
_write(chunk, enc, cb) {
if (this._fields >= this.fieldsLimit)
return cb();
let i = 0;
const len = chunk.length;
this._lastPos = 0;
if (this._byte !== -2) {
i = readPctEnc(this, chunk, i, len);
if (i === -1)
return cb(new Error("Malformed urlencoded form"));
if (i >= len)
return cb();
if (this._inKey)
++this._bytesKey;
else
++this._bytesVal;
}
main:
while (i < len) {
if (this._inKey) {
i = skipKeyBytes(this, chunk, i, len);
while (i < len) {
switch (chunk[i]) {
case 61:
if (this._lastPos < i)
this._key += chunk.latin1Slice(this._lastPos, i);
this._lastPos = ++i;
this._key = this._decoder(this._key, this._encode);
this._encode = 0;
this._inKey = false;
continue main;
case 38:
if (this._lastPos < i)
this._key += chunk.latin1Slice(this._lastPos, i);
this._lastPos = ++i;
this._key = this._decoder(this._key, this._encode);
this._encode = 0;
if (this._bytesKey > 0) {
this.emit(
"field",
this._key,
"",
{
nameTruncated: this._keyTrunc,
valueTruncated: false,
encoding: this.charset,
mimeType: "text/plain"
}
);
}
this._key = "";
this._val = "";
this._keyTrunc = false;
this._valTrunc = false;
this._bytesKey = 0;
this._bytesVal = 0;
if (++this._fields >= this.fieldsLimit) {
this.emit("fieldsLimit");
return cb();
}
continue;
case 43:
if (this._lastPos < i)
this._key += chunk.latin1Slice(this._lastPos, i);
this._key += " ";
this._lastPos = i + 1;
break;
case 37:
if (this._encode === 0)
this._encode = 1;
if (this._lastPos < i)
this._key += chunk.latin1Slice(this._lastPos, i);
this._lastPos = i + 1;
this._byte = -1;
i = readPctEnc(this, chunk, i + 1, len);
if (i === -1)
return cb(new Error("Malformed urlencoded form"));
if (i >= len)
return cb();
++this._bytesKey;
i = skipKeyBytes(this, chunk, i, len);
continue;
}
++i;
++this._bytesKey;
i = skipKeyBytes(this, chunk, i, len);
}
if (this._lastPos < i)
this._key += chunk.latin1Slice(this._lastPos, i);
} else {
i = skipValBytes(this, chunk, i, len);
while (i < len) {
switch (chunk[i]) {
case 38:
if (this._lastPos < i)
this._val += chunk.latin1Slice(this._lastPos, i);
this._lastPos = ++i;
this._inKey = true;
this._val = this._decoder(this._val, this._encode);
this._encode = 0;
if (this._bytesKey > 0 || this._bytesVal > 0) {
this.emit(
"field",
this._key,
this._val,
{
nameTruncated: this._keyTrunc,
valueTruncated: this._valTrunc,
encoding: this.charset,
mimeType: "text/plain"
}
);
}
this._key = "";
this._val = "";
this._keyTrunc = false;
this._valTrunc = false;
this._bytesKey = 0;
this._bytesVal = 0;
if (++this._fields >= this.fieldsLimit) {
this.emit("fieldsLimit");
return cb();
}
continue main;
case 43:
if (this._lastPos < i)
this._val += chunk.latin1Slice(this._lastPos, i);
this._val += " ";
this._lastPos = i + 1;
break;
case 37:
if (this._encode === 0)
this._encode = 1;
if (this._lastPos < i)
this._val += chunk.latin1Slice(this._lastPos, i);
this._lastPos = i + 1;
this._byte = -1;
i = readPctEnc(this, chunk, i + 1, len);
if (i === -1)
return cb(new Error("Malformed urlencoded form"));
if (i >= len)
return cb();
++this._bytesVal;
i = skipValBytes(this, chunk, i, len);
continue;
}
++i;
++this._bytesVal;
i = skipValBytes(this, chunk, i, len);
}
if (this._lastPos < i)
this._val += chunk.latin1Slice(this._lastPos, i);
}
}
cb();
}
_final(cb) {
if (this._byte !== -2)
return cb(new Error("Malformed urlencoded form"));
if (!this._inKey || this._bytesKey > 0 || this._bytesVal > 0) {
if (this._inKey)
this._key = this._decoder(this._key, this._encode);
else
this._val = this._decoder(this._val, this._encode);
this.emit(
"field",
this._key,
this._val,
{
nameTruncated: this._keyTrunc,
valueTruncated: this._valTrunc,
encoding: this.charset,
mimeType: "text/plain"
}
);
}
cb();
}
};
function readPctEnc(self, chunk, pos, len) {
if (pos >= len)
return len;
if (self._byte === -1) {
const hexUpper = HEX_VALUES[chunk[pos++]];
if (hexUpper === -1)
return -1;
if (hexUpper >= 8)
self._encode = 2;
if (pos < len) {
const hexLower = HEX_VALUES[chunk[pos++]];
if (hexLower === -1)
return -1;
if (self._inKey)
self._key += String.fromCharCode((hexUpper << 4) + hexLower);
else
self._val += String.fromCharCode((hexUpper << 4) + hexLower);
self._byte = -2;
self._lastPos = pos;
} else {
self._byte = hexUpper;
}
} else {
const hexLower = HEX_VALUES[chunk[pos++]];
if (hexLower === -1)
return -1;
if (self._inKey)
self._key += String.fromCharCode((self._byte << 4) + hexLower);
else
self._val += String.fromCharCode((self._byte << 4) + hexLower);
self._byte = -2;
self._lastPos = pos;
}
return pos;
}
function skipKeyBytes(self, chunk, pos, len) {
if (self._bytesKey > self.fieldNameSizeLimit) {
if (!self._keyTrunc) {
if (self._lastPos < pos)
self._key += chunk.latin1Slice(self._lastPos, pos - 1);
}
self._keyTrunc = true;
for (; pos < len; ++pos) {
const code = chunk[pos];
if (code === 61 || code === 38)
break;
++self._bytesKey;
}
self._lastPos = pos;
}
return pos;
}
function skipValBytes(self, chunk, pos, len) {
if (self._bytesVal > self.fieldSizeLimit) {
if (!self._valTrunc) {
if (self._lastPos < pos)
self._val += chunk.latin1Slice(self._lastPos, pos - 1);
}
self._valTrunc = true;
for (; pos < len; ++pos) {
if (chunk[pos] === 38)
break;
++self._bytesVal;
}
self._lastPos = pos;
}
return pos;
}
var HEX_VALUES = [
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
10,
11,
12,
13,
14,
15,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
10,
11,
12,
13,
14,
15,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1
];
module2.exports = URLEncoded;
}
});
// ../../../usr/share/nodejs/busboy/lib/index.js
var require_lib = __commonJS({
"../../../usr/share/nodejs/busboy/lib/index.js"(exports2, module2) {
"use strict";
var { parseContentType } = require_utils();
function getInstance(cfg) {
const headers = cfg.headers;
const conType = parseContentType(headers["content-type"]);
if (!conType)
throw new Error("Malformed content type");
for (const type of TYPES) {
const matched = type.detect(conType);
if (!matched)
continue;
const instanceCfg = {
limits: cfg.limits,
headers,
conType,
highWaterMark: void 0,
fileHwm: void 0,
defCharset: void 0,
defParamCharset: void 0,
preservePath: false
};
if (cfg.highWaterMark)
instanceCfg.highWaterMark = cfg.highWaterMark;
if (cfg.fileHwm)
instanceCfg.fileHwm = cfg.fileHwm;
instanceCfg.defCharset = cfg.defCharset;
instanceCfg.defParamCharset = cfg.defParamCharset;
instanceCfg.preservePath = cfg.preservePath;
return new type(instanceCfg);
}
throw new Error(`Unsupported content type: ${headers["content-type"]}`);
}
var TYPES = [
require_multipart(),
require_urlencoded()
].filter(function(typemod) {
return typeof typemod.detect === "function";
});
module2.exports = (cfg) => {
if (typeof cfg !== "object" || cfg === null)
cfg = {};
if (typeof cfg.headers !== "object" || cfg.headers === null || typeof cfg.headers["content-type"] !== "string") {
throw new Error("Missing Content-Type");
}
return getInstance(cfg);
};
}
});
// lib/fetch/dataURL.js
var require_dataURL = __commonJS({
"lib/fetch/dataURL.js"(exports2, module2) {
var assert = require("assert");
var { atob: atob2 } = require("buffer");
var { format } = require("url");
var { isValidHTTPToken, isomorphicDecode } = require_util2();
var encoder = new TextEncoder();
function dataURLProcessor(dataURL) {
assert(dataURL.protocol === "data:");
let input = URLSerializer(dataURL, true);
input = input.slice(5);
const position = { position: 0 };
let mimeType = collectASequenceOfCodePoints(
(char) => char !== ",",
input,
position
);
const mimeTypeLength = mimeType.length;
mimeType = mimeType.replace(/^(\u0020)+|(\u0020)+$/g, "");
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 };
}
function URLSerializer(url, excludeFragment = false) {
return format(url, { fragment: !excludeFragment });
}
function collectASequenceOfCodePoints(condition, input, position) {
let result = "";
while (position.position < input.length && condition(input[position.position])) {
result += input[position.position];
position.position++;
}
return result;
}
function stringPercentDecode(input) {
const bytes = encoder.encode(input);
return percentDecode(bytes);
}
function percentDecode(input) {
const output = [];
for (let i = 0; i < input.length; i++) {
const byte = input[i];
if (byte !== 37) {
output.push(byte);
} else if (byte === 37 && !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i + 1], input[i + 2]))) {
output.push(37);
} else {
const nextTwoBytes = String.fromCharCode(input[i + 1], input[i + 2]);
const bytePoint = Number.parseInt(nextTwoBytes, 16);
output.push(bytePoint);
i += 2;
}
}
return Uint8Array.from(output);
}
function parseMIMEType(input) {
input = input.trim();
const position = { position: 0 };
const type = collectASequenceOfCodePoints(
(char) => char !== "/",
input,
position
);
if (type.length === 0 || !/^[!#$%&'*+-.^_|~A-z0-9]+$/.test(type)) {
return "failure";
}
if (position.position > input.length) {
return "failure";
}
position.position++;
let subtype = collectASequenceOfCodePoints(
(char) => char !== ";",
input,
position
);
subtype = subtype.trimEnd();
if (subtype.length === 0 || !/^[!#$%&'*+-.^_|~A-z0-9]+$/.test(subtype)) {
return "failure";
}
const mimeType = {
type: type.toLowerCase(),
subtype: subtype.toLowerCase(),
/** @type {Map<string, string>} */
parameters: /* @__PURE__ */ new Map(),
// https://mimesniff.spec.whatwg.org/#mime-type-essence
get essence() {
return `${this.type}/${this.subtype}`;
}
};
while (position.position < input.length) {
position.position++;
collectASequenceOfCodePoints(
// https://fetch.spec.whatwg.org/#http-whitespace
(char) => /(\u000A|\u000D|\u0009|\u0020)/.test(char),
// eslint-disable-line
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);
collectASequenceOfCodePoints(
(char) => char !== ";",
input,
position
);
} else {
parameterValue = collectASequenceOfCodePoints(
(char) => char !== ";",
input,
position
);
parameterValue = parameterValue.trimEnd();
if (parameterValue.length === 0) {
continue;
}
}
if (parameterName.length !== 0 && /^[!#$%&'*+-.^_|~A-z0-9]+$/.test(parameterName) && // https://mimesniff.spec.whatwg.org/#http-quoted-string-token-code-point
!/^(\u0009|\x{0020}-\x{007E}|\x{0080}-\x{00FF})+$/.test(parameterValue) && // eslint-disable-line
!mimeType.parameters.has(parameterName)) {
mimeType.parameters.set(parameterName, parameterValue);
}
}
return mimeType;
}
function forgivingBase64(data) {
data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, "");
if (data.length % 4 === 0) {
data = data.replace(/=?=$/, "");
}
if (data.length % 4 === 1) {
return "failure";
}
if (/[^+/0-9A-Za-z]/.test(data)) {
return "failure";
}
const binary = atob2(data);
const bytes = new Uint8Array(binary.length);
for (let byte = 0; byte < binary.length; byte++) {
bytes[byte] = binary.charCodeAt(byte);
}
return bytes;
}
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);
}
function serializeAMimeType(mimeType) {
assert(mimeType !== "failure");
const { type, subtype, parameters } = mimeType;
let serialization = `${type}/${subtype}`;
for (let [name, value] of parameters.entries()) {
serialization += ";";
serialization += name;
serialization += "=";
if (!isValidHTTPToken(value)) {
value = value.replace(/(\\|")/g, "\\$1");
value = '"' + value;
value += '"';
}
serialization += value;
}
return serialization;
}
module2.exports = {
dataURLProcessor,
URLSerializer,
collectASequenceOfCodePoints,
stringPercentDecode,
parseMIMEType,
collectAnHTTPQuotedString,
serializeAMimeType
};
}
});
// lib/fetch/file.js
var require_file = __commonJS({
"lib/fetch/file.js"(exports2, module2) {
"use strict";
var { Blob: Blob2, File: NativeFile } = require("buffer");
var { types } = require("util");
var { kState } = require_symbols2();
var { isBlobLike } = require_util2();
var { webidl } = require_webidl();
var { parseMIMEType, serializeAMimeType } = require_dataURL();
var { kEnumerableProperty } = require_util();
var File = class extends Blob2 {
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 {
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(new TextEncoder().encode(s));
} else if (types.isAnyArrayBuffer(element) || types.isTypedArray(element)) {
if (!element.buffer) {
bytes.push(new Uint8Array(element));
} else {
bytes.push(
new Uint8Array(element.buffer, element.byteOffset, element.byteLength)
);
}
} else if (isBlobLike(element)) {
bytes.push(element);
}
}
return bytes;
}
function convertLineEndingsNative(s) {
let nativeLineEnding = "\n";
if (process.platform === "win32") {
nativeLineEnding = "\r\n";
}
return s.replace(/\r?\n/g, nativeLineEnding);
}
function isFileLike(object) {
return NativeFile && object instanceof NativeFile || object instanceof File || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File";
}
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 { File: UndiciFile, FileLike, isFileLike } = require_file();
var { webidl } = require_webidl();
var { Blob: Blob2, File: NativeFile } = require("buffer");
var File = NativeFile ?? UndiciFile;
var FormData = class {
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);
const next = [];
for (const entry of this[kState]) {
if (entry.name !== name) {
next.push(entry);
}
}
this[kState] = next;
}
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].map((pair) => [pair.name, pair.value]),
"FormData",
"key+value"
);
}
keys() {
webidl.brandCheck(this, FormData);
return makeIterator(
() => this[kState].map((pair) => [pair.name, pair.value]),
"FormData",
"key"
);
}
values() {
webidl.brandCheck(this, FormData);
return makeIterator(
() => this[kState].map((pair) => [pair.name, pair.value]),
"FormData",
"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.apply(thisArg, [value, key, this]);
}
}
};
FormData.prototype[Symbol.iterator] = FormData.prototype.entries;
Object.defineProperties(FormData.prototype, {
[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 Blob2 ? 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 = value instanceof File ? new File([value], filename, options) : new FileLike(value, filename, options);
}
}
return { name, value };
}
module2.exports = { FormData };
}
});
// lib/fetch/body.js
var require_body = __commonJS({
"lib/fetch/body.js"(exports2, module2) {
"use strict";
var Busboy = require_lib();
var util = require_util();
var {
ReadableStreamFrom,
isBlobLike,
isReadableStreamLike,
readableStreamClose,
createDeferredPromise,
fullyReadBody
} = require_util2();
var { FormData } = require_formdata();
var { kState } = require_symbols2();
var { webidl } = require_webidl();
var { DOMException, structuredClone } = require_constants();
var { Blob: Blob2, File: NativeFile } = require("buffer");
var { kBodyUsed } = require_symbols();
var assert = require("assert");
var { isErrored } = require_util();
var { isUint8Array, isArrayBuffer } = require("util/types");
var { File: UndiciFile } = require_file();
var { parseMIMEType, serializeAMimeType } = require_dataURL();
var ReadableStream = globalThis.ReadableStream;
var File = NativeFile ?? UndiciFile;
function extractBody(object, keepalive = false) {
if (!ReadableStream) {
ReadableStream = require("stream/web").ReadableStream;
}
let stream = null;
if (object instanceof ReadableStream) {
stream = object;
} else if (isBlobLike(object)) {
stream = object.stream();
} else {
stream = new ReadableStream({
async pull(controller) {
controller.enqueue(
typeof source === "string" ? new TextEncoder().encode(source) : source
);
queueMicrotask(() => readableStreamClose(controller));
},
start() {
},
type: void 0
});
}
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-${Math.random()}`.replace(".", "").slice(0, 32);
const prefix = `--${boundary}\r
Content-Disposition: form-data`;
const escape = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n");
const enc = new TextEncoder();
const blobParts = [];
const rn = new Uint8Array([13, 10]);
length = 0;
for (const [name, value] of object) {
if (typeof value === "string") {
const chunk2 = enc.encode(prefix + `; name="${escape(normalizeLinefeeds(name))}"\r
\r
${normalizeLinefeeds(value)}\r
`);
blobParts.push(chunk2);
length += chunk2.byteLength;
} else {
const chunk2 = enc.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);
length += chunk2.byteLength + value.size + rn.byteLength;
}
}
const chunk = enc.encode(`--${boundary}--`);
blobParts.push(chunk);
length += chunk.byteLength;
source = object;
action = async function* () {
for (const part of blobParts) {
if (part.stream) {
yield* part.stream();
} else {
yield part;
}
}
};
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();
});
} else {
if (!isErrored(stream)) {
controller.enqueue(new Uint8Array(value));
}
}
return controller.desiredSize > 0;
},
async cancel(reason) {
await iterator.return();
},
type: void 0
});
}
const body = { stream, source, length };
return [body, type];
}
function safelyExtractBody(object, keepalive = false) {
if (!ReadableStream) {
ReadableStream = require("stream/web").ReadableStream;
}
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);
}
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
};
}
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;
}
}
}
function throwIfAborted(state) {
if (state.aborted) {
throw new DOMException("The operation was aborted.", "AbortError");
}
}
function bodyMixinMethods(instance) {
const methods = {
blob() {
return specConsumeBody(this, (bytes) => {
let mimeType = bodyMimeType(this);
if (mimeType === "failure") {
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 contentType = this.headers.get("Content-Type");
if (/multipart\/form-data/.test(contentType)) {
const headers = {};
for (const [key, value] of this.headers)
headers[key.toLowerCase()] = value;
const responseFormData = new FormData();
let busboy;
try {
busboy = Busboy({
headers,
defParamCharset: "utf8"
});
} catch (err) {
throw new DOMException(`${err}`, "AbortError");
}
busboy.on("field", (name, value) => {
responseFormData.append(name, value);
});
busboy.on("file", (name, value, info) => {
const { filename, encoding, mimeType } = info;
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: mimeType }));
});
} else {
value.on("data", (chunk) => {
chunks.push(chunk);
});
value.on("end", () => {
responseFormData.append(name, new File(chunks, filename, { type: mimeType }));
});
}
});
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 (/application\/x-www-form-urlencoded/.test(contentType)) {
let entries;
try {
let text = "";
const textDecoder = 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 += textDecoder.decode(chunk, { stream: true });
}
text += textDecoder.decode();
entries = new URLSearchParams(text);
} catch (err) {
throw Object.assign(new TypeError(), { 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;
}
function mixinBody(prototype) {
Object.assign(prototype.prototype, bodyMixinMethods(prototype));
}
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 = (error) => promise.reject(error);
const successSteps = (data) => {
try {
promise.resolve(convertBytesToJSValue(data));
} catch (e) {
errorSteps(e);
}
};
if (object[kState].body == null) {
successSteps(new Uint8Array());
return promise.promise;
}
fullyReadBody(object[kState].body, successSteps, errorSteps);
return promise.promise;
}
function bodyUnusable(body) {
return body != null && (body.stream.locked || util.isDisturbed(body.stream));
}
function utf8DecodeBytes(buffer) {
if (buffer.length === 0) {
return "";
}
if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
buffer = buffer.subarray(3);
}
const output = new TextDecoder().decode(buffer);
return output;
}
function parseJSONFromBytes(bytes) {
return JSON.parse(utf8DecodeBytes(bytes));
}
function bodyMimeType(object) {
const { headersList } = object[kState];
const contentType = headersList.get("content-type");
if (contentType === null) {
return "failure";
}
return parseMIMEType(contentType);
}
module2.exports = {
extractBody,
safelyExtractBody,
cloneBody,
mixinBody
};
}
});
// 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];
}
function setGlobalOrigin(newOrigin) {
if (newOrigin !== void 0 && typeof newOrigin !== "string" && !(newOrigin instanceof URL)) {
throw new Error("Invalid base url");
}
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
});
}
module2.exports = {
getGlobalOrigin,
setGlobalOrigin
};
}
});
// 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 {
redirectStatus,
nullBodyStatus,
DOMException
} = require_constants();
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 } = require_symbols();
var assert = require("assert");
var { types } = require("util");
var ReadableStream = globalThis.ReadableStream || require("stream/web").ReadableStream;
var Response = class {
// Creates network error Response.
static error() {
const relevantRealm = { settingsObject: {} };
const responseObject = new Response();
responseObject[kState] = makeNetworkError();
responseObject[kRealm] = relevantRealm;
responseObject[kHeaders][kHeadersList] = responseObject[kState].headersList;
responseObject[kHeaders][kGuard] = "immutable";
responseObject[kHeaders][kRealm] = relevantRealm;
return responseObject;
}
// https://fetch.spec.whatwg.org/#dom-response-json
static json(data = void 0, init = {}) {
webidl.argumentLengthCheck(arguments, 1, { header: "Response.json" });
if (init !== null) {
init = webidl.converters.ResponseInit(init);
}
const bytes = new TextEncoder("utf-8").encode(
serializeJavascriptValueToJSONString(data)
);
const body = extractBody(bytes);
const relevantRealm = { settingsObject: {} };
const responseObject = new Response();
responseObject[kRealm] = relevantRealm;
responseObject[kHeaders][kGuard] = "response";
responseObject[kHeaders][kRealm] = 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 Object.assign(new TypeError("Failed to parse URL from " + url), {
cause: err
});
}
if (!redirectStatus.includes(status)) {
throw new RangeError("Invalid status code " + status);
}
const responseObject = new Response();
responseObject[kRealm] = relevantRealm;
responseObject[kHeaders][kGuard] = "immutable";
responseObject[kHeaders][kRealm] = relevantRealm;
responseObject[kState].status = status;
const value = isomorphicEncode(URLSerializer(parsedURL));
responseObject[kState].headersList.append("location", value);
return responseObject;
}
// https://fetch.spec.whatwg.org/#dom-response
constructor(body = null, init = {}) {
if (body !== null) {
body = webidl.converters.BodyInit(body);
}
init = webidl.converters.ResponseInit(init);
this[kRealm] = { settingsObject: {} };
this[kState] = makeResponse({});
this[kHeaders] = new Headers();
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 && this.body.locked) {
throw webidl.errors.exception({
header: "Response.clone",
message: "Body has already been consumed."
});
}
const clonedResponse = cloneResponse(this[kState]);
const clonedResponseObject = new Response();
clonedResponseObject[kState] = clonedResponse;
clonedResponseObject[kRealm] = this[kRealm];
clonedResponseObject[kHeaders][kHeadersList] = clonedResponse.headersList;
clonedResponseObject[kHeaders][kGuard] = this[kHeaders][kGuard];
clonedResponseObject[kHeaders][kRealm] = this[kHeaders][kRealm];
return clonedResponseObject;
}
};
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;
}
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] : []
};
}
function makeNetworkError(reason) {
const isError = isErrorLike(reason);
return makeResponse({
type: "error",
status: 0,
error: isError ? reason : new Error(reason ? String(reason) : reason, {
cause: isError ? reason : void 0
}),
aborted: reason && reason.name === "AbortError"
});
}
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;
}
});
}
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);
}
}
function makeAppropriateNetworkError(fetchParams) {
assert(isCancelled(fetchParams));
return isAborted(fetchParams) ? makeNetworkError(new DOMException("The operation was aborted.", "AbortError")) : makeNetworkError("Request was cancelled.");
}
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[kState].headersList, 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")) {
response[kState].headersList.append("content-type", body.type);
}
}
}
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 (types.isAnyArrayBuffer(V) || types.isTypedArray(V) || types.isDataView(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 = {
makeNetworkError,
makeResponse,
makeAppropriateNetworkError,
filterResponse,
Response
};
}
});
// 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 {
constructor(value) {
this.value = value;
}
deref() {
return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value;
}
};
var CompatFinalizer = class {
constructor(finalizer) {
this.finalizer = finalizer;
}
register(dispatcher, key) {
dispatcher.on("disconnect", () => {
if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) {
this.finalizer(key);
}
});
}
};
module2.exports = function() {
return {
WeakRef: global.WeakRef || CompatWeakRef,
FinalizationRegistry: global.FinalizationRegistry || CompatFinalizer
};
};
}
});
// 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 } = require_dispatcher_weakref()();
var util = require_util();
var {
isValidHTTPToken,
sameOrigin,
normalizeMethod
} = require_util2();
var {
forbiddenMethods,
corsSafeListedMethods,
referrerPolicy,
requestRedirect,
requestMode,
requestCredentials,
requestCache,
requestDuplex
} = require_constants();
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 } = require_symbols();
var assert = require("assert");
var TransformStream = globalThis.TransformStream;
var kInit = Symbol("init");
var requestFinalizer = new FinalizationRegistry(({ signal, abort }) => {
signal.removeEventListener("abort", abort);
});
var Request = class {
// https://fetch.spec.whatwg.org/#dom-request
constructor(input, init = {}) {
if (input === kInit) {
return;
}
webidl.argumentLengthCheck(arguments, 1, { header: "Request constructor" });
input = webidl.converters.RequestInfo(input);
init = webidl.converters.RequestInit(init);
this[kRealm] = {
settingsObject: {
baseUrl: getGlobalOrigin()
}
};
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 !== void 0 && init.window != null) {
throw new TypeError(`'window' option '${window}' must be null`);
}
if (init.window !== void 0) {
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]
});
if (Object.keys(init).length > 0) {
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 });
}
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 !== void 0 && 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;
if (!isValidHTTPToken(init.method)) {
throw TypeError(`'${init.method}' is not a valid HTTP method.`);
}
if (forbiddenMethods.indexOf(method.toUpperCase()) !== -1) {
throw TypeError(`'${init.method}' HTTP method is unsupported.`);
}
method = normalizeMethod(init.method);
request.method = method;
}
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 {
const acRef = new WeakRef(ac);
const abort = function() {
acRef.deref()?.abort(this.reason);
};
signal.addEventListener("abort", abort, { once: true });
requestFinalizer.register(this, { signal, abort });
}
}
this[kHeaders] = new Headers();
this[kHeaders][kHeadersList] = request.headersList;
this[kHeaders][kGuard] = "request";
this[kHeaders][kRealm] = this[kRealm];
if (mode === "no-cors") {
if (!corsSafeListedMethods.includes(request.method)) {
throw new TypeError(
`'${request.method} is unsupported in no-cors mode.`
);
}
this[kHeaders][kGuard] = "request-no-cors";
}
if (Object.keys(init).length !== 0) {
let headers = new Headers(this[kHeaders]);
if (init.headers !== void 0) {
headers = init.headers;
}
this[kHeaders][kHeadersList].clear();
if (headers.constructor.name === "Headers") {
for (const [key, val] of headers) {
this[kHeaders].append(key, val);
}
} else {
fillHeaders(this[kHeaders], headers);
}
}
const inputBody = input instanceof Request ? input[kState].body : null;
if ((init.body !== void 0 && 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 !== void 0 && init.body != null) {
const [extractedBody, contentType] = extractBody(
init.body,
request.keepalive
);
initBody = extractedBody;
if (contentType && !this[kHeaders][kHeadersList].contains("content-type")) {
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."
);
}
if (!TransformStream) {
TransformStream = require("stream/web").TransformStream;
}
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 clonedRequestObject = new Request(kInit);
clonedRequestObject[kState] = clonedRequest;
clonedRequestObject[kRealm] = this[kRealm];
clonedRequestObject[kHeaders] = new Headers();
clonedRequestObject[kHeaders][kHeadersList] = clonedRequest.headersList;
clonedRequestObject[kHeaders][kGuard] = this[kHeaders][kGuard];
clonedRequestObject[kHeaders][kRealm] = this[kHeaders][kRealm];
const ac = new AbortController();
if (this.signal.aborted) {
ac.abort(this.signal.reason);
} else {
this.signal.addEventListener(
"abort",
() => {
ac.abort(this.signal.reason);
},
{ once: true }
);
}
clonedRequestObject[kSignal] = ac.signal;
return clonedRequestObject;
}
};
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;
}
function cloneRequest(request) {
const newRequest = makeRequest({ ...request, body: null });
if (request.body != null) {
newRequest.body = cloneBody(request.body);
}
return newRequest;
}
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 };
}
});
// lib/core/request.js
var require_request2 = __commonJS({
"lib/core/request.js"(exports2, module2) {
"use strict";
var {
InvalidArgumentError,
NotSupportedError
} = require_errors();
var assert = require("assert");
var util = require_util();
var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
var invalidPathRegex = /[^\u0021-\u00ff]/;
var kHandler = Symbol("handler");
var channels = {};
var extractBody;
var nodeVersion = process.versions.node.split(".");
var nodeMajor = Number(nodeVersion[0]);
var nodeMinor = Number(nodeVersion[1]);
try {
const diagnosticsChannel = require("diagnostics_channel");
channels.create = diagnosticsChannel.channel("undici:request:create");
channels.bodySent = diagnosticsChannel.channel("undici:request:bodySent");
channels.headers = diagnosticsChannel.channel("undici:request:headers");
channels.trailers = diagnosticsChannel.channel("undici:request:trailers");
channels.error = diagnosticsChannel.channel("undici:request:error");
} catch {
channels.create = { hasSubscribers: false };
channels.bodySent = { hasSubscribers: false };
channels.headers = { hasSubscribers: false };
channels.trailers = { hasSubscribers: false };
channels.error = { hasSubscribers: false };
}
var Request = class {
constructor(origin, {
path,
method,
body,
headers,
query,
idempotent,
blocking,
upgrade,
headersTimeout,
bodyTimeout,
reset,
throwOnError
}, handler) {
if (typeof path !== "string") {
throw new InvalidArgumentError("path must be a string");
} else if (path[0] !== "/" && !(path.startsWith("http://") || path.startsWith("https://")) && method !== "CONNECT") {
throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
} else if (invalidPathRegex.exec(path) !== null) {
throw new InvalidArgumentError("invalid request path");
}
if (typeof method !== "string") {
throw new InvalidArgumentError("method must be a string");
} else if (tokenRegExp.exec(method) === null) {
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");
}
this.headersTimeout = headersTimeout;
this.bodyTimeout = bodyTimeout;
this.throwOnError = throwOnError === true;
this.method = method;
if (body == null) {
this.body = null;
} else if (util.isStream(body)) {
this.body = body;
} 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 ? false : reset;
this.host = null;
this.contentLength = null;
this.contentType = null;
this.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(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 (nodeMajor < 16 || nodeMajor === 16 && nodeMinor < 8) {
throw new InvalidArgumentError("Form-Data bodies are only supported in node v16.8 and newer.");
}
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;
} 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 {
this[kHandler].onBodySent(chunk);
} catch (err) {
this.onError(err);
}
}
}
onRequestSent() {
if (channels.bodySent.hasSubscribers) {
channels.bodySent.publish({ request: this });
}
}
onConnect(abort) {
assert(!this.aborted);
assert(!this.completed);
return this[kHandler].onConnect(abort);
}
onHeaders(statusCode, headers, resume, statusText) {
assert(!this.aborted);
assert(!this.completed);
if (channels.headers.hasSubscribers) {
channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
}
return this[kHandler].onHeaders(statusCode, headers, resume, statusText);
}
onData(chunk) {
assert(!this.aborted);
assert(!this.completed);
return this[kHandler].onData(chunk);
}
onUpgrade(statusCode, headers, socket) {
assert(!this.aborted);
assert(!this.completed);
return this[kHandler].onUpgrade(statusCode, headers, socket);
}
onComplete(trailers) {
assert(!this.aborted);
this.completed = true;
if (channels.trailers.hasSubscribers) {
channels.trailers.publish({ request: this, trailers });
}
return this[kHandler].onComplete(trailers);
}
onError(error) {
if (channels.error.hasSubscribers) {
channels.error.publish({ request: this, error });
}
if (this.aborted) {
return;
}
this.aborted = true;
return this[kHandler].onError(error);
}
addHeader(key, value) {
processHeader(this, key, value);
return this;
}
};
function processHeaderValue(key, val) {
if (val && (typeof val === "object" && !Array.isArray(val))) {
throw new InvalidArgumentError(`invalid ${key} header`);
} else if (headerCharRegex.exec(val) !== null) {
throw new InvalidArgumentError(`invalid ${key} header`);
}
return `${key}: ${val}\r
`;
}
function processHeader(request, key, val) {
if (val && (typeof val === "object" && !Array.isArray(val))) {
throw new InvalidArgumentError(`invalid ${key} header`);
} else if (val === void 0) {
return;
}
if (request.host === null && key.length === 4 && key.toLowerCase() === "host") {
if (headerCharRegex.exec(val) !== null) {
throw new InvalidArgumentError(`invalid ${key} header`);
}
request.host = val;
} else if (request.contentLength === null && key.length === 14 && key.toLowerCase() === "content-length") {
request.contentLength = parseInt(val, 10);
if (!Number.isFinite(request.contentLength)) {
throw new InvalidArgumentError("invalid content-length header");
}
} else if (request.contentType === null && key.length === 12 && key.toLowerCase() === "content-type" && headerCharRegex.exec(val) === null) {
request.contentType = val;
request.headers += `${key}: ${val}\r
`;
} else if (key.length === 17 && key.toLowerCase() === "transfer-encoding") {
throw new InvalidArgumentError("invalid transfer-encoding header");
} else if (key.length === 10 && key.toLowerCase() === "connection") {
const value = val.toLowerCase();
if (value !== "close" && value !== "keep-alive") {
throw new InvalidArgumentError("invalid connection header");
} else if (value === "close") {
request.reset = true;
}
} else if (key.length === 10 && key.toLowerCase() === "keep-alive") {
throw new InvalidArgumentError("invalid keep-alive header");
} else if (key.length === 7 && key.toLowerCase() === "upgrade") {
throw new InvalidArgumentError("invalid upgrade header");
} else if (key.length === 6 && key.toLowerCase() === "expect") {
throw new NotSupportedError("expect header not supported");
} else if (tokenRegExp.exec(key) === null) {
throw new InvalidArgumentError("invalid header key");
} else {
if (Array.isArray(val)) {
for (let i = 0; i < val.length; i++) {
request.headers += processHeaderValue(key, val[i]);
}
} else {
request.headers += processHeaderValue(key, val);
}
}
}
module2.exports = Request;
}
});
// lib/dispatcher.js
var require_dispatcher = __commonJS({
"lib/dispatcher.js"(exports2, module2) {
"use strict";
var EventEmitter = require("events");
var Dispatcher = class extends EventEmitter {
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 {
constructor() {
super();
this[kDestroyed] = false;
this[kOnDestroyed] = [];
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 = () => {
const callbacks = this[kOnClosed];
this[kOnClosed] = null;
for (let i = 0; i < callbacks.length; i++) {
callbacks[i](null, null);
}
};
this[kClose]().then(() => this.destroy()).then(() => {
queueMicrotask(onClosed);
});
}
destroy(err, callback) {
if (typeof err === "function") {
callback = err;
err = null;
}
if (callback === void 0) {
return new Promise((resolve, reject) => {
this.destroy(err, (err2, data) => {
return err2 ? (
/* 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].push(callback);
const onDestroyed = () => {
const callbacks = this[kOnDestroyed];
this[kOnDestroyed] = null;
for (let i = 0; i < callbacks.length; i++) {
callbacks[i](null, null);
}
};
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]) {
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/core/connect.js
var require_connect = __commonJS({
"lib/core/connect.js"(exports2, module2) {
"use strict";
var net = require("net");
var assert = require("assert");
var util = require_util();
var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
var tls;
var SessionCache;
if (global.FinalizationRegistry) {
SessionCache = class WeakSessionCache {
constructor(maxCachedSessions) {
this._maxCachedSessions = maxCachedSessions;
this._sessionCache = /* @__PURE__ */ new Map();
this._sessionRegistry = new global.FinalizationRegistry((key) => {
if (this._sessionCache.size < this._maxCachedSessions) {
return;
}
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 {
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({ 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;
return function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
let socket;
if (protocol === "https:") {
if (!tls) {
tls = require("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,
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
});
}
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;
};
}
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);
};
}
function onConnectTimeout(socket) {
util.destroy(socket, new ConnectTimeoutError());
}
module2.exports = buildConnector;
}
});
// lib/llhttp/utils.js
var require_utils2 = __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;
}
exports2.enumToMap = enumToMap;
}
});
// lib/llhttp/constants.js
var require_constants2 = __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_utils2();
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("assert");
var { InvalidArgumentError } = require_errors();
var EE = require("events");
var redirectableStatusCodes = [300, 301, 302, 303, 307, 308];
var kBody = Symbol("body");
var BodyAsyncIterable = class {
constructor(body) {
this[kBody] = body;
this[kBodyUsed] = false;
}
async *[Symbol.asyncIterator]() {
assert(!this[kBodyUsed], "disturbed");
this[kBodyUsed] = true;
yield* this[kBody];
}
};
var RedirectHandler = class {
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 = [];
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.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].toString().toLowerCase() === "location") {
return headers[i + 1];
}
}
}
function shouldRemoveHeader(header, removeContent, unknownOrigin) {
return header.length === 4 && header.toString().toLowerCase() === "host" || removeContent && header.toString().toLowerCase().indexOf("content-") === 0 || unknownOrigin && header.length === 13 && header.toString().toLowerCase() === "authorization" || unknownOrigin && header.length === 6 && header.toString().toLowerCase() === "cookie";
}
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;
}
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 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);
};
};
}
module2.exports = createRedirectInterceptor;
}
});
// lib/llhttp/llhttp.wasm.js
var require_llhttp_wasm = __commonJS({
"lib/llhttp/llhttp.wasm.js"(exports2, module2) {
module2.exports = "AGFzbQEAAAABMAhgAX8Bf2ADf39/AX9gBH9/f38Bf2AAAGABfwBgA39/fwBgAn9/AGAGf39/f39/ AALLAQgDZW52GHdhc21fb25faGVhZGVyc19jb21wbGV0ZQACA2VudhV3YXNtX29uX21lc3NhZ2Vf YmVnaW4AAANlbnYLd2FzbV9vbl91cmwAAQNlbnYOd2FzbV9vbl9zdGF0dXMAAQNlbnYUd2FzbV9v bl9oZWFkZXJfZmllbGQAAQNlbnYUd2FzbV9vbl9oZWFkZXJfdmFsdWUAAQNlbnYMd2FzbV9vbl9i b2R5AAEDZW52GHdhc21fb25fbWVzc2FnZV9jb21wbGV0ZQAAA0ZFAwMDAAEAAAQEBQAABAAAAAAA AAQBBAAEBAQAAAYAAAAABgYGBgEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQAAAQEHBAUBcAES EgUDAQACBggBfwFBgNQECwfRBSIGbWVtb3J5AgALX2luaXRpYWxpemUACRlfX2luZGlyZWN0X2Z1 bmN0aW9uX3RhYmxlAQAGbWFsbG9jAA0EZnJlZQAPC2xsaHR0cF9pbml0ABEYbGxodHRwX3Nob3Vs ZF9rZWVwX2FsaXZlAEgMbGxodHRwX2FsbG9jABMLbGxodHRwX2ZyZWUAFA9sbGh0dHBfZ2V0X3R5 cGUAFRVsbGh0dHBfZ2V0X2h0dHBfbWFqb3IAFhVsbGh0dHBfZ2V0X2h0dHBfbWlub3IAFxFsbGh0 dHBfZ2V0X21ldGhvZAAYFmxsaHR0cF9nZXRfc3RhdHVzX2NvZGUAGRJsbGh0dHBfZ2V0X3VwZ3Jh ZGUAGgxsbGh0dHBfcmVzZXQAGw5sbGh0dHBfZXhlY3V0ZQAcFGxsaHR0cF9zZXR0aW5nc19pbml0 AB0NbGxodHRwX2ZpbmlzaAAeDGxsaHR0cF9wYXVzZQAfDWxsaHR0cF9yZXN1bWUAIBtsbGh0dHBf cmVzdW1lX2FmdGVyX3VwZ3JhZGUAIRBsbGh0dHBfZ2V0X2Vycm5vACIXbGxodHRwX2dldF9lcnJv cl9yZWFzb24AIxdsbGh0dHBfc2V0X2Vycm9yX3JlYXNvbgAkFGxsaHR0cF9nZXRfZXJyb3JfcG9z ACURbGxodHRwX2Vycm5vX25hbWUAJhJsbGh0dHBfbWV0aG9kX25hbWUAJxJsbGh0dHBfc3RhdHVz X25hbWUAKBpsbGh0dHBfc2V0X2xlbmllbnRfaGVhZGVycwApIWxsaHR0cF9zZXRfbGVuaWVudF9j aHVua2VkX2xlbmd0aAAqHWxsaHR0cF9zZXRfbGVuaWVudF9rZWVwX2FsaXZlACskbGxodHRwX3Nl dF9sZW5pZW50X3RyYW5zZmVyX2VuY29kaW5nACwYbGxodHRwX21lc3NhZ2VfbmVlZHNfZW9mAEYJ FwEAQQELEQECAwQFEgYHPEA+ODY0LjIwCrLbAkUCAAsIABCIgICAAAsEAAAAC04AAkAgAA0APwBB EHQPCwJAIABB//8DcQ0AIABBf0wNAAJAIABBEHZAACIAQX9HDQBBAEEwNgKI0ICAAEF/DwsgAEEQ dA8LEIqAgIAAAAv7AgIDfwF+AkAgAkUNACAAIAE6AAAgAiAAaiIDQX9qIAE6AAAgAkEDSQ0AIAAg AToAAiAAIAE6AAEgA0F9aiABOgAAIANBfmogAToAACACQQdJDQAgACABOgADIANBfGogAToAACAC QQlJDQAgAEEAIABrQQNxIgRqIgMgAUH/AXFBgYKECGwiATYCACADIAIgBGtBfHEiBGoiAkF8aiAB NgIAIARBCUkNACADIAE2AgggAyABNgIEIAJBeGogATYCACACQXRqIAE2AgAgBEEZSQ0AIAMgATYC GCADIAE2AhQgAyABNgIQIAMgATYCDCACQXBqIAE2AgAgAkFsaiABNgIAIAJBaGogATYCACACQWRq IAE2AgAgBCADQQRxQRhyIgVrIgJBIEkNACABrUKBgICAEH4hBiADIAVqIQEDQCABIAY3AwAgAUEY aiAGNwMAIAFBEGogBjcDACABQQhqIAY3AwAgAUEgaiEBIAJBYGoiAkEfSw0ACwsgAAsKACAAEI6A gIAAC4Y3AQt/I4CAgIAAQRBrIgEkgICAgAACQEEAKAKk0ICAAA0AQQAQi4CAgABBgNSEgABrIgJB 2QBJDQBBACEDAkBBACgC5NOAgAAiBA0AQQBCfzcC8NOAgABBAEKAgISAgIDAADcC6NOAgABBACAB QQhqQXBxQdiq1aoFcyIENgLk04CAAEEAQQA2AvjTgIAAQQBBADYCyNOAgAALQQAgAjYC0NOAgABB AEGA1ISAADYCzNOAgABBAEGA1ISAADYCnNCAgABBACAENgKw0ICAAEEAQX82AqzQgIAAA0AgA0HI 0ICAAGogA0G80ICAAGoiBDYCACAEIANBtNCAgABqIgU2AgAgA0HA0ICAAGogBTYCACADQdDQgIAA aiADQcTQgIAAaiIFNgIAIAUgBDYCACADQdjQgIAAaiADQczQgIAAaiIENgIAIAQgBTYCACADQdTQ gIAAaiAENgIAIANBIGoiA0GAAkcNAAtBgNSEgABBeEGA1ISAAGtBD3FBAEGA1ISAAEEIakEPcRsi A2oiBEEEaiACQUhqIgUgA2siA0EBcjYCAEEAQQAoAvTTgIAANgKo0ICAAEEAIAM2ApjQgIAAQQAg BDYCpNCAgABBgNSEgAAgBWpBODYCBAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAEHsAUsNAAJA QQAoAozQgIAAIgZBECAAQRNqQXBxIABBC0kbIgJBA3YiBHYiA0EDcUUNACADQQFxIARyQQFzIgVB A3QiAEG80ICAAGooAgAiBEEIaiEDAkACQCAEKAIIIgIgAEG00ICAAGoiAEcNAEEAIAZBfiAFd3E2 AozQgIAADAELIAAgAjYCCCACIAA2AgwLIAQgBUEDdCIFQQNyNgIEIAQgBWoiBCAEKAIEQQFyNgIE DAwLIAJBACgClNCAgAAiB00NAQJAIANFDQACQAJAIAMgBHRBAiAEdCIDQQAgA2tycSIDQQAgA2tx QX9qIgMgA0EMdkEQcSIDdiIEQQV2QQhxIgUgA3IgBCAFdiIDQQJ2QQRxIgRyIAMgBHYiA0EBdkEC cSIEciADIAR2IgNBAXZBAXEiBHIgAyAEdmoiBUEDdCIAQbzQgIAAaigCACIEKAIIIgMgAEG00ICA AGoiAEcNAEEAIAZBfiAFd3EiBjYCjNCAgAAMAQsgACADNgIIIAMgADYCDAsgBEEIaiEDIAQgAkED cjYCBCAEIAVBA3QiBWogBSACayIFNgIAIAQgAmoiACAFQQFyNgIEAkAgB0UNACAHQQN2IghBA3RB tNCAgABqIQJBACgCoNCAgAAhBAJAAkAgBkEBIAh0IghxDQBBACAGIAhyNgKM0ICAACACIQgMAQsg AigCCCEICyAIIAQ2AgwgAiAENgIIIAQgAjYCDCAEIAg2AggLQQAgADYCoNCAgABBACAFNgKU0ICA AAwMC0EAKAKQ0ICAACIJRQ0BIAlBACAJa3FBf2oiAyADQQx2QRBxIgN2IgRBBXZBCHEiBSADciAE IAV2IgNBAnZBBHEiBHIgAyAEdiIDQQF2QQJxIgRyIAMgBHYiA0EBdkEBcSIEciADIAR2akECdEG8 0oCAAGooAgAiACgCBEF4cSACayEEIAAhBQJAA0ACQCAFKAIQIgMNACAFQRRqKAIAIgNFDQILIAMo AgRBeHEgAmsiBSAEIAUgBEkiBRshBCADIAAgBRshACADIQUMAAsLIAAoAhghCgJAIAAoAgwiCCAA Rg0AQQAoApzQgIAAIAAoAggiA0saIAggAzYCCCADIAg2AgwMCwsCQCAAQRRqIgUoAgAiAw0AIAAo AhAiA0UNAyAAQRBqIQULA0AgBSELIAMiCEEUaiIFKAIAIgMNACAIQRBqIQUgCCgCECIDDQALIAtB ADYCAAwKC0F/IQIgAEG/f0sNACAAQRNqIgNBcHEhAkEAKAKQ0ICAACIHRQ0AQQAhCwJAIAJBgAJJ DQBBHyELIAJB////B0sNACADQQh2IgMgA0GA/j9qQRB2QQhxIgN0IgQgBEGA4B9qQRB2QQRxIgR0 IgUgBUGAgA9qQRB2QQJxIgV0QQ92IAMgBHIgBXJrIgNBAXQgAiADQRVqdkEBcXJBHGohCwtBACAC ayEEAkACQAJAAkAgC0ECdEG80oCAAGooAgAiBQ0AQQAhA0EAIQgMAQtBACEDIAJBAEEZIAtBAXZr IAtBH0YbdCEAQQAhCANAAkAgBSgCBEF4cSACayIGIARPDQAgBiEEIAUhCCAGDQBBACEEIAUhCCAF IQMMAwsgAyAFQRRqKAIAIgYgBiAFIABBHXZBBHFqQRBqKAIAIgVGGyADIAYbIQMgAEEBdCEAIAUN AAsLAkAgAyAIcg0AQQAhCEECIAt0IgNBACADa3IgB3EiA0UNAyADQQAgA2txQX9qIgMgA0EMdkEQ cSIDdiIFQQV2QQhxIgAgA3IgBSAAdiIDQQJ2QQRxIgVyIAMgBXYiA0EBdkECcSIFciADIAV2IgNB AXZBAXEiBXIgAyAFdmpBAnRBvNKAgABqKAIAIQMLIANFDQELA0AgAygCBEF4cSACayIGIARJIQAC QCADKAIQIgUNACADQRRqKAIAIQULIAYgBCAAGyEEIAMgCCAAGyEIIAUhAyAFDQALCyAIRQ0AIARB ACgClNCAgAAgAmtPDQAgCCgCGCELAkAgCCgCDCIAIAhGDQBBACgCnNCAgAAgCCgCCCIDSxogACAD NgIIIAMgADYCDAwJCwJAIAhBFGoiBSgCACIDDQAgCCgCECIDRQ0DIAhBEGohBQsDQCAFIQYgAyIA QRRqIgUoAgAiAw0AIABBEGohBSAAKAIQIgMNAAsgBkEANgIADAgLAkBBACgClNCAgAAiAyACSQ0A QQAoAqDQgIAAIQQCQAJAIAMgAmsiBUEQSQ0AIAQgAmoiACAFQQFyNgIEQQAgBTYClNCAgABBACAA NgKg0ICAACAEIANqIAU2AgAgBCACQQNyNgIEDAELIAQgA0EDcjYCBCAEIANqIgMgAygCBEEBcjYC BEEAQQA2AqDQgIAAQQBBADYClNCAgAALIARBCGohAwwKCwJAQQAoApjQgIAAIgAgAk0NAEEAKAKk 0ICAACIDIAJqIgQgACACayIFQQFyNgIEQQAgBTYCmNCAgABBACAENgKk0ICAACADIAJBA3I2AgQg A0EIaiEDDAoLAkACQEEAKALk04CAAEUNAEEAKALs04CAACEEDAELQQBCfzcC8NOAgABBAEKAgISA gIDAADcC6NOAgABBACABQQxqQXBxQdiq1aoFczYC5NOAgABBAEEANgL404CAAEEAQQA2AsjTgIAA QYCABCEEC0EAIQMCQCAEIAJBxwBqIgdqIgZBACAEayILcSIIIAJLDQBBAEEwNgKI0ICAAAwKCwJA QQAoAsTTgIAAIgNFDQACQEEAKAK804CAACIEIAhqIgUgBE0NACAFIANNDQELQQAhA0EAQTA2AojQ gIAADAoLQQAtAMjTgIAAQQRxDQQCQAJAAkBBACgCpNCAgAAiBEUNAEHM04CAACEDA0ACQCADKAIA IgUgBEsNACAFIAMoAgRqIARLDQMLIAMoAggiAw0ACwtBABCLgICAACIAQX9GDQUgCCEGAkBBACgC 6NOAgAAiA0F/aiIEIABxRQ0AIAggAGsgBCAAakEAIANrcWohBgsgBiACTQ0FIAZB/v///wdLDQUC QEEAKALE04CAACIDRQ0AQQAoArzTgIAAIgQgBmoiBSAETQ0GIAUgA0sNBgsgBhCLgICAACIDIABH DQEMBwsgBiAAayALcSIGQf7///8HSw0EIAYQi4CAgAAiACADKAIAIAMoAgRqRg0DIAAhAwsCQCAD QX9GDQAgAkHIAGogBk0NAAJAIAcgBmtBACgC7NOAgAAiBGpBACAEa3EiBEH+////B00NACADIQAM BwsCQCAEEIuAgIAAQX9GDQAgBCAGaiEGIAMhAAwHC0EAIAZrEIuAgIAAGgwECyADIQAgA0F/Rw0F DAMLQQAhCAwHC0EAIQAMBQsgAEF/Rw0CC0EAQQAoAsjTgIAAQQRyNgLI04CAAAsgCEH+////B0sN ASAIEIuAgIAAIQBBABCLgICAACEDIABBf0YNASADQX9GDQEgACADTw0BIAMgAGsiBiACQThqTQ0B C0EAQQAoArzTgIAAIAZqIgM2ArzTgIAAAkAgA0EAKALA04CAAE0NAEEAIAM2AsDTgIAACwJAAkAC QAJAQQAoAqTQgIAAIgRFDQBBzNOAgAAhAwNAIAAgAygCACIFIAMoAgQiCGpGDQIgAygCCCIDDQAM AwsLAkACQEEAKAKc0ICAACIDRQ0AIAAgA08NAQtBACAANgKc0ICAAAtBACEDQQAgBjYC0NOAgABB ACAANgLM04CAAEEAQX82AqzQgIAAQQBBACgC5NOAgAA2ArDQgIAAQQBBADYC2NOAgAADQCADQcjQ gIAAaiADQbzQgIAAaiIENgIAIAQgA0G00ICAAGoiBTYCACADQcDQgIAAaiAFNgIAIANB0NCAgABq IANBxNCAgABqIgU2AgAgBSAENgIAIANB2NCAgABqIANBzNCAgABqIgQ2AgAgBCAFNgIAIANB1NCA gABqIAQ2AgAgA0EgaiIDQYACRw0ACyAAQXggAGtBD3FBACAAQQhqQQ9xGyIDaiIEIAZBSGoiBSAD ayIDQQFyNgIEQQBBACgC9NOAgAA2AqjQgIAAQQAgAzYCmNCAgABBACAENgKk0ICAACAAIAVqQTg2 AgQMAgsgAy0ADEEIcQ0AIAUgBEsNACAAIARNDQAgBEF4IARrQQ9xQQAgBEEIakEPcRsiBWoiAEEA KAKY0ICAACAGaiILIAVrIgVBAXI2AgQgAyAIIAZqNgIEQQBBACgC9NOAgAA2AqjQgIAAQQAgBTYC mNCAgABBACAANgKk0ICAACAEIAtqQTg2AgQMAQsCQCAAQQAoApzQgIAAIghPDQBBACAANgKc0ICA ACAAIQgLIAAgBmohBUHM04CAACEDAkACQAJAAkACQAJAAkADQCADKAIAIAVGDQEgAygCCCIDDQAM AgsLIAMtAAxBCHFFDQELQczTgIAAIQMDQAJAIAMoAgAiBSAESw0AIAUgAygCBGoiBSAESw0DCyAD KAIIIQMMAAsLIAMgADYCACADIAMoAgQgBmo2AgQgAEF4IABrQQ9xQQAgAEEIakEPcRtqIgsgAkED cjYCBCAFQXggBWtBD3FBACAFQQhqQQ9xG2oiBiALIAJqIgJrIQUCQCAEIAZHDQBBACACNgKk0ICA AEEAQQAoApjQgIAAIAVqIgM2ApjQgIAAIAIgA0EBcjYCBAwDCwJAQQAoAqDQgIAAIAZHDQBBACAC NgKg0ICAAEEAQQAoApTQgIAAIAVqIgM2ApTQgIAAIAIgA0EBcjYCBCACIANqIAM2AgAMAwsCQCAG KAIEIgNBA3FBAUcNACADQXhxIQcCQAJAIANB/wFLDQAgBigCCCIEIANBA3YiCEEDdEG00ICAAGoi AEYaAkAgBigCDCIDIARHDQBBAEEAKAKM0ICAAEF+IAh3cTYCjNCAgAAMAgsgAyAARhogAyAENgII IAQgAzYCDAwBCyAGKAIYIQkCQAJAIAYoAgwiACAGRg0AIAggBigCCCIDSxogACADNgIIIAMgADYC DAwBCwJAIAZBFGoiAygCACIEDQAgBkEQaiIDKAIAIgQNAEEAIQAMAQsDQCADIQggBCIAQRRqIgMo AgAiBA0AIABBEGohAyAAKAIQIgQNAAsgCEEANgIACyAJRQ0AAkACQCAGKAIcIgRBAnRBvNKAgABq IgMoAgAgBkcNACADIAA2AgAgAA0BQQBBACgCkNCAgABBfiAEd3E2ApDQgIAADAILIAlBEEEUIAko AhAgBkYbaiAANgIAIABFDQELIAAgCTYCGAJAIAYoAhAiA0UNACAAIAM2AhAgAyAANgIYCyAGKAIU IgNFDQAgAEEUaiADNgIAIAMgADYCGAsgByAFaiEFIAYgB2ohBgsgBiAGKAIEQX5xNgIEIAIgBWog BTYCACACIAVBAXI2AgQCQCAFQf8BSw0AIAVBA3YiBEEDdEG00ICAAGohAwJAAkBBACgCjNCAgAAi BUEBIAR0IgRxDQBBACAFIARyNgKM0ICAACADIQQMAQsgAygCCCEECyAEIAI2AgwgAyACNgIIIAIg AzYCDCACIAQ2AggMAwtBHyEDAkAgBUH///8HSw0AIAVBCHYiAyADQYD+P2pBEHZBCHEiA3QiBCAE QYDgH2pBEHZBBHEiBHQiACAAQYCAD2pBEHZBAnEiAHRBD3YgAyAEciAAcmsiA0EBdCAFIANBFWp2 QQFxckEcaiEDCyACIAM2AhwgAkIANwIQIANBAnRBvNKAgABqIQQCQEEAKAKQ0ICAACIAQQEgA3Qi CHENACAEIAI2AgBBACAAIAhyNgKQ0ICAACACIAQ2AhggAiACNgIIIAIgAjYCDAwDCyAFQQBBGSAD QQF2ayADQR9GG3QhAyAEKAIAIQADQCAAIgQoAgRBeHEgBUYNAiADQR12IQAgA0EBdCEDIAQgAEEE cWpBEGoiCCgCACIADQALIAggAjYCACACIAQ2AhggAiACNgIMIAIgAjYCCAwCCyAAQXggAGtBD3FB ACAAQQhqQQ9xGyIDaiILIAZBSGoiCCADayIDQQFyNgIEIAAgCGpBODYCBCAEIAVBNyAFa0EPcUEA IAVBSWpBD3EbakFBaiIIIAggBEEQakkbIghBIzYCBEEAQQAoAvTTgIAANgKo0ICAAEEAIAM2ApjQ gIAAQQAgCzYCpNCAgAAgCEEQakEAKQLU04CAADcCACAIQQApAszTgIAANwIIQQAgCEEIajYC1NOA gABBACAGNgLQ04CAAEEAIAA2AszTgIAAQQBBADYC2NOAgAAgCEEkaiEDA0AgA0EHNgIAIAUgA0EE aiIDSw0ACyAIIARGDQMgCCAIKAIEQX5xNgIEIAggCCAEayIGNgIAIAQgBkEBcjYCBAJAIAZB/wFL DQAgBkEDdiIFQQN0QbTQgIAAaiEDAkACQEEAKAKM0ICAACIAQQEgBXQiBXENAEEAIAAgBXI2AozQ gIAAIAMhBQwBCyADKAIIIQULIAUgBDYCDCADIAQ2AgggBCADNgIMIAQgBTYCCAwEC0EfIQMCQCAG Qf///wdLDQAgBkEIdiIDIANBgP4/akEQdkEIcSIDdCIFIAVBgOAfakEQdkEEcSIFdCIAIABBgIAP akEQdkECcSIAdEEPdiADIAVyIAByayIDQQF0IAYgA0EVanZBAXFyQRxqIQMLIARCADcCECAEQRxq IAM2AgAgA0ECdEG80oCAAGohBQJAQQAoApDQgIAAIgBBASADdCIIcQ0AIAUgBDYCAEEAIAAgCHI2 ApDQgIAAIARBGGogBTYCACAEIAQ2AgggBCAENgIMDAQLIAZBAEEZIANBAXZrIANBH0YbdCEDIAUo AgAhAANAIAAiBSgCBEF4cSAGRg0DIANBHXYhACADQQF0IQMgBSAAQQRxakEQaiIIKAIAIgANAAsg CCAENgIAIARBGGogBTYCACAEIAQ2AgwgBCAENgIIDAMLIAQoAggiAyACNgIMIAQgAjYCCCACQQA2 AhggAiAENgIMIAIgAzYCCAsgC0EIaiEDDAULIAUoAggiAyAENgIMIAUgBDYCCCAEQRhqQQA2AgAg BCAFNgIMIAQgAzYCCAtBACgCmNCAgAAiAyACTQ0AQQAoAqTQgIAAIgQgAmoiBSADIAJrIgNBAXI2 AgRBACADNgKY0ICAAEEAIAU2AqTQgIAAIAQgAkEDcjYCBCAEQQhqIQMMAwtBACEDQQBBMDYCiNCA gAAMAgsCQCALRQ0AAkACQCAIIAgoAhwiBUECdEG80oCAAGoiAygCAEcNACADIAA2AgAgAA0BQQAg B0F+IAV3cSIHNgKQ0ICAAAwCCyALQRBBFCALKAIQIAhGG2ogADYCACAARQ0BCyAAIAs2AhgCQCAI KAIQIgNFDQAgACADNgIQIAMgADYCGAsgCEEUaigCACIDRQ0AIABBFGogAzYCACADIAA2AhgLAkAC QCAEQQ9LDQAgCCAEIAJqIgNBA3I2AgQgCCADaiIDIAMoAgRBAXI2AgQMAQsgCCACaiIAIARBAXI2 AgQgCCACQQNyNgIEIAAgBGogBDYCAAJAIARB/wFLDQAgBEEDdiIEQQN0QbTQgIAAaiEDAkACQEEA KAKM0ICAACIFQQEgBHQiBHENAEEAIAUgBHI2AozQgIAAIAMhBAwBCyADKAIIIQQLIAQgADYCDCAD IAA2AgggACADNgIMIAAgBDYCCAwBC0EfIQMCQCAEQf///wdLDQAgBEEIdiIDIANBgP4/akEQdkEI cSIDdCIFIAVBgOAfakEQdkEEcSIFdCICIAJBgIAPakEQdkECcSICdEEPdiADIAVyIAJyayIDQQF0 IAQgA0EVanZBAXFyQRxqIQMLIAAgAzYCHCAAQgA3AhAgA0ECdEG80oCAAGohBQJAIAdBASADdCIC cQ0AIAUgADYCAEEAIAcgAnI2ApDQgIAAIAAgBTYCGCAAIAA2AgggACAANgIMDAELIARBAEEZIANB AXZrIANBH0YbdCEDIAUoAgAhAgJAA0AgAiIFKAIEQXhxIARGDQEgA0EddiECIANBAXQhAyAFIAJB BHFqQRBqIgYoAgAiAg0ACyAGIAA2AgAgACAFNgIYIAAgADYCDCAAIAA2AggMAQsgBSgCCCIDIAA2 AgwgBSAANgIIIABBADYCGCAAIAU2AgwgACADNgIICyAIQQhqIQMMAQsCQCAKRQ0AAkACQCAAIAAo AhwiBUECdEG80oCAAGoiAygCAEcNACADIAg2AgAgCA0BQQAgCUF+IAV3cTYCkNCAgAAMAgsgCkEQ QRQgCigCECAARhtqIAg2AgAgCEUNAQsgCCAKNgIYAkAgACgCECIDRQ0AIAggAzYCECADIAg2AhgL IABBFGooAgAiA0UNACAIQRRqIAM2AgAgAyAINgIYCwJAAkAgBEEPSw0AIAAgBCACaiIDQQNyNgIE IAAgA2oiAyADKAIEQQFyNgIEDAELIAAgAmoiBSAEQQFyNgIEIAAgAkEDcjYCBCAFIARqIAQ2AgAC QCAHRQ0AIAdBA3YiCEEDdEG00ICAAGohAkEAKAKg0ICAACEDAkACQEEBIAh0IgggBnENAEEAIAgg BnI2AozQgIAAIAIhCAwBCyACKAIIIQgLIAggAzYCDCACIAM2AgggAyACNgIMIAMgCDYCCAtBACAF NgKg0ICAAEEAIAQ2ApTQgIAACyAAQQhqIQMLIAFBEGokgICAgAAgAwsKACAAEJCAgIAAC/ANAQd/ AkAgAEUNACAAQXhqIgEgAEF8aigCACICQXhxIgBqIQMCQCACQQFxDQAgAkEDcUUNASABIAEoAgAi AmsiAUEAKAKc0ICAACIESQ0BIAIgAGohAAJAQQAoAqDQgIAAIAFGDQACQCACQf8BSw0AIAEoAggi BCACQQN2IgVBA3RBtNCAgABqIgZGGgJAIAEoAgwiAiAERw0AQQBBACgCjNCAgABBfiAFd3E2AozQ gIAADAMLIAIgBkYaIAIgBDYCCCAEIAI2AgwMAgsgASgCGCEHAkACQCABKAIMIgYgAUYNACAEIAEo AggiAksaIAYgAjYCCCACIAY2AgwMAQsCQCABQRRqIgIoAgAiBA0AIAFBEGoiAigCACIEDQBBACEG DAELA0AgAiEFIAQiBkEUaiICKAIAIgQNACAGQRBqIQIgBigCECIEDQALIAVBADYCAAsgB0UNAQJA AkAgASgCHCIEQQJ0QbzSgIAAaiICKAIAIAFHDQAgAiAGNgIAIAYNAUEAQQAoApDQgIAAQX4gBHdx NgKQ0ICAAAwDCyAHQRBBFCAHKAIQIAFGG2ogBjYCACAGRQ0CCyAGIAc2AhgCQCABKAIQIgJFDQAg BiACNgIQIAIgBjYCGAsgASgCFCICRQ0BIAZBFGogAjYCACACIAY2AhgMAQsgAygCBCICQQNxQQNH DQAgAyACQX5xNgIEQQAgADYClNCAgAAgASAAaiAANgIAIAEgAEEBcjYCBA8LIAMgAU0NACADKAIE IgJBAXFFDQACQAJAIAJBAnENAAJAQQAoAqTQgIAAIANHDQBBACABNgKk0ICAAEEAQQAoApjQgIAA IABqIgA2ApjQgIAAIAEgAEEBcjYCBCABQQAoAqDQgIAARw0DQQBBADYClNCAgABBAEEANgKg0ICA AA8LAkBBACgCoNCAgAAgA0cNAEEAIAE2AqDQgIAAQQBBACgClNCAgAAgAGoiADYClNCAgAAgASAA QQFyNgIEIAEgAGogADYCAA8LIAJBeHEgAGohAAJAAkAgAkH/AUsNACADKAIIIgQgAkEDdiIFQQN0 QbTQgIAAaiIGRhoCQCADKAIMIgIgBEcNAEEAQQAoAozQgIAAQX4gBXdxNgKM0ICAAAwCCyACIAZG GiACIAQ2AgggBCACNgIMDAELIAMoAhghBwJAAkAgAygCDCIGIANGDQBBACgCnNCAgAAgAygCCCIC SxogBiACNgIIIAIgBjYCDAwBCwJAIANBFGoiAigCACIEDQAgA0EQaiICKAIAIgQNAEEAIQYMAQsD QCACIQUgBCIGQRRqIgIoAgAiBA0AIAZBEGohAiAGKAIQIgQNAAsgBUEANgIACyAHRQ0AAkACQCAD KAIcIgRBAnRBvNKAgABqIgIoAgAgA0cNACACIAY2AgAgBg0BQQBBACgCkNCAgABBfiAEd3E2ApDQ gIAADAILIAdBEEEUIAcoAhAgA0YbaiAGNgIAIAZFDQELIAYgBzYCGAJAIAMoAhAiAkUNACAGIAI2 AhAgAiAGNgIYCyADKAIUIgJFDQAgBkEUaiACNgIAIAIgBjYCGAsgASAAaiAANgIAIAEgAEEBcjYC BCABQQAoAqDQgIAARw0BQQAgADYClNCAgAAPCyADIAJBfnE2AgQgASAAaiAANgIAIAEgAEEBcjYC BAsCQCAAQf8BSw0AIABBA3YiAkEDdEG00ICAAGohAAJAAkBBACgCjNCAgAAiBEEBIAJ0IgJxDQBB ACAEIAJyNgKM0ICAACAAIQIMAQsgACgCCCECCyACIAE2AgwgACABNgIIIAEgADYCDCABIAI2AggP C0EfIQICQCAAQf///wdLDQAgAEEIdiICIAJBgP4/akEQdkEIcSICdCIEIARBgOAfakEQdkEEcSIE dCIGIAZBgIAPakEQdkECcSIGdEEPdiACIARyIAZyayICQQF0IAAgAkEVanZBAXFyQRxqIQILIAFC ADcCECABQRxqIAI2AgAgAkECdEG80oCAAGohBAJAAkBBACgCkNCAgAAiBkEBIAJ0IgNxDQAgBCAB NgIAQQAgBiADcjYCkNCAgAAgAUEYaiAENgIAIAEgATYCCCABIAE2AgwMAQsgAEEAQRkgAkEBdmsg AkEfRht0IQIgBCgCACEGAkADQCAGIgQoAgRBeHEgAEYNASACQR12IQYgAkEBdCECIAQgBkEEcWpB EGoiAygCACIGDQALIAMgATYCACABQRhqIAQ2AgAgASABNgIMIAEgATYCCAwBCyAEKAIIIgAgATYC DCAEIAE2AgggAUEYakEANgIAIAEgBDYCDCABIAA2AggLQQBBACgCrNCAgABBf2oiAUF/IAEbNgKs 0ICAAAsLGQAgABDJgICAABogACACNgI4IAAgAToAKAscACAAIAAvATIgAC0ALiAAEMiAgIAAEICA gIAACyoBAX9BwAAQjYCAgAAiARDJgICAABogAUGAiICAADYCOCABIAA6ACggAQsKACAAEI+AgIAA CwcAIAAtACgLBwAgAC0AKgsHACAALQArCwcAIAAtACkLBwAgAC8BMgsHACAALQAuC0UBBH8gACgC GCEBIAAtAC0hAiAALQAoIQMgACgCOCEEIAAQyYCAgAAaIAAgBDYCOCAAIAM6ACggACACOgAtIAAg ATYCGAsRACAAIAEgASACahDKgICAAAsQACAAQQBB3AAQjICAgAAaC2cBAX9BACEBAkAgACgCDA0A AkACQAJAAkAgAC0ALw4DAQADAgsgACgCOCIBRQ0AIAEoAiwiAUUNACAAIAERgICAgAAAIgENAwtB AA8LEIqAgIAAAAsgAEHDloCAADYCEEEOIQELIAELHgACQCAAKAIMDQAgAEHRm4CAADYCECAAQRU2 AgwLCxYAAkAgACgCDEEVRw0AIABBADYCDAsLFgACQCAAKAIMQRZHDQAgAEEANgIMCwsHACAAKAIM CwcAIAAoAhALCQAgACABNgIQCwcAIAAoAhQLIgACQCAAQSRJDQAQioCAgAAACyAAQQJ0QaCzgIAA aigCAAsiAAJAIABBLkkNABCKgICAAAALIABBAnRBsLSAgABqKAIAC+4LAQF/QeuogIAAIQECQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAQZx/ag70A2NiAAFhYWFhYWECAwQFYWFhYWFhYWFh YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFh YWFhYWFhYWFhYWFhYWFhYWFhYQYHCAkKCwwNDg9hYWFhYRBhYWFhYWFhYWFhYRFhYWFhYWFhYWFh YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFh YWFhYWESExQVFhcYGRobYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFh YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYRwdHh8gISIj JCUmJygpKissLS4vMDEyMzQ1NmE3ODk6YWFhYWFhYWE7YWFhPGFhYWE9Pj9hYWFhYWFhYUBhYUFh YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFCQ0RFRkdISUpLTE1OT1BRUlNhYWFhYWFhYVRV VldYWVpbYVxdYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhXmFhYWFhYWFhYWFhYWFhYWFh YWFhYWFhYWFhYWFhYWFhYWFhYV9gYQtB4aeAgAAPC0GkoYCAAA8LQcusgIAADwtB/rGAgAAPC0HA pICAAA8LQaukgIAADwtBjaiAgAAPC0HipoCAAA8LQYCwgIAADwtBua+AgAAPC0HXpICAAA8LQe+f gIAADwtB4Z+AgAAPC0H6n4CAAA8LQfKggIAADwtBqK+AgAAPC0GusoCAAA8LQYiwgIAADwtB7KeA gAAPC0GCooCAAA8LQY6dgIAADwtB0K6AgAAPC0HKo4CAAA8LQcWygIAADwtB35yAgAAPC0HSnICA AA8LQcSggIAADwtB16CAgAAPC0Gin4CAAA8LQe2ugIAADwtBq7CAgAAPC0HUpYCAAA8LQcyugIAA DwtB+q6AgAAPC0H8q4CAAA8LQdKwgIAADwtB8Z2AgAAPC0G7oICAAA8LQfergIAADwtBkLGAgAAP C0HXsYCAAA8LQaKtgIAADwtB1KeAgAAPC0Hgq4CAAA8LQZ+sgIAADwtB67GAgAAPC0HVn4CAAA8L QcqxgIAADwtB3qWAgAAPC0HUnoCAAA8LQfScgIAADwtBp7KAgAAPC0GxnYCAAA8LQaCdgIAADwtB ubGAgAAPC0G8sICAAA8LQZKhgIAADwtBs6aAgAAPC0HprICAAA8LQayegIAADwtB1KuAgAAPC0H3 poCAAA8LQYCmgIAADwtBsKGAgAAPC0H+noCAAA8LQY2jgIAADwtBia2AgAAPC0H3ooCAAA8LQaCx gIAADwtBrp+AgAAPC0HGpYCAAA8LQeiegIAADwtBk6KAgAAPC0HCr4CAAA8LQcOdgIAADwtBi6yA gAAPC0HhnYCAAA8LQY2vgIAADwtB6qGAgAAPC0G0rYCAAA8LQdKvgIAADwtB37KAgAAPC0HSsoCA AA8LQfCwgIAADwtBqaKAgAAPC0H5o4CAAA8LQZmegIAADwtBtayAgAAPC0GbsICAAA8LQZKygIAA DwtBtquAgAAPC0HCooCAAA8LQfiygIAADwtBnqWAgAAPC0HQooCAAA8LQbqegIAADwtBgZ6AgAAP CxCKgICAAAALQdahgIAAIQELIAELFgAgACAALQAtQf4BcSABQQBHcjoALQsZACAAIAAtAC1B/QFx IAFBAEdBAXRyOgAtCxkAIAAgAC0ALUH7AXEgAUEAR0ECdHI6AC0LGQAgACAALQAtQfcBcSABQQBH QQN0cjoALQsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIAIgRFDQAgACAEEYCAgIAAACEDCyADC0kB An9BACEDAkAgACgCOCIERQ0AIAQoAgQiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEHG kYCAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCMCIERQ0AIAAgBBGAgICAAAAh AwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIIIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/ Rw0AIABB9oqAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAjQiBEUNACAAIAQR gICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCDCIERQ0AIAAgASACIAFrIAQRgYCA gAAAIgNBf0cNACAAQe2agIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAI4IgRF DQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAhAiBEUNACAAIAEgAiAB ayAEEYGAgIAAACIDQX9HDQAgAEGVkICAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAg BCgCPCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIUIgRFDQAg ACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABBqpuAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgC OCIERQ0AIAQoAkAiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgC GCIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQe2TgIAANgIQQRghAwsgAwsuAQJ/QQAh AwJAIAAoAjgiBEUNACAEKAJEIgRFDQAgACAEEYCAgIAAACEDCyADCy4BAn9BACEDAkAgACgCOCIE RQ0AIAQoAiQiBEUNACAAIAQRgICAgAAAIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCLCIE RQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIoIgRFDQAgACABIAIg AWsgBBGBgICAAAAiA0F/Rw0AIABB9oiAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0A IAQoAlAiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCHCIERQ0A IAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQcKZgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAo AjgiBEUNACAEKAJIIgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQo AiAiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEGUlICAADYCEEEYIQMLIAMLLgECf0EA IQMCQCAAKAI4IgRFDQAgBCgCTCIERQ0AIAAgBBGAgICAAAAhAwsgAwsuAQJ/QQAhAwJAIAAoAjgi BEUNACAEKAJUIgRFDQAgACAEEYCAgIAAACEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAlgi BEUNACAAIAQRgICAgAAAIQMLIAMLRQEBfwJAAkAgAC8BMEEUcUEURw0AQQEhAyAALQAoQQFGDQEg AC8BMkHlAEYhAwwBCyAALQApQQVGIQMLIAAgAzoALkEAC/cBAQN/QQEhAwJAIAAvATAiBEEIcQ0A IAApAyBCAFIhAwsCQAJAIAAtAC5FDQBBASEFIAAtAClBBUYNAUEBIQUgBEHAAHFFIANxQQFHDQEL QQAhBSAEQcAAcQ0AQQIhBSAEQQhxDQACQCAEQYAEcUUNAAJAIAAtAChBAUcNACAALQAtQQpxDQBB BQ8LQQQPCwJAIARBIHENAAJAIAAtAChBAUYNACAALwEyQf//A3EiAEGcf2pB5ABJDQAgAEHMAUYN ACAAQbACRg0AQQQhBSAEQYgEcUGABEYNAiAEQShxRQ0CC0EADwtBAEEDIAApAyBQGyEFCyAFC2IB An9BACEBAkAgAC0AKEEBRg0AIAAvATJB//8DcSICQZx/akHkAEkNACACQcwBRg0AIAJBsAJGDQAg AC8BMCIAQcAAcQ0AQQEhASAAQYgEcUGABEYNACAAQShxRSEBCyABC6cBAQN/AkACQAJAIAAtACpF DQAgAC0AK0UNAEEAIQMgAC8BMCIEQQJxRQ0BDAILQQAhAyAALwEwIgRBAXFFDQELQQEhAyAALQAo QQFGDQAgAC8BMkH//wNxIgVBnH9qQeQASQ0AIAVBzAFGDQAgBUGwAkYNACAEQcAAcQ0AQQAhAyAE QYgEcUGABEYNACAEQShxQQBHIQMLIABBADsBMCAAQQA6AC8gAwuZAQECfwJAAkACQCAALQAqRQ0A IAAtACtFDQBBACEBIAAvATAiAkECcUUNAQwCC0EAIQEgAC8BMCICQQFxRQ0BC0EBIQEgAC0AKEEB Rg0AIAAvATJB//8DcSIAQZx/akHkAEkNACAAQcwBRg0AIABBsAJGDQAgAkHAAHENAEEAIQEgAkGI BHFBgARGDQAgAkEocUEARyEBCyABC1kAIABBGGpCADcDACAAQgA3AwAgAEE4akIANwMAIABBMGpC ADcDACAAQShqQgA3AwAgAEEgakIANwMAIABBEGpCADcDACAAQQhqQgA3AwAgAEHdATYCHEEAC3sB AX8CQCAAKAIMIgMNAAJAIAAoAgRFDQAgACABNgIECwJAIAAgASACEMuAgIAAIgMNACAAKAIMDwsg ACADNgIcQQAhAyAAKAIEIgFFDQAgACABIAIgACgCCBGBgICAAAAiAUUNACAAIAI2AhQgACABNgIM IAEhAwsgAwuw7gEDD38DfgJ/I4CAgIAAQRBrIgMkgICAgAAgASEEIAEhBSABIQYgASEHIAEhCCAB IQkgASEKIAEhCyABIQwgASENIAEhDiABIQ8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIcIhBBf2oO3QHaAQHZAQIDBAUGBwgJCgsMDQ7YAQ8Q 1wEREtYBExQVFhcYGRob4QHgARwdHtUBHyAhIiMkJdQBJicoKSorLNMB0gEtLtEB0AEvMDEyMzQ1 Njc4OTo7PD0+P0BBQkNERUbbAUdISUrPAc4BS80BTMwBTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNk ZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gAGBAYIBgwGEAYUBhgGHAYgBiQGKAYsBjAGNAY4B jwGQAZEBkgGTAZQBlQGWAZcBmAGZAZoBmwGcAZ0BngGfAaABoQGiAaMBpAGlAaYBpwGoAakBqgGr AawBrQGuAa8BsAGxAbIBswG0AbUBtgG3AcsBygG4AckBuQHIAboBuwG8Ab0BvgG/AcABwQHCAcMB xAHFAcYBANwBC0EAIRAMxgELQQ4hEAzFAQtBDSEQDMQBC0EPIRAMwwELQRAhEAzCAQtBEyEQDMEB C0EVIRAMwAELQRQhEAy/AQtBFiEQDL4BC0EXIRAMvQELQRghEAy8AQtBGSEQDLsBC0EaIRAMugEL QRshEAy5AQtBHCEQDLgBC0EIIRAMtwELQR0hEAy2AQtBICEQDLUBC0EfIRAMtAELQQchEAyzAQtB ISEQDLIBC0EiIRAMsQELQR4hEAywAQtBIyEQDK8BC0ESIRAMrgELQREhEAytAQtBJSEQDKwBC0Ek IRAMqwELQSYhEAyqAQtBJyEQDKkBC0HDASEQDKgBC0EoIRAMpwELQSkhEAymAQtBKiEQDKUBC0Er IRAMpAELQSwhEAyjAQtBLSEQDKIBC0EvIRAMoQELQS4hEAygAQtBMyEQDJ8BC0EMIRAMngELQTAh EAydAQtBMSEQDJwBC0EyIRAMmwELQTghEAyaAQtBNCEQDJkBC0HEASEQDJgBC0ELIRAMlwELQTkh EAyWAQtBNSEQDJUBC0EKIRAMlAELQTYhEAyTAQtBNyEQDJIBC0E7IRAMkQELQTohEAyQAQtBPCEQ DI8BC0EJIRAMjgELQT0hEAyNAQtBPiEQDIwBC0E/IRAMiwELQcAAIRAMigELQcEAIRAMiQELQcIA IRAMiAELQcMAIRAMhwELQcQAIRAMhgELQcUAIRAMhQELQcYAIRAMhAELQccAIRAMgwELQcgAIRAM ggELQcUBIRAMgQELQckAIRAMgAELQcoAIRAMfwtBywAhEAx+C0HNACEQDH0LQcwAIRAMfAtBzgAh EAx7C0HPACEQDHoLQdAAIRAMeQtB0QAhEAx4C0HSACEQDHcLQdMAIRAMdgtB1AAhEAx1C0HWACEQ DHQLQdUAIRAMcwtBBiEQDHILQdcAIRAMcQtBBSEQDHALQdgAIRAMbwtBBCEQDG4LQdkAIRAMbQtB 2gAhEAxsC0HbACEQDGsLQdwAIRAMagtBAyEQDGkLQd0AIRAMaAtB3gAhEAxnC0HfACEQDGYLQeEA IRAMZQtB4AAhEAxkC0HiACEQDGMLQeMAIRAMYgtBAiEQDGELQeQAIRAMYAtB5QAhEAxfC0HmACEQ DF4LQecAIRAMXQtB6AAhEAxcC0HpACEQDFsLQeoAIRAMWgtB6wAhEAxZC0HsACEQDFgLQe0AIRAM VwtB7gAhEAxWC0HvACEQDFULQfAAIRAMVAtB8QAhEAxTC0HyACEQDFILQfMAIRAMUQtB9AAhEAxQ C0H1ACEQDE8LQfYAIRAMTgtB9wAhEAxNC0H4ACEQDEwLQfkAIRAMSwtB+gAhEAxKC0H7ACEQDEkL QfwAIRAMSAtB/QAhEAxHC0H+ACEQDEYLQf8AIRAMRQtBgAEhEAxEC0GBASEQDEMLQYIBIRAMQgtB gwEhEAxBC0GEASEQDEALQYUBIRAMPwtBhgEhEAw+C0GHASEQDD0LQYgBIRAMPAtBiQEhEAw7C0GK ASEQDDoLQYsBIRAMOQtBjAEhEAw4C0GNASEQDDcLQY4BIRAMNgtBjwEhEAw1C0GQASEQDDQLQZEB IRAMMwtBkgEhEAwyC0GTASEQDDELQZQBIRAMMAtBlQEhEAwvC0GWASEQDC4LQZcBIRAMLQtBmAEh EAwsC0GZASEQDCsLQZoBIRAMKgtBmwEhEAwpC0GcASEQDCgLQZ0BIRAMJwtBngEhEAwmC0GfASEQ DCULQaABIRAMJAtBoQEhEAwjC0GiASEQDCILQaMBIRAMIQtBpAEhEAwgC0GlASEQDB8LQaYBIRAM HgtBpwEhEAwdC0GoASEQDBwLQakBIRAMGwtBqgEhEAwaC0GrASEQDBkLQawBIRAMGAtBrQEhEAwX C0GuASEQDBYLQQEhEAwVC0GvASEQDBQLQbABIRAMEwtBsQEhEAwSC0GzASEQDBELQbIBIRAMEAtB tAEhEAwPC0G1ASEQDA4LQbYBIRAMDQtBtwEhEAwMC0G4ASEQDAsLQbkBIRAMCgtBugEhEAwJC0G7 ASEQDAgLQcYBIRAMBwtBvAEhEAwGC0G9ASEQDAULQb4BIRAMBAtBvwEhEAwDC0HAASEQDAILQcIB IRAMAQtBwQEhEAsDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAC QAJAAkACQAJAAkACQAJAAkACQCAQDscBAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxweHyAh IyUoUlNUV1hZWltcXV5fYWJjZGX7A2lrbW5vcnN1dnd4eXp7fH1+gAGBAYMBhAGFAYYBhwGIAYkB igGLAYwBjQGOAY8BkAGSAZQBlwGYAZkBmgGcAZ0BngGfAaABoQGiAaUBpgGnAagBqQGqAasBrAGt Aa4BrwGwAbEBsgGzAbQBtQG2AbcBuAG5AboBuwG8Ab0BvgG/AcABwQHCAcMBxAHFAcYBxwHIAckB ygHLAcwBzQHOAc8B0AHRAdIB0wHUAdUB1gHXAdgB2QHaAdsB3AHdAd4B3wHgAeEB4gHjAeQB5QHm AecB6AHpAeoB6wHsAe0B7gHvAfEB8gHzAfQB9QH2AfcB+AH5AfoB+wH8Af0B/gH/AYACgQKCAoMC hAKnAr4C6AKPA48DCyABIgQgAkcNhAJB3QEhEAydBAsgASIQIAJHDe4BQcMBIRAMnAQLIAEiASAC Rw2hAUH3ACEQDJsECyABIgEgAkcNlwFB7wAhEAyaBAsgASIBIAJHDZEBQeoAIRAMmQQLIAEiASAC Rw2NAUHoACEQDJgECyABIgEgAkcNigFB5gAhEAyXBAsgASIBIAJHDRpBGCEQDJYECyABIgEgAkcN FEESIRAMlQQLIAEiASACRw1qQcUAIRAMlAQLIAEiASACRw1cQT8hEAyTBAsgASIBIAJHDVpBPCEQ DJIECyABIgEgAkcNU0ExIRAMkQQLIAAtAC5BAUYNiAQMlAILIAAgASIBIAIQx4CAgABBAUcN9wEg AEIANwMgDPgBCyAAIAEiASACELuAgIAAIhAN+AEgASEBDIkDC0EGIRAgASIBIAJGDY0EIAAgAUEB aiIBIAIQwoCAgAAiEA35ASABIQEMRAsgAEIANwMgQRIhEAzyAwtBHSEQIAEiESACRg2LBEIAIRIg ES0AAEFQag43iwKKAissLS4vMDEyjAKMAowCjAKMAowCjAIzNDU2NziMAowCjAKMAowCjAKMAowC jAKMAowCjAKMAowCjAKMAowCjAKMAowCjAKMAowCjAKMAowCOTo7PD0+jAILQQchECABIgEgAkYN igQgAUEBaiEBDIcDC0EJIRAgASIBIAJGDYkEIABBiYCAgAA2AgggACABNgIEIAEhAUEVIRAM7wML IABCACAAKQMgIhIgAiABIgFrrSITfSIUIBQgElYbNwMgIAEgASASp2oiFSASIBNWIhEbIRZBCCEQ IBENiAQgACgCBCEQIABBADYCBCAVIQEgACAQIBYQvICAgAAiEEUNhwMgAEEHNgIcIAAgFjYCFCAA IBA2AgwMhgQLIAEhASAAKQMgUA1oIAEhAQyHAwtBCyEQIAEiASACRg2GBCAAIAFBAWoiASACEL2A gIAAIhAN8wEgASEBDIcDCyAAIAEiASACEL+AgIAAIhAN8wEgASEBDIcDCyAAIAEiASACEL+AgIAA IhAN9AEgASEBDA0LIAAgASIBIAIQwYCAgAAiEA31ASABIQEMhQMLQQ8hECABIgEgAkYNggQgAS0A ACIQQTtGDQggEEENRw32ASABQQFqIQEMhAMLIAAgASIBIAIQwYCAgAAiEA32ASABIQEMhwMLA0AC QCABLQAAQfC1gIAAai0AACIQQQFGDQAgEEECRw35ASAAKAIEIRAgAEEANgIEIAAgECABQQFqIgEQ wICAgAAiEA34ASABIQEMiQMLIAFBAWoiASACRw0AC0ESIRAMgAQLIAAgASIBIAIQwYCAgAAiEA33 ASABIQEMCgtBGyEQIAEiASACRg3+AyABLQAAIhBBO0YNBiAQQQ1HDfwBIAFBAWohAQyAAwtBFiEQ IAEiASACRg39AyAAQYqAgIAANgIIIAAgATYCBCAAIAEgAhC/gICAACIQDfgBIAEhAUEgIRAM4wML AkAgASIBIAJGDQADQAJAIAEtAABB8LeAgABqLQAAIhBBAkYNAAJAIBBBf2oOBPMB+gEA+QH6AQsg AUEBaiEBQQghEAzlAwsgAUEBaiIBIAJHDQALQRUhEAz9AwtBFSEQDPwDCwNAAkAgAS0AAEHwuYCA AGotAAAiEEECRg0AIBBBf2oOBOwB+gHuAfkB+gELIAFBAWoiASACRw0AC0EYIRAM+wMLQRkhECAB IgEgAkYN+gMgAEGLgICAADYCCCAAIAE2AgQgASEBDPQCCyABQQFqIQEMAgtBGiEQIAEiESACRg34 AyARIQECQCARLQAAQXNqDhTuAoMDgwODA4MDgwODA4MDgwODA4MDgwODA4MDgwODA4MDgwODAwCD AwsgAEEANgIcIABBr4uAgAA2AhAgAEECNgIMIAAgEUEBajYCFAz2AwsgAUEBaiEBC0EiIRAM3AML QRwhECABIhEgAkYN9QNCACESIBEhASARLQAAQVBqDjf1AfQBAQIDBAUGBwgAAAAAAAAACQoLDA0O AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPEBESExQAC0EeIRAM2gMLQgIhEgzzAQtCAyESDPIB C0IEIRIM8QELQgUhEgzwAQtCBiESDO8BC0IHIRIM7gELQgghEgztAQtCCSESDOwBC0IKIRIM6wEL QgshEgzqAQtCDCESDOkBC0INIRIM6AELQg4hEgznAQtCDyESDOYBC0IKIRIM5QELQgshEgzkAQtC DCESDOMBC0INIRIM4gELQg4hEgzhAQtCDyESDOABC0ICIRIM3wELQgMhEgzeAQtCBCESDN0BC0IF IRIM3AELQgYhEgzbAQtCByESDNoBC0IIIRIM2QELQgkhEgzYAQtCCiESDNcBC0ILIRIM1gELQgwh EgzVAQtCDSESDNQBC0IOIRIM0wELQg8hEgzSAQtCCiESDNEBC0ILIRIM0AELQgwhEgzPAQtCDSES DM4BC0IOIRIMzQELQg8hEgzMAQtBICEQIAEiASACRg3LAyAAQYmAgIAANgIIIAAgATYCBCABIQFB JSEQDLEDCyAAQgAgACkDICISIAIgASIBa60iE30iFCAUIBJWGzcDICABIAEgEqdqIhUgEiATViIR GyEWQR8hECARDcoDIAAoAgQhECAAQQA2AgQgFSEBIAAgECAWELyAgIAAIhBFDcYCIABBBTYCHCAA IBY2AhQgACAQNgIMDMgDCyAAIAEiECACEMWAgIAAQX9qDgW0AQDHAgHLAcwBC0ERIRAMrgMLIABB AToALyAQIQEMxgMLQSQhECABIgEgAkYNxgMgAUEBaiEQIAAvATAiAUGAAXFFDc0BIAAgECACEMKA gIAAIgENzAEgECEBDMICCyAAIAEiASACELmAgIAAIhAN0AEgASEBDCkLQSghECABIgEgAkYNxAMg AEEANgIEIABBjICAgAA2AgggACABIAEQuICAgAAiEA3QASABIQEM1QELQSkhECABIhEgAkYNwwMg ES0AACIBQSBGDRUgAUEJRw3QASARQQFqIQEMFgtBKiEQIAEiASACRg3CAyABQQFqIQEMzwILQSsh ECABIhEgAkYNwQMCQCARLQAAIgFBCUYNACABQSBHDdIBCyAALQAsQQhGDdABIBEhAQydAwtBLCEQ IAEiASACRg3AAyABLQAAQQpHDdIBIAFBAWohAQzOAgtBLyEQIAEiDiACRg2/AyAOLQAAQQ1GDdIB IAAtAC1BAXFFDdQBQS8hEAylAwsgDiACRw3SAUEtIRAMvgMLA0ACQCABLQAAIhBBIEYNAAJAIBBB dmoOBADYAdgBANYBCyABIQEM3AELIAFBAWoiASACRw0AC0ExIRAMvQMLAkAgASIQIAJHDQBBMiEQ DL0DCyACIBBrIAAoAgAiAWohFSAQIAFrQQNqIRYCQANAIBAtAAAiEUEgciARIBFBv39qQf8BcUEa SRtB/wFxIAFB8LuAgABqLQAARw0BQQYhESABQQNGDaADIAFBAWohASAQQQFqIhAgAkcNAAsgACAV NgIAQTIhEAy9AwsgAEEANgIAIBAhAQzVAQsCQCABIhAgAkcNAEEzIRAMvAMLIAIgEGsgACgCACIB aiEVIBAgAWtBCGohFgJAA0AgEC0AACIRQSByIBEgEUG/f2pB/wFxQRpJG0H/AXEgAUH0u4CAAGot AABHDQFBBSERIAFBCEYNnwMgAUEBaiEBIBBBAWoiECACRw0ACyAAIBU2AgBBMyEQDLwDCyAAQQA2 AgAgECEBDNQBCwJAIAEiECACRw0AQTQhEAy7AwsgAiAQayAAKAIAIgFqIRUgECABa0EFaiEWAkAD QCAQLQAAIhFBIHIgESARQb9/akH/AXFBGkkbQf8BcSABQdDCgIAAai0AAEcNAUEHIREgAUEFRg2e AyABQQFqIQEgEEEBaiIQIAJHDQALIAAgFTYCAEE0IRAMuwMLIABBADYCACAQIQEM0wELAkAgASIB IAJGDQADQAJAIAEtAABBgL6AgABqLQAAIhBBAUYNACAQQQJGDQogASEBDNkBCyABQQFqIgEgAkcN AAtBMCEQDLoDC0EwIRAMuQMLAkAgASIBIAJGDQADQAJAIAEtAAAiEEEgRg0AIBBBdmoOBNUB1gHW AdUB1gELIAFBAWoiASACRw0AC0E4IRAMuQMLQTghEAy4AwsDQAJAIAEtAAAiEEEgRg0AIBBBCUcN AwsgAUEBaiIBIAJHDQALQTwhEAy3AwsDQAJAIAEtAAAiEEEgRg0AAkACQCAQQXZqDgTWAQEB1gEA CyAQQSxGDdcBCyABIQEMBAsgAUEBaiIBIAJHDQALQT8hEAy2AwsgASEBDNcBCwJAIAEiECACRw0A QcAAIRAMtQMLIAIgEGsgACgCACIBaiEWIBAgAWtBBmohEQJAA0AgEC0AAEEgciABQYDAgIAAai0A AEcNASABQQZGDZkDIAFBAWohASAQQQFqIhAgAkcNAAsgACAWNgIAQcAAIRAMtQMLIABBADYCACAQ IQELQTUhEAyZAwtBwQAhECABIg8gAkYNsgMgAEGMgICAADYCCCAAIA82AgQgDyEBIAAtACxBf2oO BMkB0QHTAdUBkgMLIAFBAWohAQzIAQsCQCABIgEgAkYNAANAAkAgAS0AACIQQSByIBAgEEG/f2pB /wFxQRpJG0H/AXEiEEEJRg0AIBBBIEYNAAJAAkACQAJAIBBBnX9qDhMAAwMDAwMDAwEDAwMDAwMD AwMCAwsgAUEBaiEBQTAhEAycAwsgAUEBaiEBQTEhEAybAwsgAUEBaiEBQTIhEAyaAwsgASEBDMwB CyABQQFqIgEgAkcNAAtBNSEQDLEDC0E1IRAMsAMLAkAgASIBIAJGDQADQAJAIAEtAABBgLyAgABq LQAAQQFGDQAgASEBDM8BCyABQQFqIgEgAkcNAAtBPSEQDLADC0E9IRAMrwMLIAAgASIBIAIQt4CA gAAiEA3SASABIQEMAQsgEUEBaiEBC0E7IRAMkgMLAkAgASIBIAJHDQBBwgAhEAysAwsCQANAAkAg AS0AAEF3ag4YAAKJA4kDjwOJA4kDiQOJA4kDiQOJA4kDiQOJA4kDiQOJA4kDiQOJA4kDiQMAiQML IAFBAWoiASACRw0AC0HCACEQDKwDCyABQQFqIQEgAC0ALUEBcUUNuQEgASEBDLgCC0HEACEQIAEi ASACRg2qAyABLQAAQTpGDdABIABBADYCHCAAIAE2AhQgAEGxkYCAADYCECAAQQo2AgwMqAMLA0AC QCABLQAAQZDAgIAAai0AAEEBRg0AIAEhAQy8AgsgAUEBaiIBIAJHDQALQcUAIRAMqQMLQcYAIRAg ASINIAJGDagDIA0tAAAiEEEgRg2wASAQQTpHDY0DIAAoAgQhASAAQQA2AgQgACABIA0QtoCAgAAi AQ3NASANQQFqIQEMuAILAkAgASINIAJHDQBBxwAhEAyoAwsgAiANayAAKAIAIhBqIRYgDSAQa0EF aiERA0AgDS0AACIBQSByIAEgAUG/f2pB/wFxQRpJG0H/AXEgEEGQwoCAAGotAABHDYwDQQEhASAQ QQVGDYEDIBBBAWohECANQQFqIg0gAkcNAAsgACAWNgIAQccAIRAMpwMLAkAgASINIAJHDQBByAAh EAynAwsgAiANayAAKAIAIhBqIRYgDSAQa0EJaiERA0AgDS0AACIBQSByIAEgAUG/f2pB/wFxQRpJ G0H/AXEgEEGWwoCAAGotAABHDYsDQQIhASAQQQlGDYADIBBBAWohECANQQFqIg0gAkcNAAsgACAW NgIAQcgAIRAMpgMLQckAIRAgASINIAJGDaUDAkACQCANLQAAIgFBIHIgASABQb9/akH/AXFBGkkb Qf8BcUGSf2oOBwCMA4wDjAOMA4wDAYwDCyANQQFqIQFBPiEQDIwDCyANQQFqIQFBPyEQDIsDCwJA IAEiDSACRw0AQcoAIRAMpQMLIAIgDWsgACgCACIBaiEWIA0gAWtBAWohEQNAIA0tAAAiEEEgciAQ IBBBv39qQf8BcUEaSRtB/wFxIAFBoMKAgABqLQAARw2JAyABQQFGDf0CIAFBAWohASANQQFqIg0g AkcNAAsgACAWNgIAQcoAIRAMpAMLAkAgASINIAJHDQBBywAhEAykAwsgAiANayAAKAIAIhBqIRYg DSAQa0EOaiERA0AgDS0AACIBQSByIAEgAUG/f2pB/wFxQRpJG0H/AXEgEEGiwoCAAGotAABHDYgD QQEhASAQQQ5GDf0CIBBBAWohECANQQFqIg0gAkcNAAsgACAWNgIAQcsAIRAMowMLAkAgASINIAJH DQBBzAAhEAyjAwsgAiANayAAKAIAIhBqIRYgDSAQa0EPaiERA0AgDS0AACIBQSByIAEgAUG/f2pB /wFxQRpJG0H/AXEgEEHAwoCAAGotAABHDYcDQQMhASAQQQ9GDfwCIBBBAWohECANQQFqIg0gAkcN AAsgACAWNgIAQcwAIRAMogMLAkAgASINIAJHDQBBzQAhEAyiAwsgAiANayAAKAIAIhBqIRYgDSAQ a0EFaiERA0AgDS0AACIBQSByIAEgAUG/f2pB/wFxQRpJG0H/AXEgEEHQwoCAAGotAABHDYYDQQQh ASAQQQVGDfsCIBBBAWohECANQQFqIg0gAkcNAAsgACAWNgIAQc0AIRAMoQMLQc4AIRAgASINIAJG DaADAkACQAJAAkAgDS0AACIBQSByIAEgAUG/f2pB/wFxQRpJG0H/AXFBnX9qDhMAiQOJA4kDiQOJ A4kDiQOJA4kDiQOJA4kDAYkDiQOJAwIDiQMLIA1BAWohAUHBACEQDIkDCyANQQFqIQFBwgAhEAyI AwsgDUEBaiEBQcMAIRAMhwMLIA1BAWohAUHEACEQDIYDC0HPACEQIAEiASACRg2fAyAAQY2AgIAA NgIIIAAgATYCBCABIQEMsQILIAAgAC8BMEGAAXI7ATAgASEBDAILQdAAIRAgASIRIAJGDZ0DIBEh AQJAAkAgES0AAEF2ag4EAasCqwIAqwILIBFBAWohAQtBJyEQDIMDC0HRACEQIAEiASACRg2cAwJA IAEtAABBIEYNACABIQEMAQsgAUEBaiEBIAAtAC1BAXFFDcMBIAEhAQtBxwAhEAyBAwsCQCABIhAg AkcNAEHTACEQDJsDCyACIBBrIAAoAgAiAWohFiAQIAFrQQFqIREDQCAQLQAAIAFB1sKAgABqLQAA Rw3FASABQQFGDcMBIAFBAWohASAQQQFqIhAgAkcNAAsgACAWNgIAQdMAIRAMmgMLQdUAIRAgASIB IAJGDZkDIAEtAABBCkcNxQEgAUEBaiEBDOUBC0HWACEQIAEiASACRg2YAwJAAkAgAS0AAEF2ag4E AMYBxgEBxgELIAFBAWohAQzlAQsgAUEBaiEBQcoAIRAM/gILIAAgASIBIAIQtYCAgAAiEA3EASAB IQFBzQAhEAz9AgsgAC0AKUEiRg2QAwyqAgtB2wAhECABIgEgAkYNlQNBACERQQEhFkEBIRVBACEQ AkACQAJAAkACQAJAAkACQAJAIAEtAABBUGoOCs0BzAEAAQIDBAUGCM4BC0ECIRAMBgtBAyEQDAUL QQQhEAwEC0EFIRAMAwtBBiEQDAILQQchEAwBC0EIIRALQQAhFkEAIRVBACERDMUBC0EJIRBBASER QQAhFkEAIRUMxAELQd0AIRAgASIBIAJGDZQDIAEtAABBLkcNxQEgAUEBaiEBDKoCC0HfACEQIAEi ASACRg2TAyABLQAAQVBqIhBB/wFxQQpPDcUBIAAgEDoAKiABQQFqIQEMqgILQeAAIRAgASIBIAJG DZIDIABBjoCAgAA2AgggACABNgIEIAEhAQyqAgsCQCABIgEgAkcNAEHhACEQDJIDCyACIAFrIAAo AgAiEGohFiABIBBrQQNqIREDQCABLQAAIBBB4sKAgABqLQAARw3GASAQQQNGDcUBIBBBAWohECAB QQFqIgEgAkcNAAsgACAWNgIAQeEAIRAMkQMLAkAgASIBIAJHDQBB4gAhEAyRAwsgAiABayAAKAIA IhBqIRYgASAQa0ECaiERA0AgAS0AACAQQebCgIAAai0AAEcNxQEgEEECRg3HASAQQQFqIRAgAUEB aiIBIAJHDQALIAAgFjYCAEHiACEQDJADCwJAIAEiASACRw0AQeMAIRAMkAMLIAIgAWsgACgCACIQ aiEWIAEgEGtBA2ohEQNAIAEtAAAgEEHpwoCAAGotAABHDcQBIBBBA0YNxwEgEEEBaiEQIAFBAWoi ASACRw0ACyAAIBY2AgBB4wAhEAyPAwtB5QAhECABIgEgAkYNjgMgACABQQFqIgEgAhCvgICAACIQ DcYBIAEhAUHWACEQDPQCCwJAIAEiASACRg0AA0ACQCABLQAAIhBBIEYNAAJAAkACQCAQQbh/ag4L AAHIAcgByAHIAcgByAHIAcgBAsgBCyABQQFqIQFB0gAhEAz4AgsgAUEBaiEBQdMAIRAM9wILIAFB AWohAUHUACEQDPYCCyABQQFqIgEgAkcNAAtB5AAhEAyOAwtB5AAhEAyNAwsDQAJAIAEtAABB8MKA gABqLQAAIhBBAUYNACAQQX5qDgPIAckBygHLAQsgAUEBaiIBIAJHDQALQeYAIRAMjAMLQecAIRAg ASIBIAJGDYsDIAFBAWohAQwCCwNAAkAgAS0AAEHwxICAAGotAAAiEEEBRg0AAkAgEEF+ag4EywHM Ac0BAM4BCyABIQFB1wAhEAzyAgsgAUEBaiIBIAJHDQALQegAIRAMigMLQekAIRAgASIBIAJGDYkD AkAgAS0AACIQQXZqDhqzAc4BzgG1Ac4BzgHOAc4BzgHOAc4BzgHOAc4BzgHOAc4BzgHOAc4BzgHO AcMBzgHOAQDMAQsgAUEBaiEBC0EGIRAM7gILA0ACQCABLQAAQfDGgIAAai0AAEEBRg0AIAEhAQyk AgsgAUEBaiIBIAJHDQALQeoAIRAMhwMLQesAIRAgASIBIAJGDYYDIAFBAWohAQz/AQtB7AAhECAB IgEgAkYNhQMgAUEBaiEBDP4BC0HtACEQIAEiASACRg2EAyABQQFqIQEM/QELQe4AIRAgASIRIAJG DYMDIBEhAQJAAkACQCARLQAAQfDIgIAAai0AAEF/ag4HzgHVAdYBAKMCAQLXAQsgEUEBaiEBDAoL IBFBAWohAQzHAQsgAEEANgIcIABBm5KAgAA2AhAgAEEHNgIMIAAgEUEBajYCFEEAIRAMgwMLAkAD QAJAIAEtAABB8MiAgABqLQAAIhBBBEYNAAJAAkAgEEF/ag4HzAHNAc4B2QEABAHZAQsgASEBQdoA IRAM7AILIAFBAWohAUHcACEQDOsCCyABQQFqIgEgAkcNAAtB7wAhEAyDAwsgAUEBaiEBDMUBC0Hw ACEQIAEiESACRg2BAyARLQAAQS9HDdQBIBFBAWohAQwGC0HxACEQIAEiESACRg2AAwJAIBEtAAAi AUEvRw0AIBFBAWohAUHdACEQDOcCCyABQXZqIgRBFksN0wFBASAEdEGJgIACcUUN0wEM1wILQfIA IRAgASIBIAJGDf8CIAFBAWohAQydAgtB9AAhECABIhEgAkYN/gIgESEBAkAgES0AAEHwzICAAGot AABBf2oOA9YCmwIA1AELQeEAIRAM5AILAkAgASIRIAJGDQADQAJAIBEtAABB8MqAgABqLQAAIgFB A0YNAAJAIAFBf2oOAtgCANUBCyARIQFB3wAhEAzmAgsgEUEBaiIRIAJHDQALQfMAIRAM/gILQfMA IRAM/QILQfUAIRAgASIBIAJGDfwCIABBj4CAgAA2AgggACABNgIEIAEhAQybAgtB9gAhECABIgEg AkYN+wIgAEGPgICAADYCCCAAIAE2AgQgASEBC0EDIRAM4AILA0AgAS0AAEEgRw3QAiABQQFqIgEg AkcNAAtB9wAhEAz5AgtB+AAhECABIgEgAkYN+AIgAS0AAEEgRw3OASABQQFqIQEM8AELIAAgASIB IAIQs4CAgAAiEA3OASABIQEMlwILQfoAIRAgASIEIAJGDfYCIAQtAABBzABHDdEBIARBAWohAUET IRAMzwELAkAgASIEIAJHDQBB+wAhEAz2AgsgAiAEayAAKAIAIgFqIREgBCABa0EFaiEQA0AgBC0A ACABQfDOgIAAai0AAEcN0AEgAUEFRg3OASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYCAEH7ACEQ DPUCC0H8ACEQIAEiBCACRg30AgJAAkAgBC0AAEG9f2oODADRAdEB0QHRAdEB0QHRAdEB0QHRAQHR AQsgBEEBaiEBQeYAIRAM2wILIARBAWohAUHnACEQDNoCCwJAIAEiBCACRw0AQf0AIRAM9AILIAIg BGsgACgCACIBaiERIAQgAWtBAmohEAJAA0AgBC0AACABQe3PgIAAai0AAEcNzwEgAUECRg0BIAFB AWohASAEQQFqIgQgAkcNAAsgACARNgIAQf0AIRAM9AILIABBADYCACAQQQFqIQFBECEQDMwBCwJA IAEiBCACRw0AQf4AIRAM8wILIAIgBGsgACgCACIBaiERIAQgAWtBBWohEAJAA0AgBC0AACABQfbO gIAAai0AAEcNzgEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACARNgIAQf4AIRAM8wILIABB ADYCACAQQQFqIQFBFiEQDMsBCwJAIAEiBCACRw0AQf8AIRAM8gILIAIgBGsgACgCACIBaiERIAQg AWtBA2ohEAJAA0AgBC0AACABQfzOgIAAai0AAEcNzQEgAUEDRg0BIAFBAWohASAEQQFqIgQgAkcN AAsgACARNgIAQf8AIRAM8gILIABBADYCACAQQQFqIQFBBSEQDMoBC0GAASEQIAEiBCACRg3wAiAE LQAAQdkARw3LASAEQQFqIQFBCCEQDMkBC0GBASEQIAEiBCACRg3vAgJAAkAgBC0AAEGyf2oOAwDM AQHMAQsgBEEBaiEBQesAIRAM1gILIARBAWohAUHsACEQDNUCC0GCASEQIAEiBCACRg3uAgJAAkAg BC0AAEG4f2oOCADLAcsBywHLAcsBywEBywELIARBAWohAUHqACEQDNUCCyAEQQFqIQFB7QAhEAzU AgsCQCABIgQgAkcNAEGDASEQDO4CCyACIARrIAAoAgAiAWohECAEIAFrQQJqIRECQANAIAQtAAAg AUGAz4CAAGotAABHDckBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgEDYCAEGDASEQDO4C C0EAIRAgAEEANgIAIBFBAWohAQzGAQsCQCABIgQgAkcNAEGEASEQDO0CCyACIARrIAAoAgAiAWoh ESAEIAFrQQRqIRACQANAIAQtAAAgAUGDz4CAAGotAABHDcgBIAFBBEYNASABQQFqIQEgBEEBaiIE IAJHDQALIAAgETYCAEGEASEQDO0CCyAAQQA2AgAgEEEBaiEBQSMhEAzFAQtBhQEhECABIgQgAkYN 6wICQAJAIAQtAABBtH9qDggAyAHIAcgByAHIAcgBAcgBCyAEQQFqIQFB7wAhEAzSAgsgBEEBaiEB QfAAIRAM0QILQYYBIRAgASIEIAJGDeoCIAQtAABBxQBHDcUBIARBAWohAQyMAgsCQCABIgQgAkcN AEGHASEQDOoCCyACIARrIAAoAgAiAWohESAEIAFrQQNqIRACQANAIAQtAAAgAUGIz4CAAGotAABH DcUBIAFBA0YNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYCAEGHASEQDOoCCyAAQQA2AgAgEEEB aiEBQS0hEAzCAQsCQCABIgQgAkcNAEGIASEQDOkCCyACIARrIAAoAgAiAWohESAEIAFrQQhqIRAC QANAIAQtAAAgAUHQz4CAAGotAABHDcQBIAFBCEYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYC AEGIASEQDOkCCyAAQQA2AgAgEEEBaiEBQSkhEAzBAQtBiQEhECABIgEgAkYN5wJBASEQIAEtAABB 3wBHDcABIAFBAWohAQyKAgsCQCABIgQgAkcNAEGKASEQDOcCCyACIARrIAAoAgAiAWohESAEIAFr QQFqIRADQCAELQAAIAFBjM+AgABqLQAARw3BASABQQFGDbwCIAFBAWohASAEQQFqIgQgAkcNAAsg ACARNgIAQYoBIRAM5gILAkAgASIEIAJHDQBBiwEhEAzmAgsgAiAEayAAKAIAIgFqIREgBCABa0EC aiEQAkADQCAELQAAIAFBjs+AgABqLQAARw3BASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAA IBE2AgBBiwEhEAzmAgsgAEEANgIAIBBBAWohAUECIRAMvgELAkAgASIEIAJHDQBBjAEhEAzlAgsg AiAEayAAKAIAIgFqIREgBCABa0EBaiEQAkADQCAELQAAIAFB8M+AgABqLQAARw3AASABQQFGDQEg AUEBaiEBIARBAWoiBCACRw0ACyAAIBE2AgBBjAEhEAzlAgsgAEEANgIAIBBBAWohAUEfIRAMvQEL AkAgASIEIAJHDQBBjQEhEAzkAgsgAiAEayAAKAIAIgFqIREgBCABa0EBaiEQAkADQCAELQAAIAFB 8s+AgABqLQAARw2/ASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBE2AgBBjQEhEAzkAgsg AEEANgIAIBBBAWohAUEJIRAMvAELQY4BIRAgASIEIAJGDeICAkACQCAELQAAQbd/ag4HAL8BvwG/ Ab8BvwEBvwELIARBAWohAUH4ACEQDMkCCyAEQQFqIQFB+QAhEAzIAgsCQCABIgQgAkcNAEGPASEQ DOICCyACIARrIAAoAgAiAWohESAEIAFrQQVqIRACQANAIAQtAAAgAUGRz4CAAGotAABHDb0BIAFB BUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYCAEGPASEQDOICCyAAQQA2AgAgEEEBaiEBQRgh EAy6AQsCQCABIgQgAkcNAEGQASEQDOECCyACIARrIAAoAgAiAWohESAEIAFrQQJqIRACQANAIAQt AAAgAUGXz4CAAGotAABHDbwBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYCAEGQASEQ DOECCyAAQQA2AgAgEEEBaiEBQRchEAy5AQsCQCABIgQgAkcNAEGRASEQDOACCyACIARrIAAoAgAi AWohESAEIAFrQQZqIRACQANAIAQtAAAgAUGaz4CAAGotAABHDbsBIAFBBkYNASABQQFqIQEgBEEB aiIEIAJHDQALIAAgETYCAEGRASEQDOACCyAAQQA2AgAgEEEBaiEBQRUhEAy4AQsCQCABIgQgAkcN AEGSASEQDN8CCyACIARrIAAoAgAiAWohESAEIAFrQQVqIRACQANAIAQtAAAgAUGhz4CAAGotAABH DboBIAFBBUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYCAEGSASEQDN8CCyAAQQA2AgAgEEEB aiEBQR4hEAy3AQtBkwEhECABIgQgAkYN3QIgBC0AAEHMAEcNuAEgBEEBaiEBQQohEAy2AQtBlAEh ECAEIAJGDdwCAkACQCAELQAAQb9/ag4PALkBuQG5AbkBuQG5AbkBuQG5AbkBuQG5AbkBAbkBCyAE QQFqIQFB/gAhEAzDAgsgBEEBaiEBQf8AIRAMwgILQZUBIRAgBCACRg3bAgJAAkAgBC0AAEG/f2oO AwC4AQG4AQsgBEEBaiEBQf0AIRAMwgILIARBAWohBEGAASEQDMECCwJAIAQgAkcNAEGWASEQDNsC CyACIARrIAAoAgAiAWohESAEIAFrQQFqIRACQANAIAQtAAAgAUGnz4CAAGotAABHDbYBIAFBAUYN ASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYCAEGWASEQDNsCCyAAQQA2AgAgEEEBaiEBQQshEAyz AQtBlwEhECAEIAJGDdkCAkACQAJAAkAgBC0AAEFTag4jALgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4 AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAEBuAG4AbgBuAG4AQK4AbgBuAEDuAELIARBAWohAUH7ACEQ DMICCyAEQQFqIQFB/AAhEAzBAgsgBEEBaiEEQYEBIRAMwAILIARBAWohBEGCASEQDL8CCwJAIAQg AkcNAEGYASEQDNkCCyACIARrIAAoAgAiAWohESAEIAFrQQRqIRACQANAIAQtAAAgAUGpz4CAAGot AABHDbQBIAFBBEYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYCAEGYASEQDNkCCyAAQQA2AgAg EEEBaiEBQRkhEAyxAQsCQCAEIAJHDQBBmQEhEAzYAgsgAiAEayAAKAIAIgFqIREgBCABa0EFaiEQ AkADQCAELQAAIAFBrs+AgABqLQAARw2zASABQQVGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBE2 AgBBmQEhEAzYAgsgAEEANgIAIBBBAWohAUEGIRAMsAELAkAgBCACRw0AQZoBIRAM1wILIAIgBGsg ACgCACIBaiERIAQgAWtBAWohEAJAA0AgBC0AACABQbTPgIAAai0AAEcNsgEgAUEBRg0BIAFBAWoh ASAEQQFqIgQgAkcNAAsgACARNgIAQZoBIRAM1wILIABBADYCACAQQQFqIQFBHCEQDK8BCwJAIAQg AkcNAEGbASEQDNYCCyACIARrIAAoAgAiAWohESAEIAFrQQFqIRACQANAIAQtAAAgAUG2z4CAAGot AABHDbEBIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYCAEGbASEQDNYCCyAAQQA2AgAg EEEBaiEBQSchEAyuAQtBnAEhECAEIAJGDdQCAkACQCAELQAAQax/ag4CAAGxAQsgBEEBaiEEQYYB IRAMuwILIARBAWohBEGHASEQDLoCCwJAIAQgAkcNAEGdASEQDNQCCyACIARrIAAoAgAiAWohESAE IAFrQQFqIRACQANAIAQtAAAgAUG4z4CAAGotAABHDa8BIAFBAUYNASABQQFqIQEgBEEBaiIEIAJH DQALIAAgETYCAEGdASEQDNQCCyAAQQA2AgAgEEEBaiEBQSYhEAysAQsCQCAEIAJHDQBBngEhEAzT AgsgAiAEayAAKAIAIgFqIREgBCABa0EBaiEQAkADQCAELQAAIAFBus+AgABqLQAARw2uASABQQFG DQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBE2AgBBngEhEAzTAgsgAEEANgIAIBBBAWohAUEDIRAM qwELAkAgBCACRw0AQZ8BIRAM0gILIAIgBGsgACgCACIBaiERIAQgAWtBAmohEAJAA0AgBC0AACAB Qe3PgIAAai0AAEcNrQEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACARNgIAQZ8BIRAM0gIL IABBADYCACAQQQFqIQFBDCEQDKoBCwJAIAQgAkcNAEGgASEQDNECCyACIARrIAAoAgAiAWohESAE IAFrQQNqIRACQANAIAQtAAAgAUG8z4CAAGotAABHDawBIAFBA0YNASABQQFqIQEgBEEBaiIEIAJH DQALIAAgETYCAEGgASEQDNECCyAAQQA2AgAgEEEBaiEBQQ0hEAypAQtBoQEhECAEIAJGDc8CAkAC QCAELQAAQbp/ag4LAKwBrAGsAawBrAGsAawBrAGsAQGsAQsgBEEBaiEEQYsBIRAMtgILIARBAWoh BEGMASEQDLUCC0GiASEQIAQgAkYNzgIgBC0AAEHQAEcNqQEgBEEBaiEEDPIBC0GjASEQIAQgAkYN zQICQAJAIAQtAABBt39qDgcBqgGqAaoBqgGqAQCqAQsgBEEBaiEEQY4BIRAMtAILIARBAWohAUEi IRAMpgELAkAgBCACRw0AQaQBIRAMzQILIAIgBGsgACgCACIBaiERIAQgAWtBAWohEAJAA0AgBC0A ACABQcDPgIAAai0AAEcNqAEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACARNgIAQaQBIRAM zQILIABBADYCACAQQQFqIQFBHSEQDKUBC0GlASEQIAQgAkYNywICQAJAIAQtAABBrn9qDgMAqAEB qAELIARBAWohBEGQASEQDLICCyAEQQFqIQFBBCEQDKQBC0GmASEQIAQgAkYNygICQAJAAkACQAJA IAQtAABBv39qDhUAqgGqAaoBqgGqAaoBqgGqAaoBqgEBqgGqAQKqAaoBA6oBqgEEqgELIARBAWoh BEGIASEQDLQCCyAEQQFqIQRBiQEhEAyzAgsgBEEBaiEEQYoBIRAMsgILIARBAWohBEGPASEQDLEC CyAEQQFqIQRBkQEhEAywAgsCQCAEIAJHDQBBpwEhEAzKAgsgAiAEayAAKAIAIgFqIREgBCABa0EC aiEQAkADQCAELQAAIAFB7c+AgABqLQAARw2lASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAA IBE2AgBBpwEhEAzKAgsgAEEANgIAIBBBAWohAUERIRAMogELAkAgBCACRw0AQagBIRAMyQILIAIg BGsgACgCACIBaiERIAQgAWtBAmohEAJAA0AgBC0AACABQcLPgIAAai0AAEcNpAEgAUECRg0BIAFB AWohASAEQQFqIgQgAkcNAAsgACARNgIAQagBIRAMyQILIABBADYCACAQQQFqIQFBLCEQDKEBCwJA IAQgAkcNAEGpASEQDMgCCyACIARrIAAoAgAiAWohESAEIAFrQQRqIRACQANAIAQtAAAgAUHFz4CA AGotAABHDaMBIAFBBEYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYCAEGpASEQDMgCCyAAQQA2 AgAgEEEBaiEBQSshEAygAQsCQCAEIAJHDQBBqgEhEAzHAgsgAiAEayAAKAIAIgFqIREgBCABa0EC aiEQAkADQCAELQAAIAFBys+AgABqLQAARw2iASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAA IBE2AgBBqgEhEAzHAgsgAEEANgIAIBBBAWohAUEUIRAMnwELQasBIRAgBCACRg3FAgJAAkACQAJA IAQtAABBvn9qDg8AAQKkAaQBpAGkAaQBpAGkAaQBpAGkAaQBA6QBCyAEQQFqIQRBkwEhEAyuAgsg BEEBaiEEQZQBIRAMrQILIARBAWohBEGVASEQDKwCCyAEQQFqIQRBlgEhEAyrAgtBrAEhECAEIAJG DcQCIAQtAABBxQBHDZ8BIARBAWohBAzpAQsCQCAEIAJHDQBBrQEhEAzEAgsgAiAEayAAKAIAIgFq IREgBCABa0ECaiEQAkADQCAELQAAIAFBzc+AgABqLQAARw2fASABQQJGDQEgAUEBaiEBIARBAWoi BCACRw0ACyAAIBE2AgBBrQEhEAzEAgsgAEEANgIAIBBBAWohAUEOIRAMnAELQa4BIRAgBCACRg3C AiAELQAAQdAARw2dASAEQQFqIQFBJSEQDJsBCwJAIAQgAkcNAEGvASEQDMICCyACIARrIAAoAgAi AWohESAEIAFrQQhqIRACQANAIAQtAAAgAUHQz4CAAGotAABHDZ0BIAFBCEYNASABQQFqIQEgBEEB aiIEIAJHDQALIAAgETYCAEGvASEQDMICCyAAQQA2AgAgEEEBaiEBQSohEAyaAQtBsAEhECAEIAJG DcACAkACQCAELQAAQat/ag4LAJ0BnQGdAZ0BnQGdAZ0BnQGdAQGdAQsgBEEBaiEEQZoBIRAMpwIL IARBAWohBEGbASEQDKYCC0GxASEQIAQgAkYNvwICQAJAIAQtAABBv39qDhQAnAGcAZwBnAGcAZwB nAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBAZwBCyAEQQFqIQRBmQEhEAymAgsgBEEBaiEEQZwBIRAM pQILAkAgBCACRw0AQbIBIRAMvwILIAIgBGsgACgCACIBaiERIAQgAWtBA2ohEAJAA0AgBC0AACAB QdnPgIAAai0AAEcNmgEgAUEDRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACARNgIAQbIBIRAMvwIL IABBADYCACAQQQFqIQFBISEQDJcBCwJAIAQgAkcNAEGzASEQDL4CCyACIARrIAAoAgAiAWohESAE IAFrQQZqIRACQANAIAQtAAAgAUHdz4CAAGotAABHDZkBIAFBBkYNASABQQFqIQEgBEEBaiIEIAJH DQALIAAgETYCAEGzASEQDL4CCyAAQQA2AgAgEEEBaiEBQRohEAyWAQtBtAEhECAEIAJGDbwCAkAC QAJAIAQtAABBu39qDhEAmgGaAZoBmgGaAZoBmgGaAZoBAZoBmgGaAZoBmgECmgELIARBAWohBEGd ASEQDKQCCyAEQQFqIQRBngEhEAyjAgsgBEEBaiEEQZ8BIRAMogILAkAgBCACRw0AQbUBIRAMvAIL IAIgBGsgACgCACIBaiERIAQgAWtBBWohEAJAA0AgBC0AACABQeTPgIAAai0AAEcNlwEgAUEFRg0B IAFBAWohASAEQQFqIgQgAkcNAAsgACARNgIAQbUBIRAMvAILIABBADYCACAQQQFqIQFBKCEQDJQB CwJAIAQgAkcNAEG2ASEQDLsCCyACIARrIAAoAgAiAWohESAEIAFrQQJqIRACQANAIAQtAAAgAUHq z4CAAGotAABHDZYBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYCAEG2ASEQDLsCCyAA QQA2AgAgEEEBaiEBQQchEAyTAQtBtwEhECAEIAJGDbkCAkACQCAELQAAQbt/ag4OAJYBlgGWAZYB lgGWAZYBlgGWAZYBlgGWAQGWAQsgBEEBaiEEQaEBIRAMoAILIARBAWohBEGiASEQDJ8CCwJAIAQg AkcNAEG4ASEQDLkCCyACIARrIAAoAgAiAWohESAEIAFrQQJqIRACQANAIAQtAAAgAUHtz4CAAGot AABHDZQBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYCAEG4ASEQDLkCCyAAQQA2AgAg EEEBaiEBQRIhEAyRAQsCQCAEIAJHDQBBuQEhEAy4AgsgAiAEayAAKAIAIgFqIREgBCABa0EBaiEQ AkADQCAELQAAIAFB8M+AgABqLQAARw2TASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBE2 AgBBuQEhEAy4AgsgAEEANgIAIBBBAWohAUEgIRAMkAELAkAgBCACRw0AQboBIRAMtwILIAIgBGsg ACgCACIBaiERIAQgAWtBAWohEAJAA0AgBC0AACABQfLPgIAAai0AAEcNkgEgAUEBRg0BIAFBAWoh ASAEQQFqIgQgAkcNAAsgACARNgIAQboBIRAMtwILIABBADYCACAQQQFqIQFBDyEQDI8BC0G7ASEQ IAQgAkYNtQICQAJAIAQtAABBt39qDgcAkgGSAZIBkgGSAQGSAQsgBEEBaiEEQaUBIRAMnAILIARB AWohBEGmASEQDJsCCwJAIAQgAkcNAEG8ASEQDLUCCyACIARrIAAoAgAiAWohESAEIAFrQQdqIRAC QANAIAQtAAAgAUH0z4CAAGotAABHDZABIAFBB0YNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgETYC AEG8ASEQDLUCCyAAQQA2AgAgEEEBaiEBQRshEAyNAQtBvQEhECAEIAJGDbMCAkACQAJAIAQtAABB vn9qDhIAkQGRAZEBkQGRAZEBkQGRAZEBAZEBkQGRAZEBkQGRAQKRAQsgBEEBaiEEQaQBIRAMmwIL IARBAWohBEGnASEQDJoCCyAEQQFqIQRBqAEhEAyZAgtBvgEhECAEIAJGDbICIAQtAABBzgBHDY0B IARBAWohBAzYAQtBvwEhECAEIAJGDbECAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAg BC0AAEG/f2oOFQABAgOcAQQFBpwBnAGcAQcICQoLnAEMDQ4PnAELIARBAWohAUHoACEQDKYCCyAE QQFqIQFB6QAhEAylAgsgBEEBaiEBQe4AIRAMpAILIARBAWohAUHyACEQDKMCCyAEQQFqIQFB8wAh EAyiAgsgBEEBaiEBQfYAIRAMoQILIARBAWohAUH3ACEQDKACCyAEQQFqIQFB+gAhEAyfAgsgBEEB aiEEQYMBIRAMngILIARBAWohBEGEASEQDJ0CCyAEQQFqIQRBhQEhEAycAgsgBEEBaiEEQZIBIRAM mwILIARBAWohBEGYASEQDJoCCyAEQQFqIQRBoAEhEAyZAgsgBEEBaiEEQaMBIRAMmAILIARBAWoh BEGqASEQDJcCC0HAASEQIAQgAkYNsAIgAEGQgICAADYCCCAAIAQ2AgQM1wELIAAgBSACELGAgIAA IgENiwEgBSEBDHsLQcIBIRAgBiACRg2uAiAGQQFqIQUMjAELA0ACQCAQLQAAQXZqDgSMAQAAjwEA CyAQQQFqIhAgAkcNAAtBwwEhEAytAgtBxAEhECAHIAJGDawCIABBkYCAgAA2AgggACAHNgIEIAch AQyjAQtBxQEhECAHIAJGDasCAkACQCAHLQAAQXZqDgQA2AHYAQHYAQsgB0EBaiEFDIoBCyAHQQFq IQYMjAELQcYBIRAgByACRg2qAgJAAkAgBy0AAEF2ag4XAY8BjwEBjwGPAY8BjwGPAY8BjwGPAY8B jwGPAY8BjwGPAY8BjwGPAY8BAI8BCyAHQQFqIQcLQbABIRAMkAILQcgBIRAgCCACRg2pAiAILQAA QSBHDY0BIABBADsBMiAIQQFqIQFBswEhEAyPAgsgASEWA0BBxwEhECAWIgcgAkYNqQIgBy0AAEFQ akH/AXEiEEEKTw3VASAHQQFqIRYCQCAALwEyIhFBmTNLDQAgACARQQpsIhE7ATIgEEH//wNzIBFB /v8DcUkNACAAIBEgEGoiEDsBMiAQQf//A3FB6AdJDQELCyAAQQA2AhwgAEHBiYCAADYCECAAQQ02 AgwgACAHQQFqNgIUQQAhEAyoAgsgACAIIAIQtYCAgAAiEEUN1AEgEEEVRw2MASAAQcgBNgIcIAAg CDYCFCAAQcmXgIAANgIQIABBFTYCDEEAIRAMpwILQcwBIRAgCSACRg2mAkEAIRFBASEWQQEhFUEA IRACQAJAAkACQAJAAkACQAJAAkAgCS0AAEFQag4KlgGVAQABAgMEBQYIlwELQQIhEAwGC0EDIRAM BQtBBCEQDAQLQQUhEAwDC0EGIRAMAgtBByEQDAELQQghEAtBACEWQQAhFUEAIREMjgELQQkhEEEB IRFBACEWQQAhFQyNAQtBzgEhECAKIAJGDaUCIAotAABBLkcNjgEgCkEBaiEJDNQBC0HQASEQIAsg AkYNpAIgCy0AAEFQaiIQQf8BcUEKTw2OASAAIBA6ACogC0EBaiEKDNQBC0HRASEQIAsgAkYNowIg AEGOgICAADYCCCAAIAs2AgQM1AELAkAgBCACRw0AQdIBIRAMowILIAIgBGsgACgCACIQaiERIAQg EGtBBGohCwNAIAQtAAAgEEH8z4CAAGotAABHDY4BIBBBBEYN9gEgEEEBaiEQIARBAWoiBCACRw0A CyAAIBE2AgBB0gEhEAyiAgsgACAMIAIQs4CAgAAiAQ2NASAMIQEMwQELAkAgBCACRw0AQdQBIRAM oQILIAIgBGsgACgCACIQaiERIAQgEGtBAWohDANAIAQtAAAgEEGB0ICAAGotAABHDY8BIBBBAUYN jgEgEEEBaiEQIARBAWoiBCACRw0ACyAAIBE2AgBB1AEhEAygAgsCQCAEIAJHDQBB1gEhEAygAgsg AiAEayAAKAIAIhBqIREgBCAQa0ECaiELA0AgBC0AACAQQYPQgIAAai0AAEcNjgEgEEECRg2QASAQ QQFqIRAgBEEBaiIEIAJHDQALIAAgETYCAEHWASEQDJ8CC0HXASEQIAQgAkYNngICQAJAIAQtAABB u39qDhAAjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAQGPAQsgBEEBaiEEQbsBIRAMhQILIARB AWohBEG8ASEQDIQCC0HYASEQIAQgAkYNnQIgBC0AAEHIAEcNjAEgBEEBaiEEDNABC0HZASEQIAQg AkYNnAIgAEGQgICAADYCCCAAIAQ2AgQM0AELQdoBIRAgBCACRg2bAiAELQAAQcgARg3QASAAQQE6 ACgMwwELIABBAjoALyAAIAQgAhCtgICAACIQDY0BQcIBIRAMgAILIAAtAChBf2oOAsEBwwHCAQsD QAJAIAQtAABBdmoOBACOAY4BAI4BCyAEQQFqIgQgAkcNAAtB3QEhEAyYAgsgAEEAOgAvIAAtAC1B BHFFDZACCyAAQQA6AC8gAEEBOgA0IAEhAQyMAQsgEEEVRg3nASAAQQA2AhwgACABNgIUIABBp46A gAA2AhAgAEESNgIMDJMCCwJAIAAgECACELuAgIAAIgQNACAQIQEMjQILAkAgBEEVRw0AIABBAzYC HCAAIBA2AhQgAEGwmICAADYCECAAQRU2AgwMkwILIABBADYCHCAAIBA2AhQgAEGnjoCAADYCECAA QRI2AgwMkgILIBBBFUYN4wEgAEEANgIcIAAgATYCFCAAQdqNgIAANgIQIABBFDYCDAyRAgsgEEEV Rg3hASAAQQA2AhwgACABNgIUIABBg4yAgAA2AhAgAEETNgIMDJACCyAQQRVGDd8BIABBADYCHCAA IAE2AhQgAEGaj4CAADYCECAAQSI2AgwMjwILIAAoAgQhECAAQQA2AgQCQCAAIBAgARC+gICAACIQ DQAgAUEBaiEBDJQBCyAAQQw2AhwgACAQNgIMIAAgAUEBajYCFAyOAgsgEEEVRg3cASAAQQA2Ahwg ACABNgIUIABBmo+AgAA2AhAgAEEiNgIMDI0CCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQvoCAgAAi EA0AIAFBAWohAQyTAQsgAEENNgIcIAAgEDYCDCAAIAFBAWo2AhQMjAILIBBBFUYN2QEgAEEANgIc IAAgATYCFCAAQcaMgIAANgIQIABBIzYCDAyLAgsgACgCBCEQIABBADYCBAJAIAAgECABEMCAgIAA IhANACABQQFqIQEMkgELIABBDjYCHCAAIBA2AgwgACABQQFqNgIUDIoCCyAAQQA2AhwgACABNgIU IABBwJWAgAA2AhAgAEECNgIMDIkCCyAQQRVGDdUBIABBADYCHCAAIAE2AhQgAEHGjICAADYCECAA QSM2AgwMiAILIABBEDYCHCAAIAE2AhQgACAQNgIMDIcCCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQ wICAgAAiBA0AIAFBAWohAQyAAgsgAEERNgIcIAAgBDYCDCAAIAFBAWo2AhQMhgILIBBBFUYN0QEg AEEANgIcIAAgATYCFCAAQcaMgIAANgIQIABBIzYCDAyFAgsgACgCBCEQIABBADYCBAJAIAAgECAB EMCAgIAAIhANACABQQFqIQEMjwELIABBEzYCHCAAIBA2AgwgACABQQFqNgIUDIQCCyAAKAIEIQQg AEEANgIEAkAgACAEIAEQwICAgAAiBA0AIAFBAWohAQz8AQsgAEEUNgIcIAAgBDYCDCAAIAFBAWo2 AhQMgwILIBBBFUYNzQEgAEEANgIcIAAgATYCFCAAQZqPgIAANgIQIABBIjYCDAyCAgsgACgCBCEQ IABBADYCBAJAIAAgECABEL6AgIAAIhANACABQQFqIQEMjQELIABBFjYCHCAAIBA2AgwgACABQQFq NgIUDIECCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQvoCAgAAiBA0AIAFBAWohAQz4AQsgAEEXNgIc IAAgBDYCDCAAIAFBAWo2AhQMgAILIABBADYCHCAAIAE2AhQgAEHNk4CAADYCECAAQQw2AgwM/wEL QgEhEgsgEUEBaiEBAkAgACkDICITQv//////////D1YNACAAIBNCBIYgEoQ3AyAgASEBDIsBCyAA QQA2AhwgACABNgIUIABBrYmAgAA2AhAgAEEMNgIMDP0BCyAAQQA2AhwgACARNgIUIABBzZOAgAA2 AhAgAEEMNgIMDPwBCyAAQQA2AhwgACAQNgIUIABBqpyAgAA2AhAgAEEPNgIMDPsBCyAAIBAgAhC7 gICAACIBDQEgECEBC0EOIRAM4QELAkAgAUEVRw0AIABBAjYCHCAAIBA2AhQgAEGwmICAADYCECAA QRU2AgwM+QELIABBADYCHCAAIBA2AhQgAEGnjoCAADYCECAAQRI2AgwM+AELIAFBFUcNygEgAEEF NgIcIAAgEDYCFCAAQfmXgIAANgIQIABBFTYCDAz3AQsCQCABQaAEcUGgBEcNACAALQAtQQJxDQAg AEEANgIcIAAgEDYCFCAAQZaTgIAANgIQIABBBDYCDAz3AQsgACAQIAIQxICAgAAaIBAhAQJAAkAC QAJAAkAgACAQIAIQuoCAgAAOFgIBAAQEBAQEBAQEBAQEBAQEBAQEBAMECyAAQQE6AC4LIAAgAC8B MEHAAHI7ATAgECEBC0EmIRAM4AELIABBIzYCHCAAIBA2AhQgAEGlloCAADYCECAAQRU2AgwM9wEL IABBADYCHCAAIBA2AhQgAEHVi4CAADYCECAAQRE2AgwM9gELIAAtAC1BAXFFDQFBwwEhEAzdAQsC QCANIAJGDQADQAJAIA0tAABBIEYNACANIQEM0wELIA1BAWoiDSACRw0AC0ElIRAM9wELQSUhEAz2 AQsgACgCBCEEIABBADYCBCAAIAQgDRC2gICAACIERQ29ASAAQSY2AhwgACAENgIMIAAgDUEBajYC FAzzAQsgEEEVRg27ASAAQQA2AhwgACABNgIUIABB/Y2AgAA2AhAgAEEdNgIMDPIBCyAAQSc2Ahwg ACABNgIUIAAgEDYCDAzxAQsgESEBQQEhEAJAAkACQAJAAkACQAJAIAAtACxBfmoOBwYFBQMBAgAF CyAAIAAvATBBCHI7ATAMAwtBAiEQDAELQQQhEAsgAEEBOgAsIAAgAC8BMCAQcjsBMAsgESEBC0Ep IRAM2QELIABBADYCHCAAIBE2AhQgAEGrkoCAADYCECAAQQs2AgwM8AELIABBADYCHCAAIAE2AhQg AEHhj4CAADYCECAAQQo2AgwM7wELIABBADoALCARIQEMzAELIBEhAUEBIRACQAJAAkACQAJAIAAt ACxBe2oOBAMBAgAFCyAAIAAvATBBCHI7ATAMAwtBAiEQDAELQQQhEAsgAEEBOgAsIAAgAC8BMCAQ cjsBMAsgESEBC0EoIRAM1AELIABBADYCHCAAIAE2AhQgAEHwlICAADYCECAAQQM2AgwM6wELIAAo AgQhASAAQQA2AgQCQCAAIAEgDhC4gICAACIBDQAgDkEBaiEBDHwLIABBLDYCHCAAIAE2AgwgACAO QQFqNgIUDOoBCwJAAkADQAJAIA4tAABBdmoOBAIAAAMACyAOQQFqIg4gAkcNAAtBLSEQDO0BCyAA KAIEIQEgAEEANgIEAkAgACABIA4QuICAgAAiAQ0AIA4hAQx8CyAAQSw2AhwgACAONgIUIAAgATYC DAzqAQsgACgCBCEBIABBADYCBAJAIAAgASAOELiAgIAAIgENACAOQQFqIQEMewsgAEEsNgIcIAAg ATYCDCAAIA5BAWo2AhQM6QELIAAoAgQhBCAAQQA2AgQgACAEIA4QuICAgAAiBA2wASAOIQEM3QEL IBBBLEcNASABQQFqIRBBASEBAkACQAJAAkACQCAALQAsQXtqDgQDAQIEAAsgECEBDAQLQQIhAQwB C0EEIQELIABBAToALCAAIAAvATAgAXI7ATAgECEBDAELIAAgAC8BMEEIcjsBMCAQIQELQTghEAzO AQsgAEEAOgAsIAEhAQtBMyEQDMwBCyAAIAAvATBBIHI7ATAgASEBDAILIAAoAgQhBCAAQQA2AgQC QCAAIAQgARC4gICAACIEDQAgASEBDNYBCyAAQTc2AhwgACABNgIUIAAgBDYCDAziAQsgAEEIOgAs IAEhAQtBLiEQDMgBCwJAIAAtAChBAUYNACABIQEMBAsgAC0ALUEIcUUNowEgASEBDAMLIAAtADBB IHENpAFBxAEhEAzGAQsCQCAPIAJGDQACQANAAkAgDy0AAEFQaiIQQf8BcUEKSQ0AIA8hAUE0IRAM yQELIA9BAWohASAAKQMgIhJCmbPmzJmz5swZVg0BIAAgEkIKfiISNwMgIBIgEK0iE0J/hUKAfoRW DQEgACASIBNC/wGDfDcDICABIQ8gASACRw0AC0E5IRAM4QELIAAoAgQhAiAAQQA2AgQgACACIA9B AWoiBBC4gICAACICDaUBIAQhAQzSAQtBOSEQDN8BCwJAIAAvATAiAUEIcUUNACAALQAoQQFHDQAg AC0ALUEIcUUNoAELIAAgAUH3+wNxQYAEcjsBMCAPIQELQTYhEAzDAQsgACAALwEwQRByOwEwDLoB CyAQQRVGDZsBIABBADYCHCAAIAE2AhQgAEHwjoCAADYCECAAQRw2AgwM2QELIABBwwA2AhwgACAB NgIMIAAgDUEBajYCFAzYAQsgACgCBCEQIABBADYCBAJAIAAgECABELaAgIAAIhANACABQQFqIQEM agsgAEHDADYCHCAAIBA2AgwgACABQQFqNgIUDNcBCyAAQQA2AhwgACABNgIUIABBoJmAgAA2AhAg AEEeNgIMDNYBCyAAQQA2AgAMIgsgACgCBCEQIABBADYCBAJAIAAgECABEK6AgIAAIhANACABIQEM IAsgAEHSADYCHCAAIAE2AhQgACAQNgIMQQAhEAzWAQsgAEEANgIcIAAgEDYCFCAAQcGogIAANgIQ IABBBzYCDCAAQQA2AgAM0wELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCugICAACIQDQAgASEBDGgL IABB0wA2AhwgACABNgIUIAAgEDYCDEEAIRAM1AELIABBADYCHCAAIAE2AhQgAEGAkYCAADYCECAA QQk2AgwM0QELIBBBFUYNkAEgAEEANgIcIAAgATYCFCAAQZSNgIAANgIQIABBITYCDAzQAQtBASEV QQAhFkEAIRFBASEQCyAAIBA6ACsgAUEBaiEBAkACQCAALQAtQRBxDQACQAJAAkAgAC0AKg4DAQAC BAsgFUUNAwwCCyARDQEMAgsgFkUNAQsgACgCBCEQIABBADYCBAJAIAAgECABELSAgIAAIhANACAB IQEMZwsgAEHYADYCHCAAIAE2AhQgACAQNgIMDM8BCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQtICA gAAiBA0AIAEhAQy/AQsgAEHZADYCHCAAIAE2AhQgACAENgIMDM4BCyAAKAIEIQQgAEEANgIEAkAg ACAEIAEQtICAgAAiBA0AIAEhAQy9AQsgAEHaADYCHCAAIAE2AhQgACAENgIMDM0BCyAAKAIEIQQg AEEANgIEAkAgACAEIAEQtICAgAAiBA0AIAEhAQy7AQsgAEHcADYCHCAAIAE2AhQgACAENgIMDMwB CyAAKAIEIQQgAEEANgIEAkAgACAEIAEQtICAgAAiBA0AIAEhAQy5AQsgAEHeADYCHCAAIAE2AhQg ACAENgIMDMsBCyAAQQA2AgAgEUEBaiEBAkAgAC0AKUEjTw0AIAEhAQxmCyAAQQA2AhwgACABNgIU IABB04mAgAA2AhAgAEEINgIMDMoBCyAAQQA2AgALIABBADYCHCAAIAE2AhQgAEGQs4CAADYCECAA QQg2AgwMyAELIABBADYCACARQQFqIQECQCAALQApQSFHDQAgASEBDGMLIABBADYCHCAAIAE2AhQg AEGbioCAADYCECAAQQg2AgwMxwELIABBADYCACARQQFqIQECQCAALQApIhBBXWpBC08NACABIQEM YgsCQCAQQQZLDQBBASAQdEHKAHFFDQAgASEBDGILIABBADYCHCAAIAE2AhQgAEH3iYCAADYCECAA QQg2AgwMxgELIBBBFUYNhAEgAEEANgIcIAAgATYCFCAAQbmNgIAANgIQIABBGjYCDAzFAQsgACgC BCEQIABBADYCBAJAIAAgECABEK6AgIAAIhANACABIQEMYQsgAEHlADYCHCAAIAE2AhQgACAQNgIM QQAhEAzGAQsgACgCBCEQIABBADYCBAJAIAAgECABEK6AgIAAIhANACABIQEMDwsgAEHSADYCHCAA IAE2AhQgACAQNgIMQQAhEAzFAQsgACgCBCEQIABBADYCBAJAIAAgECABEK6AgIAAIhANACABIQEM WAsgAEHTADYCHCAAIAE2AhQgACAQNgIMQQAhEAzEAQsgACgCBCEQIABBADYCBAJAIAAgECABEK6A gIAAIhANACABIQEMXgsgAEHlADYCHCAAIAE2AhQgACAQNgIMQQAhEAzDAQsgAEEANgIcIAAgATYC FCAAQcaKgIAANgIQIABBBzYCDEEAIRAMwgELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCugICAACIQ DQAgASEBDAsLIABB0gA2AhwgACABNgIUIAAgEDYCDEEAIRAMwQELIAAoAgQhECAAQQA2AgQCQCAA IBAgARCugICAACIQDQAgASEBDFQLIABB0wA2AhwgACABNgIUIAAgEDYCDEEAIRAMwAELIAAoAgQh ECAAQQA2AgQCQCAAIBAgARCugICAACIQDQAgASEBDFoLIABB5QA2AhwgACABNgIUIAAgEDYCDEEA IRAMvwELIABBADYCHCAAIAE2AhQgAEHciICAADYCECAAQQc2AgxBACEQDL4BCyAQQT9HDQEgAUEB aiEBC0EFIRAMogELIABBADYCHCAAIAE2AhQgAEH9koCAADYCECAAQQc2AgwMuQELIAAoAgQhECAA QQA2AgQCQCAAIBAgARCugICAACIQDQAgASEBDAQLIABB0gA2AhwgACABNgIUIAAgEDYCDAy4AQsg ACgCBCEQIABBADYCBAJAIAAgECABEK6AgIAAIhANACABIQEMTQsgAEHTADYCHCAAIAE2AhQgACAQ NgIMDLcBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQroCAgAAiEA0AIAEhAQxTCyAAQeUANgIcIAAg ATYCFCAAIBA2AgwMtgELIAAoAgQhASAAQQA2AgQgACABIBEQroCAgAAiAQ0FIBEhAQtBxQEhEAyc AQtB0gAhECABIhEgAkYNtQELIABBgBI7ASogACARQQFqIgEgAhCvgICAACIQDQEgASEBC0HIACEQ DJkBCyAQQRVHDXEgAEHRADYCHCAAIAE2AhQgAEHjl4CAADYCECAAQRU2AgwMsAELIABB0gA2Ahwg ACARNgIUIAAgATYCDEEAIRAMsQELIAAoAgQhASAAQQA2AgQCQCAAIAEgERCugICAACIBDQAgESEB DEQLIABB0wA2AhwgACARNgIUIAAgATYCDEEAIRAMsAELIAAoAgQhASAAQQA2AgQCQCAAIAEgERCu gICAACIBDQAgESEBDEoLIABB5QA2AhwgACARNgIUIAAgATYCDEEAIRAMrwELIABBADYCHCAAIBE2 AhQgAEHDj4CAADYCECAAQQc2AgxBACEQDK4BCyAAQQA2AhwgACABNgIUIABBw4+AgAA2AhAgAEEH NgIMDKsBCyAAQQA2AhwgACARNgIUIABBjJyAgAA2AhAgAEEHNgIMQQAhEAysAQsgAEEANgIcIAAg ETYCFCAAQYycgIAANgIQIABBBzYCDEEAIRAMqwELIABBADYCHCAAIBE2AhQgAEH+kYCAADYCECAA QQc2AgxBACEQDKoBCyAAQQA2AhwgACABNgIUIABBjpuAgAA2AhAgAEEGNgIMQQAhEAypAQsgEEEV Rg1kIABBADYCHCAAIAE2AhQgAEHMjoCAADYCECAAQSA2AgxBACEQDKgBCyAAQQA2AgAgEEEBaiEB QSQhEAsgACAQOgApIAAoAgQhECAAQQA2AgQgACAQIAEQsoCAgAAiEA1hIAEhAQxHCyAAQQA2AgAL QQAhECAAQQA2AhwgACAENgIUIABB8ZuAgAA2AhAgAEEGNgIMDKQBCyABQRVGDV0gAEEANgIcIAAg BTYCFCAAQfCMgIAANgIQIABBGzYCDEEAIRAMowELIAAoAgQhBSAAQQA2AgQgACAFIBAQsICAgAAi BQ0BIBBBAWohBQtBrQEhEAyHAQsgAEHBATYCHCAAIAU2AgwgACAQQQFqNgIUQQAhEAygAQsgACgC BCEGIABBADYCBCAAIAYgEBCwgICAACIGDQEgEEEBaiEGC0GuASEQDIQBCyAAQcIBNgIcIAAgBjYC DCAAIBBBAWo2AhRBACEQDJ0BCyAAQQA2AhwgACAHNgIUIABBl4uAgAA2AhAgAEENNgIMQQAhEAyc AQsgAEEANgIcIAAgCDYCFCAAQeOQgIAANgIQIABBCTYCDEEAIRAMmwELIABBADYCHCAAIAg2AhQg AEGUjYCAADYCECAAQSE2AgxBACEQDJoBC0EBIRVBACEWQQAhEUEBIRALIAAgEDoAKyAJQQFqIQgC QAJAIAAtAC1BEHENAAJAAkACQCAALQAqDgMBAAIECyAVRQ0DDAILIBENAQwCCyAWRQ0BCyAAKAIE IRAgAEEANgIEIAAgECAIELSAgIAAIhBFDUcgAEHJATYCHCAAIAg2AhQgACAQNgIMQQAhEAyZAQsg ACgCBCEEIABBADYCBCAAIAQgCBC0gICAACIERQ2CASAAQcoBNgIcIAAgCDYCFCAAIAQ2AgxBACEQ DJgBCyAAKAIEIQQgAEEANgIEIAAgBCAJELSAgIAAIgRFDYABIABBywE2AhwgACAJNgIUIAAgBDYC DEEAIRAMlwELIAAoAgQhBCAAQQA2AgQgACAEIAoQtICAgAAiBEUNfiAAQc0BNgIcIAAgCjYCFCAA IAQ2AgxBACEQDJYBCyAAKAIEIQQgAEEANgIEIAAgBCALELSAgIAAIgRFDXwgAEHPATYCHCAAIAs2 AhQgACAENgIMQQAhEAyVAQsgAEEANgIcIAAgBDYCFCAAQZCzgIAANgIQIABBCDYCDCAAQQA2AgBB ACEQDJQBCyABQRVGDUwgAEEANgIcIAAgDDYCFCAAQcyOgIAANgIQIABBIDYCDAyRAQsgAEGBBDsB KCAAKAIEIRAgAEIANwMAIAAgECAMQQFqIgwQsoCAgAAiEEUNRCAAQdMBNgIcIAAgDDYCFCAAIBA2 AgxBACEQDJIBCyAAQQA2AgALIABBADYCHCAAIAQ2AhQgAEHYm4CAADYCECAAQQg2AgwMjgELIAAo AgQhECAAQgA3AwAgACAQIAtBAWoiCxCygICAACIQDQFBxgEhEAx1CyAAQQI6ACgMYgsgAEHVATYC HCAAIAs2AhQgACAQNgIMQQAhEAyNAQsgEEEVRg1EIABBADYCHCAAIAQ2AhQgAEGkjICAADYCECAA QRA2AgwMigELIAAtADRBAUcNQSAAIAQgAhDDgICAACIQRQ1BIBBBFUcNQiAAQdwBNgIcIAAgBDYC FCAAQdWWgIAANgIQIABBFTYCDEEAIRAMiwELIABBADYCHCAAQa+LgIAANgIQIABBAjYCDCAAIBFB AWo2AhQMiAELQQAhEAxvC0EBIRAMbgtBAiEQDG0LQQQhEAxsC0EHIRAMawtBDSEQDGoLQQ8hEAxp C0EQIRAMaAtBJCEQDGcLQRMhEAxmC0EUIRAMZQtBFiEQDGQLQRchEAxjC0EYIRAMYgtBGSEQDGEL QRohEAxgC0EbIRAMXwtBHCEQDF4LQR0hEAxdC0EfIRAMXAtBISEQDFsLQSMhEAxaC0HGACEQDFkL QSohEAxYC0EsIRAMVwtBLSEQDFYLQTohEAxVC0E8IRAMVAtBxQAhEAxTC0HJACEQDFILQcsAIRAM UQtBzAAhEAxQC0HOACEQDE8LQc8AIRAMTgtB0AAhEAxNC0HRACEQDEwLQdUAIRAMSwtB2AAhEAxK C0HZACEQDEkLQdsAIRAMSAtB3gAhEAxHC0HgACEQDEYLQeQAIRAMRQtB5QAhEAxEC0HxACEQDEML QfQAIRAMQgtBjQEhEAxBC0GXASEQDEALQakBIRAMPwtBqwEhEAw+C0GsASEQDD0LQcABIRAMPAtB uQEhEAw7C0GvASEQDDoLQbEBIRAMOQtBsgEhEAw4C0G0ASEQDDcLQbUBIRAMNgtBtgEhEAw1C0G3 ASEQDDQLQboBIRAMMwtBvQEhEAwyC0G+ASEQDDELQb8BIRAMMAtBwQEhEAwvCyAAQQA2AhwgACAE NgIUIABB6YuAgAA2AhAgAEEfNgIMDEYLIABB2wE2AhwgACAENgIUIABB+paAgAA2AhAgAEEVNgIM QQAhEAxHCyAAQfgANgIcIAAgDDYCFCAAQcqYgIAANgIQIABBFTYCDEEAIRAMRgsgAEHRADYCHCAA IAU2AhQgAEGwl4CAADYCECAAQRU2AgxBACEQDEULIABB+QA2AhwgACABNgIUIAAgEDYCDEEAIRAM RAsgAEH4ADYCHCAAIAE2AhQgAEHKmICAADYCECAAQRU2AgxBACEQDEMLIABB5AA2AhwgACABNgIU IABB45eAgAA2AhAgAEEVNgIMDEALIABB1wA2AhwgACABNgIUIABByZeAgAA2AhAgAEEVNgIMDD8L IABBADYCHCAAIAE2AhQgAEG5jYCAADYCECAAQRo2AgwMPgsgAEHCADYCHCAAIAE2AhQgAEHjmICA ADYCECAAQRU2AgwMPQsgAEEANgIEIAAgDyAPELiAgIAAIgRFDQEgAEE6NgIcIAAgBDYCDCAAIA9B AWo2AhQMPAsgACgCBCEEIABBADYCBAJAIAAgBCABELiAgIAAIgRFDQAgAEE7NgIcIAAgBDYCDCAA IAFBAWo2AhQMPAsgAUEBaiEBDCwLIA9BAWohAQwsCyAAQQA2AhwgACAPNgIUIABB5JKAgAA2AhAg AEEENgIMDDkLIABBNjYCHCAAIAQ2AhQgACACNgIMDDgLIABBLjYCHCAAIA42AhQgACAENgIMDDcL IABB0AA2AhwgACABNgIUIABBkZiAgAA2AhAgAEEVNgIMDDYLIA1BAWohAQwrCyAAQRU2AhwgACAB NgIUIABBgpmAgAA2AhAgAEEVNgIMDDQLIABBGzYCHCAAIAE2AhQgAEGRl4CAADYCECAAQRU2AgwM MwsgAEEPNgIcIAAgATYCFCAAQZGXgIAANgIQIABBFTYCDAwyCyAAQQs2AhwgACABNgIUIABBkZeA gAA2AhAgAEEVNgIMDDELIABBGjYCHCAAIAE2AhQgAEGCmYCAADYCECAAQRU2AgwMMAsgAEELNgIc IAAgATYCFCAAQYKZgIAANgIQIABBFTYCDAwvCyAAQQo2AhwgACABNgIUIABB5JaAgAA2AhAgAEEV NgIMDC4LIABBHjYCHCAAIAE2AhQgAEH5l4CAADYCECAAQRU2AgwMLQsgAEEANgIcIAAgEDYCFCAA QdqNgIAANgIQIABBFDYCDAwsCyAAQQQ2AhwgACABNgIUIABBsJiAgAA2AhAgAEEVNgIMDCsLIABB ADYCACALQQFqIQsLQbgBIRAMEQsgAEEANgIAIBBBAWohAUH1ACEQDBALIAEhAQJAIAAtAClBBUcN AEHjACEQDBALQeIAIRAMDwsgAEEANgIcIABB5JGAgAA2AhAgAEEHNgIMIAAgEUEBajYCFEEAIRAM KAsgAEEANgIAIBFBAWohAUHAACEQDA0LIAAgAToALCAAQQA2AgAgEUEBaiEBC0E9IRAMCwsgASEB C0E3IRAMCQsCQCABIg8gAkYNAANAAkAgDy0AAEGAvoCAAGotAAAiAUEBRg0AIAFBAkcNAyAPQQFq IQEMBAsgD0EBaiIPIAJHDQALQT4hEAwjC0E+IRAMIgsgAEEAOgAsIA8hAQwBC0ELIRAMBgtBOSEQ DAULIAFBAWohAUErIRAMBAsgACAROgAsIABBADYCACAWQQFqIQFBDCEQDAMLIABBADYCACARQQFq IQFBCiEQDAILIABBADYCAAsgAEEAOgAsIA0hAUEJIRAMAAsLIABBADYCHCAAIAs2AhQgAEHNkICA ADYCECAAQQk2AgxBACEQDBgLIABBADYCHCAAIAo2AhQgAEHpioCAADYCECAAQQk2AgxBACEQDBcL IABBADYCHCAAIAk2AhQgAEG3kICAADYCECAAQQk2AgxBACEQDBYLIABBADYCHCAAIAg2AhQgAEGc kYCAADYCECAAQQk2AgxBACEQDBULIABBADYCHCAAIAE2AhQgAEHNkICAADYCECAAQQk2AgwMEgsg AEEANgIcIAAgATYCFCAAQemKgIAANgIQIABBCTYCDAwRCyAAQQA2AhwgACABNgIUIABBt5CAgAA2 AhAgAEEJNgIMDBALIABBADYCHCAAIAE2AhQgAEGckYCAADYCECAAQQk2AgwMDwsgAEEANgIcIAAg ATYCFCAAQZeVgIAANgIQIABBDzYCDAwOCyAAQQA2AhwgACABNgIUIABBl5WAgAA2AhAgAEEPNgIM DA0LIABBADYCHCAAIAE2AhQgAEHAkoCAADYCECAAQQs2AgwMDAsgAEEANgIcIAAgATYCFCAAQZWJ gIAANgIQIABBCzYCDAwLCyAAQQA2AhwgACABNgIUIABB4Y+AgAA2AhAgAEEKNgIMDAoLIABBADYC HCAAIAE2AhQgAEH7j4CAADYCECAAQQo2AgwMCQsgAEEANgIcIAAgATYCFCAAQfGZgIAANgIQIABB AjYCDAwICyAAQQA2AhwgACABNgIUIABBxJSAgAA2AhAgAEECNgIMDAcLIABBADYCHCAAIAE2AhQg AEHylYCAADYCECAAQQI2AgwMBgsgAEECNgIcIAAgATYCFCAAQZyagIAANgIQIABBFjYCDAwFC0EB IRAMBgtB1AAhECABIgQgAkYNBSADQQhqIAAgBCACQdjCgIAAQQoQzICAgAAgAygCDCEEIAMoAggO AwEFAgALEIqAgIAAAAsgAEEANgIcIABBtZqAgAA2AhAgAEEXNgIMIAAgBEEBajYCFAwBCyAAQQA2 AhwgACAENgIUIABBypqAgAA2AhAgAEEJNgIMC0EAIRAMAQtBIiEQIAEiBCACRg0AIABBiYCAgAA2 AgggACAENgIEQSEhEAsgA0EQaiSAgICAACAQC68BAQJ/IAEoAgAhBgJAAkAgAiADRg0AIAQgBmoh BCAGIANqIAJrIQcgAiAGQX9zIAVqIgZqIQUDQAJAIAItAAAgBC0AAEYNAEECIQQMAwsCQCAGDQBB ACEEIAUhAgwDCyAGQX9qIQYgBEEBaiEEIAJBAWoiAiADRw0ACyAHIQYgAyECCyAAQQE2AgAgASAG NgIAIAAgAjYCBA8LIAFBADYCACAAIAQ2AgAgACACNgIECwuOSAEAQYAIC4ZIAQAAAAIAAAADAAAA AAAAAAAAAAAEAAAABQAAAAAAAAAAAAAABgAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJbnZhbGlkIGNoYXIgaW4gdXJsIHF1ZXJ5AFNwYW4gY2Fs bGJhY2sgZXJyb3IgaW4gb25fYm9keQBDb250ZW50LUxlbmd0aCBvdmVyZmxvdwBDaHVuayBzaXpl IG92ZXJmbG93AFJlc3BvbnNlIG92ZXJmbG93AEludmFsaWQgbWV0aG9kIGZvciBIVFRQL3gueCBy ZXF1ZXN0AEludmFsaWQgbWV0aG9kIGZvciBSVFNQL3gueCByZXF1ZXN0AEV4cGVjdGVkIFNPVVJD RSBtZXRob2QgZm9yIElDRS94LnggcmVxdWVzdABJbnZhbGlkIGNoYXIgaW4gdXJsIGZyYWdtZW50 IHN0YXJ0AEV4cGVjdGVkIGRvdABTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3N0YXR1cwBJbnZh bGlkIHJlc3BvbnNlIHN0YXR1cwBJbnZhbGlkIGNoYXJhY3RlciBpbiBjaHVuayBleHRlbnNpb25z AFVzZXIgY2FsbGJhY2sgZXJyb3IAYG9uX3Jlc2V0YCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtf aGVhZGVyYCBjYWxsYmFjayBlcnJvcgBgb25fbWVzc2FnZV9iZWdpbmAgY2FsbGJhY2sgZXJyb3IA YG9uX2NodW5rX2V4dGVuc2lvbl92YWx1ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX3N0YXR1c19jb21w bGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX3ZlcnNpb25fY29tcGxldGVgIGNhbGxiYWNrIGVycm9y AGBvbl91cmxfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9jaHVua19jb21wbGV0ZWAgY2Fs bGJhY2sgZXJyb3IAYG9uX2hlYWRlcl92YWx1ZV9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9u X21lc3NhZ2VfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9tZXRob2RfY29tcGxldGVgIGNh bGxiYWNrIGVycm9yAGBvbl9oZWFkZXJfZmllbGRfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBv bl9jaHVua19leHRlbnNpb25fbmFtZWAgY2FsbGJhY2sgZXJyb3IAVW5leHBlY3RlZCBjaGFyIGlu IHVybCBzZXJ2ZXIASW52YWxpZCBoZWFkZXIgdmFsdWUgY2hhcgBJbnZhbGlkIGhlYWRlciBmaWVs ZCBjaGFyAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fdmVyc2lvbgBJbnZhbGlkIG1pbm9yIHZl cnNpb24ASW52YWxpZCBtYWpvciB2ZXJzaW9uAEV4cGVjdGVkIHNwYWNlIGFmdGVyIHZlcnNpb24A RXhwZWN0ZWQgQ1JMRiBhZnRlciB2ZXJzaW9uAEludmFsaWQgSFRUUCB2ZXJzaW9uAEludmFsaWQg aGVhZGVyIHRva2VuAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fdXJsAEludmFsaWQgY2hhcmFj dGVycyBpbiB1cmwAVW5leHBlY3RlZCBzdGFydCBjaGFyIGluIHVybABEb3VibGUgQCBpbiB1cmwA RW1wdHkgQ29udGVudC1MZW5ndGgASW52YWxpZCBjaGFyYWN0ZXIgaW4gQ29udGVudC1MZW5ndGgA RHVwbGljYXRlIENvbnRlbnQtTGVuZ3RoAEludmFsaWQgY2hhciBpbiB1cmwgcGF0aABDb250ZW50 LUxlbmd0aCBjYW4ndCBiZSBwcmVzZW50IHdpdGggVHJhbnNmZXItRW5jb2RpbmcASW52YWxpZCBj aGFyYWN0ZXIgaW4gY2h1bmsgc2l6ZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2hlYWRlcl92 YWx1ZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2NodW5rX2V4dGVuc2lvbl92YWx1ZQBJbnZh bGlkIGNoYXJhY3RlciBpbiBjaHVuayBleHRlbnNpb25zIHZhbHVlAE1pc3NpbmcgZXhwZWN0ZWQg TEYgYWZ0ZXIgaGVhZGVyIHZhbHVlAEludmFsaWQgYFRyYW5zZmVyLUVuY29kaW5nYCBoZWFkZXIg dmFsdWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyBxdW90ZSB2YWx1ZQBJ bnZhbGlkIGNoYXJhY3RlciBpbiBjaHVuayBleHRlbnNpb25zIHF1b3RlZCB2YWx1ZQBQYXVzZWQg Ynkgb25faGVhZGVyc19jb21wbGV0ZQBJbnZhbGlkIEVPRiBzdGF0ZQBvbl9yZXNldCBwYXVzZQBv bl9jaHVua19oZWFkZXIgcGF1c2UAb25fbWVzc2FnZV9iZWdpbiBwYXVzZQBvbl9jaHVua19leHRl bnNpb25fdmFsdWUgcGF1c2UAb25fc3RhdHVzX2NvbXBsZXRlIHBhdXNlAG9uX3ZlcnNpb25fY29t cGxldGUgcGF1c2UAb25fdXJsX2NvbXBsZXRlIHBhdXNlAG9uX2NodW5rX2NvbXBsZXRlIHBhdXNl AG9uX2hlYWRlcl92YWx1ZV9jb21wbGV0ZSBwYXVzZQBvbl9tZXNzYWdlX2NvbXBsZXRlIHBhdXNl AG9uX21ldGhvZF9jb21wbGV0ZSBwYXVzZQBvbl9oZWFkZXJfZmllbGRfY29tcGxldGUgcGF1c2UA b25fY2h1bmtfZXh0ZW5zaW9uX25hbWUgcGF1c2UAVW5leHBlY3RlZCBzcGFjZSBhZnRlciBzdGFy dCBsaW5lAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fY2h1bmtfZXh0ZW5zaW9uX25hbWUASW52 YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyBuYW1lAFBhdXNlIG9uIENPTk5FQ1Qv VXBncmFkZQBQYXVzZSBvbiBQUkkvVXBncmFkZQBFeHBlY3RlZCBIVFRQLzIgQ29ubmVjdGlvbiBQ cmVmYWNlAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fbWV0aG9kAEV4cGVjdGVkIHNwYWNlIGFm dGVyIG1ldGhvZABTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2hlYWRlcl9maWVsZABQYXVzZWQA SW52YWxpZCB3b3JkIGVuY291bnRlcmVkAEludmFsaWQgbWV0aG9kIGVuY291bnRlcmVkAFVuZXhw ZWN0ZWQgY2hhciBpbiB1cmwgc2NoZW1hAFJlcXVlc3QgaGFzIGludmFsaWQgYFRyYW5zZmVyLUVu Y29kaW5nYABTV0lUQ0hfUFJPWFkAVVNFX1BST1hZAE1LQUNUSVZJVFkAVU5QUk9DRVNTQUJMRV9F TlRJVFkAQ09QWQBNT1ZFRF9QRVJNQU5FTlRMWQBUT09fRUFSTFkATk9USUZZAEZBSUxFRF9ERVBF TkRFTkNZAEJBRF9HQVRFV0FZAFBMQVkAUFVUAENIRUNLT1VUAEdBVEVXQVlfVElNRU9VVABSRVFV RVNUX1RJTUVPVVQATkVUV09SS19DT05ORUNUX1RJTUVPVVQAQ09OTkVDVElPTl9USU1FT1VUAExP R0lOX1RJTUVPVVQATkVUV09SS19SRUFEX1RJTUVPVVQAUE9TVABNSVNESVJFQ1RFRF9SRVFVRVNU AENMSUVOVF9DTE9TRURfUkVRVUVTVABDTElFTlRfQ0xPU0VEX0xPQURfQkFMQU5DRURfUkVRVUVT VABCQURfUkVRVUVTVABIVFRQX1JFUVVFU1RfU0VOVF9UT19IVFRQU19QT1JUAFJFUE9SVABJTV9B X1RFQVBPVABSRVNFVF9DT05URU5UAE5PX0NPTlRFTlQAUEFSVElBTF9DT05URU5UAEhQRV9JTlZB TElEX0NPTlNUQU5UAEhQRV9DQl9SRVNFVABHRVQASFBFX1NUUklDVABDT05GTElDVABURU1QT1JB UllfUkVESVJFQ1QAUEVSTUFORU5UX1JFRElSRUNUAENPTk5FQ1QATVVMVElfU1RBVFVTAEhQRV9J TlZBTElEX1NUQVRVUwBUT09fTUFOWV9SRVFVRVNUUwBFQVJMWV9ISU5UUwBVTkFWQUlMQUJMRV9G T1JfTEVHQUxfUkVBU09OUwBPUFRJT05TAFNXSVRDSElOR19QUk9UT0NPTFMAVkFSSUFOVF9BTFNP X05FR09USUFURVMATVVMVElQTEVfQ0hPSUNFUwBJTlRFUk5BTF9TRVJWRVJfRVJST1IAV0VCX1NF UlZFUl9VTktOT1dOX0VSUk9SAFJBSUxHVU5fRVJST1IASURFTlRJVFlfUFJPVklERVJfQVVUSEVO VElDQVRJT05fRVJST1IAU1NMX0NFUlRJRklDQVRFX0VSUk9SAElOVkFMSURfWF9GT1JXQVJERURf Rk9SAFNFVF9QQVJBTUVURVIAR0VUX1BBUkFNRVRFUgBIUEVfVVNFUgBTRUVfT1RIRVIASFBFX0NC X0NIVU5LX0hFQURFUgBNS0NBTEVOREFSAFNFVFVQAFdFQl9TRVJWRVJfSVNfRE9XTgBURUFSRE9X TgBIUEVfQ0xPU0VEX0NPTk5FQ1RJT04ASEVVUklTVElDX0VYUElSQVRJT04ARElTQ09OTkVDVEVE X09QRVJBVElPTgBOT05fQVVUSE9SSVRBVElWRV9JTkZPUk1BVElPTgBIUEVfSU5WQUxJRF9WRVJT SU9OAEhQRV9DQl9NRVNTQUdFX0JFR0lOAFNJVEVfSVNfRlJPWkVOAEhQRV9JTlZBTElEX0hFQURF Ul9UT0tFTgBJTlZBTElEX1RPS0VOAEZPUkJJRERFTgBFTkhBTkNFX1lPVVJfQ0FMTQBIUEVfSU5W QUxJRF9VUkwAQkxPQ0tFRF9CWV9QQVJFTlRBTF9DT05UUk9MAE1LQ09MAEFDTABIUEVfSU5URVJO QUwAUkVRVUVTVF9IRUFERVJfRklFTERTX1RPT19MQVJHRV9VTk9GRklDSUFMAEhQRV9PSwBVTkxJ TksAVU5MT0NLAFBSSQBSRVRSWV9XSVRIAEhQRV9JTlZBTElEX0NPTlRFTlRfTEVOR1RIAEhQRV9V TkVYUEVDVEVEX0NPTlRFTlRfTEVOR1RIAEZMVVNIAFBST1BQQVRDSABNLVNFQVJDSABVUklfVE9P X0xPTkcAUFJPQ0VTU0lORwBNSVNDRUxMQU5FT1VTX1BFUlNJU1RFTlRfV0FSTklORwBNSVNDRUxM QU5FT1VTX1dBUk5JTkcASFBFX0lOVkFMSURfVFJBTlNGRVJfRU5DT0RJTkcARXhwZWN0ZWQgQ1JM RgBIUEVfSU5WQUxJRF9DSFVOS19TSVpFAE1PVkUAQ09OVElOVUUASFBFX0NCX1NUQVRVU19DT01Q TEVURQBIUEVfQ0JfSEVBREVSU19DT01QTEVURQBIUEVfQ0JfVkVSU0lPTl9DT01QTEVURQBIUEVf Q0JfVVJMX0NPTVBMRVRFAEhQRV9DQl9DSFVOS19DT01QTEVURQBIUEVfQ0JfSEVBREVSX1ZBTFVF X0NPTVBMRVRFAEhQRV9DQl9DSFVOS19FWFRFTlNJT05fVkFMVUVfQ09NUExFVEUASFBFX0NCX0NI VU5LX0VYVEVOU0lPTl9OQU1FX0NPTVBMRVRFAEhQRV9DQl9NRVNTQUdFX0NPTVBMRVRFAEhQRV9D Ql9NRVRIT0RfQ09NUExFVEUASFBFX0NCX0hFQURFUl9GSUVMRF9DT01QTEVURQBERUxFVEUASFBF X0lOVkFMSURfRU9GX1NUQVRFAElOVkFMSURfU1NMX0NFUlRJRklDQVRFAFBBVVNFAE5PX1JFU1BP TlNFAFVOU1VQUE9SVEVEX01FRElBX1RZUEUAR09ORQBOT1RfQUNDRVBUQUJMRQBTRVJWSUNFX1VO QVZBSUxBQkxFAFJBTkdFX05PVF9TQVRJU0ZJQUJMRQBPUklHSU5fSVNfVU5SRUFDSEFCTEUAUkVT UE9OU0VfSVNfU1RBTEUAUFVSR0UATUVSR0UAUkVRVUVTVF9IRUFERVJfRklFTERTX1RPT19MQVJH RQBSRVFVRVNUX0hFQURFUl9UT09fTEFSR0UAUEFZTE9BRF9UT09fTEFSR0UASU5TVUZGSUNJRU5U X1NUT1JBR0UASFBFX1BBVVNFRF9VUEdSQURFAEhQRV9QQVVTRURfSDJfVVBHUkFERQBTT1VSQ0UA QU5OT1VOQ0UAVFJBQ0UASFBFX1VORVhQRUNURURfU1BBQ0UAREVTQ1JJQkUAVU5TVUJTQ1JJQkUA UkVDT1JEAEhQRV9JTlZBTElEX01FVEhPRABOT1RfRk9VTkQAUFJPUEZJTkQAVU5CSU5EAFJFQklO RABVTkFVVEhPUklaRUQATUVUSE9EX05PVF9BTExPV0VEAEhUVFBfVkVSU0lPTl9OT1RfU1VQUE9S VEVEAEFMUkVBRFlfUkVQT1JURUQAQUNDRVBURUQATk9UX0lNUExFTUVOVEVEAExPT1BfREVURUNU RUQASFBFX0NSX0VYUEVDVEVEAEhQRV9MRl9FWFBFQ1RFRABDUkVBVEVEAElNX1VTRUQASFBFX1BB VVNFRABUSU1FT1VUX09DQ1VSRUQAUEFZTUVOVF9SRVFVSVJFRABQUkVDT05ESVRJT05fUkVRVUlS RUQAUFJPWFlfQVVUSEVOVElDQVRJT05fUkVRVUlSRUQATkVUV09SS19BVVRIRU5USUNBVElPTl9S RVFVSVJFRABMRU5HVEhfUkVRVUlSRUQAU1NMX0NFUlRJRklDQVRFX1JFUVVJUkVEAFVQR1JBREVf UkVRVUlSRUQAUEFHRV9FWFBJUkVEAFBSRUNPTkRJVElPTl9GQUlMRUQARVhQRUNUQVRJT05fRkFJ TEVEAFJFVkFMSURBVElPTl9GQUlMRUQAU1NMX0hBTkRTSEFLRV9GQUlMRUQATE9DS0VEAFRSQU5T Rk9STUFUSU9OX0FQUExJRUQATk9UX01PRElGSUVEAE5PVF9FWFRFTkRFRABCQU5EV0lEVEhfTElN SVRfRVhDRUVERUQAU0lURV9JU19PVkVSTE9BREVEAEhFQUQARXhwZWN0ZWQgSFRUUC8AAF4TAAAm EwAAMBAAAPAXAACdEwAAFRIAADkXAADwEgAAChAAAHUSAACtEgAAghMAAE8UAAB/EAAAoBUAACMU AACJEgAAixQAAE0VAADUEQAAzxQAABAYAADJFgAA3BYAAMERAADgFwAAuxQAAHQUAAB8FQAA5RQA AAgXAAAfEAAAZRUAAKMUAAAoFQAAAhUAAJkVAAAsEAAAixkAAE8PAADUDgAAahAAAM4QAAACFwAA iQ4AAG4TAAAcEwAAZhQAAFYXAADBEwAAzRMAAGwTAABoFwAAZhcAAF8XAAAiEwAAzg8AAGkOAADY DgAAYxYAAMsTAACqDgAAKBcAACYXAADFEwAAXRYAAOgRAABnEwAAZRMAAPIWAABzEwAAHRcAAPkW AADzEQAAzw4AAM4VAAAMEgAAsxEAAKURAABhEAAAMhcAALsTAAAAAAAAAAAAAAAAAAAAAAAAAAEA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQECAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAwICAgIC AAACAgACAgACAgICAgICAgICAAQAAAAAAAICAgICAgICAgICAgICAgICAgICAgICAgICAAAAAgIC AgICAgICAgICAgICAgICAgICAgICAgICAgIAAgACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAEAAAAAAAAAAAAAAAAAAAAAAAAAAgACAgICAgAAAgIAAgIAAgICAgICAgICAgADAAQAAAACAgIC AgICAgICAgICAgICAgICAgICAgICAgAAAAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAAIA AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAGxvc2VlZXAtYWxpdmUAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBAQEBAQECAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAWNodW5rZWQAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAEBAQEBAAABAQABAQABAQEBAQEBAQEBAAAAAAAAAAEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEA AQABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAZWN0aW9uZW50LWxlbmd0aG9ucm94eS1jb25uZWN0aW9uAAAAAAAA AAAAAAAAAAAAcmFuc2Zlci1lbmNvZGluZ3BncmFkZQ0KDQoNClNNDQoNClRUUC9DRS9UU1AvAAAA AAAAAAAAAAAAAQIAAQMAAAAAAAAAAAAAAAAAAAAAAAAEAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAECAAEDAAAAAAAAAAAAAAAAAAAA AAAABAEBBQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEA AAAAAAAAAAABAAABAAAAAAAAAAAAAAAAAAAAAAAAAAABAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAEAAAIAAAAAAAAAAAAAAAAAAAAA AAADBAAABAQEBAQEBAQEBAQFBAQEBAQEBAQEBAQEAAQABgcEBAQEBAQEBAQEBAQEBAQEBAQEBAQE BAQEBAQABAAEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAABAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAABAAABAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC AAAAAAAAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMD AwMDAwMDAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAQAAAAAAAAAAAAAAAAAAAAAA AAEAAAAAAAAAAAACAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMD AwMDAAAAAAAAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk9V TkNFRUNLT1VUTkVDVEVURUNSSUJFTFVTSEVURUFEU0VBUkNIUkdFQ1RJVklUWUxFTkRBUlZFT1RJ RllQVElPTlNDSFNFQVlTVEFUQ0hHRU9SRElSRUNUT1JUUkNIUEFSQU1FVEVSVVJDRUJTQ1JJQkVB UkRPV05BQ0VJTkROS0NLVUJTQ1JJQkVIVFRQL0FEVFAv";
}
});
// lib/client.js
var require_client = __commonJS({
"lib/client.js"(exports2, module2) {
"use strict";
var assert = require("assert");
var net = require("net");
var util = require_util();
var Request = require_request2();
var DispatcherBase = require_dispatcher_base();
var {
RequestContentLengthMismatchError,
ResponseContentLengthMismatchError,
InvalidArgumentError,
RequestAbortedError,
HeadersTimeoutError,
HeadersOverflowError,
SocketError,
InformationalError,
BodyTimeoutError,
HTTPParserError,
ResponseExceededMaxSizeError
} = 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
} = require_symbols();
var kClosedResolve = Symbol("kClosedResolve");
var channels = {};
try {
const diagnosticsChannel = require("diagnostics_channel");
channels.sendHeaders = diagnosticsChannel.channel("undici:client:sendHeaders");
channels.beforeConnect = diagnosticsChannel.channel("undici:client:beforeConnect");
channels.connectError = diagnosticsChannel.channel("undici:client:connectError");
channels.connected = diagnosticsChannel.channel("undici:client:connected");
} catch {
channels.sendHeaders = { hasSubscribers: false };
channels.beforeConnect = { hasSubscribers: false };
channels.connectError = { hasSubscribers: false };
channels.connected = { hasSubscribers: false };
}
var Client = class extends DispatcherBase {
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
} = {}) {
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 (typeof connect2 !== "function") {
connect2 = buildConnector({
...tls,
maxCachedSessions,
socketPath,
timeout: connectTimeout,
...connect2
});
}
this[kInterceptors] = interceptors && 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 || 16384;
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 : 3e4;
this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e4;
this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength;
this[kMaxRedirections] = maxRedirections;
this[kMaxRequests] = maxRequestsPerClient;
this[kClosedResolve] = null;
this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1;
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 = new Request(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.destroy(resolve);
} else {
this[kClosedResolve] = resolve;
}
});
}
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 = () => {
if (this[kClosedResolve]) {
this[kClosedResolve]();
this[kClosedResolve] = null;
}
resolve();
};
if (!this[kSocket]) {
queueMicrotask(callback);
} else {
util.destroy(this[kSocket].on("close", callback), err);
}
resume(this);
});
}
};
var constants = require_constants2();
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(Buffer.from(require("./llhttp/llhttp_simd.wasm.js"), "base64"));
} catch (e) {
mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || require_llhttp_wasm(), "base64"));
}
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;
const end = start + len;
return currentParser.onStatus(currentBufferRef.slice(start, end)) || 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;
const end = start + len;
return currentParser.onHeaderField(currentBufferRef.slice(start, end)) || 0;
},
wasm_on_header_value: (p, at, len) => {
assert.strictEqual(currentParser.ptr, p);
const start = at - currentBufferPtr;
const end = start + len;
return currentParser.onHeaderValue(currentBufferRef.slice(start, end)) || 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;
const end = start + len;
return currentParser.onBody(currentBufferRef.slice(start, end)) || 0;
},
wasm_on_message_complete: (p) => {
assert.strictEqual(currentParser.ptr, p);
return currentParser.onMessageComplete() || 0;
}
/* eslint-enable camelcase */
}
});
}
var llhttpInstance = null;
var llhttpPromise = lazyllhttp().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 {
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.maxResponseSize = client[kMaxResponseSize];
}
setTimeout(value, type) {
this.timeoutType = type;
if (value !== this.timeoutValue) {
clearTimeout(this.timeout);
if (value) {
this.timeout = 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 = 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;
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;
}
}
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 && key.toString().toLowerCase() === "keep-alive") {
this.keepAlive += buf.toString();
} else if (key.length === 14 && key.toString().toLowerCase() === "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;
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 (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;
}
let pause;
try {
pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false;
} catch (err) {
util.destroy(socket, err);
return -1;
}
if (request.method === "HEAD") {
assert(socket[kReset]);
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;
try {
if (request.onData(buf) === false) {
return constants.ERROR.PAUSED;
}
} catch (err) {
util.destroy(socket, err);
return -1;
}
}
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 = "";
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;
}
try {
request.onComplete(headers);
} catch (err) {
errorRequest(client, request, err);
}
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"));
}
}
function onSocketReadable() {
const { [kParser]: parser } = this;
parser.readMore();
}
function onSocketError(err) {
const { [kParser]: parser } = this;
assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) {
parser.onMessageComplete();
return;
}
this[kError] = err;
onError(this[kClient], err);
}
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);
}
}
function onSocketEnd() {
const { [kParser]: parser } = this;
if (parser.statusCode && !parser.shouldKeepAlive) {
parser.onMessageComplete();
return;
}
util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
}
function onSocketClose() {
const { [kClient]: client } = this;
if (!this[kError] && this[kParser].statusCode && !this[kParser].shouldKeepAlive) {
this[kParser].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);
}
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.substr(1, idx - 1);
assert(net.isIP(ip));
hostname = ip;
}
client[kConnecting] = true;
if (channels.beforeConnect.hasSubscribers) {
channels.beforeConnect.publish({
connectParams: {
host,
hostname,
protocol,
port,
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 (!llhttpInstance) {
llhttpInstance = await llhttpPromise;
llhttpPromise = null;
}
client[kConnecting] = false;
assert(socket);
client[kSocket] = socket;
socket[kNoRef] = false;
socket[kWriting] = false;
socket[kReset] = false;
socket[kBlocking] = false;
socket[kError] = null;
socket[kParser] = new Parser(client, socket, llhttpInstance);
socket[kClient] = client;
socket[kCounter] = 0;
socket[kMaxRequests] = client[kMaxRequests];
socket.on("error", onSocketError).on("readable", onSocketReadable).on("end", onSocketEnd).on("close", onSocketClose);
if (channels.connected.hasSubscribers) {
channels.connected.publish({
connectParams: {
host,
hostname,
protocol,
port,
servername: client[kServerName],
localAddress: client[kLocalAddress]
},
connector: client[kConnector],
socket
});
}
client.emit("connect", client[kUrl], [client]);
} catch (err) {
client[kConnecting] = false;
if (channels.connectError.hasSubscribers) {
channels.connectError.publish({
connectParams: {
host,
hostname,
protocol,
port,
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);
}
function emitDrain(client) {
client[kNeedDrain] = 0;
client.emit("drain", client[kUrl], [client]);
}
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;
}
}
function _resume(client, sync) {
while (true) {
if (client.destroyed) {
assert(client[kPending] === 0);
return;
}
if (client.closed && !client[kSize]) {
client.destroy();
return;
}
const socket = client[kSocket];
if (socket) {
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) {
connect(client);
continue;
}
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 (util.isStream(request.body) && util.bodyLength(request.body) === 0) {
request.body.on(
"data",
/* istanbul ignore next */
function() {
assert(false);
}
).on("error", function(err) {
errorRequest(client, request, err);
}).on("end", function() {
util.destroy(this);
});
request.body = null;
}
if (client[kRunning] > 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);
}
}
}
function write(client, request) {
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);
}
let contentLength = util.bodyLength(body);
if (contentLength === null) {
contentLength = request.contentLength;
}
if (contentLength === 0 && !expectsPayload) {
contentLength = null;
}
if (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) {
socket[kReset] = true;
}
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) {
if (contentLength === 0) {
socket.write(`${header}content-length: 0\r
\r
`, "ascii");
} else {
assert(contentLength === null, "no body must not have content length");
socket.write(`${header}\r
`, "ascii");
}
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
`, "ascii");
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;
}
function writeStream({ body, client, request, socket, contentLength, header, expectsPayload }) {
assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
let finished = false;
const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header });
const onData = function(chunk) {
try {
assert(!finished);
if (!writer.write(chunk) && this.pause) {
this.pause();
}
} catch (err) {
util.destroy(this, err);
}
};
const onDrain = function() {
assert(!finished);
if (body.resume) {
body.resume();
}
};
const onAbort = function() {
onFinished(new RequestAbortedError());
};
const onFinished = 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("error", onFinished).removeListener("close", onAbort);
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);
}
};
body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onAbort);
if (body.resume) {
body.resume();
}
socket.on("drain", onDrain).on("error", onFinished);
}
async function writeBlob({ body, client, request, socket, contentLength, header, expectsPayload }) {
assert(contentLength === body.size, "blob body must have content length");
try {
if (contentLength != null && contentLength !== body.size) {
throw new RequestContentLengthMismatchError();
}
const buffer = Buffer.from(await body.arrayBuffer());
socket.cork();
socket.write(`${header}content-length: ${contentLength}\r
\r
`, "ascii");
socket.write(buffer);
socket.uncork();
request.onBodySent(buffer);
request.onRequestSent();
if (!expectsPayload) {
socket[kReset] = true;
}
resume(client);
} catch (err) {
util.destroy(socket, err);
}
}
async function writeIterable({ 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();
}
}
const waitForDrain = () => new Promise((resolve, reject) => {
assert(callback === null);
if (socket[kError]) {
reject(socket[kError]);
} else {
callback = resolve;
}
});
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);
}
}
var AsyncWriter = class {
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());
}
if (bytesWritten === 0) {
if (!expectsPayload) {
socket[kReset] = true;
}
if (contentLength === null) {
socket.write(`${header}transfer-encoding: chunked\r
`, "ascii");
} else {
socket.write(`${header}content-length: ${contentLength}\r
\r
`, "ascii");
}
}
if (contentLength === null) {
socket.write(`\r
${len.toString(16)}\r
`, "ascii");
}
this.bytesWritten += len;
const ret = socket.write(chunk);
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
`, "ascii");
} else {
socket.write(`${header}\r
`, "ascii");
}
} else if (contentLength === null) {
socket.write("\r\n0\r\n\r\n", "ascii");
}
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);
}
}
module2.exports = Client;
}
});
// 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 {
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 {
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 {
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 {
constructor() {
super();
this[kQueue] = new FixedQueue();
this[kClients] = [];
this[kQueued] = 0;
const pool = this;
this[kOnDrain] = 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]);
}
};
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/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);
}
var Pool = class extends PoolBase {
constructor(origin, {
connections,
factory = defaultFactory,
connect,
connectTimeout,
tls,
maxCachedSessions,
socketPath,
...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,
socketPath,
timeout: connectTimeout == null ? 1e4 : connectTimeout,
...connect
});
}
this[kInterceptors] = options.interceptors && 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 };
this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
this[kFactory] = factory;
}
[kGetDispatcher]() {
let dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain]);
if (dispatcher) {
return dispatcher;
}
if (!this[kConnections] || this[kClients].length < this[kConnections]) {
dispatcher = this[kFactory](this[kUrl], this[kOptions]);
this[kAddClient](dispatcher);
}
return dispatcher;
}
};
module2.exports = Pool;
}
});
// lib/balanced-pool.js
var require_balanced_pool = __commonJS({
"lib/balanced-pool.js"(exports2, module2) {
"use strict";
var {
BalancedPoolMissingUpstreamError,
InvalidArgumentError
} = require_errors();
var {
PoolBase,
kClients,
kNeedDrain,
kAddClient,
kRemoveClient,
kGetDispatcher
} = require_pool_base();
var Pool = require_pool();
var { kUrl, kInterceptors } = require_symbols();
var { parseOrigin } = require_util();
var kFactory = Symbol("factory");
var kOptions = Symbol("options");
var kGreatestCommonDivisor = Symbol("kGreatestCommonDivisor");
var kCurrentWeight = Symbol("kCurrentWeight");
var kIndex = Symbol("kIndex");
var kWeight = Symbol("kWeight");
var kMaxWeightPerServer = Symbol("kMaxWeightPerServer");
var kErrorPenalty = Symbol("kErrorPenalty");
function getGreatestCommonDivisor(a, b) {
if (b === 0)
return a;
return getGreatestCommonDivisor(b, a % b);
}
function defaultFactory(origin, opts) {
return new Pool(origin, opts);
}
var BalancedPool = class extends PoolBase {
constructor(upstreams = [], { factory = defaultFactory, ...opts } = {}) {
super();
this[kOptions] = opts;
this[kIndex] = -1;
this[kCurrentWeight] = 0;
this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100;
this[kErrorPenalty] = this[kOptions].errorPenalty || 15;
if (!Array.isArray(upstreams)) {
upstreams = [upstreams];
}
if (typeof factory !== "function") {
throw new InvalidArgumentError("factory must be a function.");
}
this[kInterceptors] = opts.interceptors && opts.interceptors.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) ? opts.interceptors.BalancedPool : [];
this[kFactory] = factory;
for (const upstream of upstreams) {
this.addUpstream(upstream);
}
this._updateBalancedPoolStats();
}
addUpstream(upstream) {
const upstreamOrigin = parseOrigin(upstream).origin;
if (this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true)) {
return this;
}
const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions]));
this[kAddClient](pool);
pool.on("connect", () => {
pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty]);
});
pool.on("connectionError", () => {
pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]);
this._updateBalancedPoolStats();
});
pool.on("disconnect", (...args) => {
const err = args[2];
if (err && err.code === "UND_ERR_SOCKET") {
pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]);
this._updateBalancedPoolStats();
}
});
for (const client of this[kClients]) {
client[kWeight] = this[kMaxWeightPerServer];
}
this._updateBalancedPoolStats();
return this;
}
_updateBalancedPoolStats() {
this[kGreatestCommonDivisor] = this[kClients].map((p) => p[kWeight]).reduce(getGreatestCommonDivisor, 0);
}
removeUpstream(upstream) {
const upstreamOrigin = parseOrigin(upstream).origin;
const pool = this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true);
if (pool) {
this[kRemoveClient](pool);
}
return this;
}
get upstreams() {
return this[kClients].filter((dispatcher) => dispatcher.closed !== true && dispatcher.destroyed !== true).map((p) => p[kUrl].origin);
}
[kGetDispatcher]() {
if (this[kClients].length === 0) {
throw new BalancedPoolMissingUpstreamError();
}
const dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain] && dispatcher2.closed !== true && dispatcher2.destroyed !== true);
if (!dispatcher) {
return;
}
const allClientsBusy = this[kClients].map((pool) => pool[kNeedDrain]).reduce((a, b) => a && b, true);
if (allClientsBusy) {
return;
}
let counter = 0;
let maxWeightIndex = this[kClients].findIndex((pool) => !pool[kNeedDrain]);
while (counter++ < this[kClients].length) {
this[kIndex] = (this[kIndex] + 1) % this[kClients].length;
const pool = this[kClients][this[kIndex]];
if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) {
maxWeightIndex = this[kIndex];
}
if (this[kIndex] === 0) {
this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor];
if (this[kCurrentWeight] <= 0) {
this[kCurrentWeight] = this[kMaxWeightPerServer];
}
}
if (pool[kWeight] >= this[kCurrentWeight] && !pool[kNeedDrain]) {
return pool;
}
}
this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight];
this[kIndex] = maxWeightIndex;
return this[kClients][maxWeightIndex];
}
};
module2.exports = BalancedPool;
}
});
// 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 { WeakRef: WeakRef2, FinalizationRegistry } = require_dispatcher_weakref()();
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 kFinalizer = Symbol("finalizer");
var kOptions = Symbol("options");
function defaultFactory(origin, opts) {
return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
}
var Agent = class extends DispatcherBase {
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 && 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[kFinalizer] = new FinalizationRegistry(
/* istanbul ignore next: gc is undeterministic */
(key) => {
const ref = this[kClients].get(key);
if (ref !== void 0 && ref.deref() === void 0) {
this[kClients].delete(key);
}
}
);
const agent = this;
this[kOnDrain] = (origin, targets) => {
agent.emit("drain", origin, [agent, ...targets]);
};
this[kOnConnect] = (origin, targets) => {
agent.emit("connect", origin, [agent, ...targets]);
};
this[kOnDisconnect] = (origin, targets, err) => {
agent.emit("disconnect", origin, [agent, ...targets], err);
};
this[kOnConnectionError] = (origin, targets, err) => {
agent.emit("connectionError", origin, [agent, ...targets], err);
};
}
get [kRunning]() {
let ret = 0;
for (const ref of this[kClients].values()) {
const client = ref.deref();
if (client) {
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.");
}
const ref = this[kClients].get(key);
let dispatcher = ref ? ref.deref() : null;
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, new WeakRef2(dispatcher));
this[kFinalizer].register(dispatcher, key);
}
return dispatcher.dispatch(opts, handler);
}
async [kClose]() {
const closePromises = [];
for (const ref of this[kClients].values()) {
const client = ref.deref();
if (client) {
closePromises.push(client.close());
}
}
await Promise.all(closePromises);
}
async [kDestroy](err) {
const destroyPromises = [];
for (const ref of this[kClients].values()) {
const client = ref.deref();
if (client) {
destroyPromises.push(client.destroy(err));
}
}
await Promise.all(destroyPromises);
}
};
module2.exports = Agent;
}
});
// lib/api/readable.js
var require_readable = __commonJS({
"lib/api/readable.js"(exports2, module2) {
"use strict";
var assert = require("assert");
var { Readable } = require("stream");
var { RequestAbortedError, NotSupportedError } = require_errors();
var util = require_util();
var { ReadableStreamFrom, toUSVString } = require_util();
var Blob2;
var kConsume = Symbol("kConsume");
var kReading = Symbol("kReading");
var kBody = Symbol("kBody");
var kAbort = Symbol("abort");
var kContentType = Symbol("kContentType");
module2.exports = class BodyReadable extends Readable {
constructor(resume, abort, contentType = "") {
super({
autoDestroy: true,
read: resume,
highWaterMark: 64 * 1024
// Same as nodejs fs streams.
});
this._readableState.dataEmitted = false;
this[kAbort] = abort;
this[kConsume] = null;
this[kBody] = null;
this[kContentType] = contentType;
this[kReading] = false;
}
destroy(err) {
if (this.destroyed) {
return this;
}
if (!err && !this._readableState.endEmitted) {
err = new RequestAbortedError();
}
if (err) {
this[kAbort]();
}
return super.destroy(err);
}
emit(ev, ...args) {
if (ev === "data") {
this._readableState.dataEmitted = true;
} else if (ev === "error") {
this._readableState.errorEmitted = true;
}
return super.emit(ev, ...args);
}
on(ev, ...args) {
if (ev === "data" || ev === "readable") {
this[kReading] = true;
}
return super.on(ev, ...args);
}
addListener(ev, ...args) {
return this.on(ev, ...args);
}
off(ev, ...args) {
const ret = super.off(ev, ...args);
if (ev === "data" || ev === "readable") {
this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0;
}
return ret;
}
removeListener(ev, ...args) {
return this.off(ev, ...args);
}
push(chunk) {
if (this[kConsume] && chunk !== null && this.readableLength === 0) {
consumePush(this[kConsume], chunk);
return this[kReading] ? super.push(chunk) : true;
}
return super.push(chunk);
}
// https://fetch.spec.whatwg.org/#dom-body-text
async text() {
return consume(this, "text");
}
// https://fetch.spec.whatwg.org/#dom-body-json
async json() {
return consume(this, "json");
}
// https://fetch.spec.whatwg.org/#dom-body-blob
async blob() {
return consume(this, "blob");
}
// https://fetch.spec.whatwg.org/#dom-body-arraybuffer
async arrayBuffer() {
return consume(this, "arrayBuffer");
}
// https://fetch.spec.whatwg.org/#dom-body-formdata
async formData() {
throw new NotSupportedError();
}
// https://fetch.spec.whatwg.org/#dom-body-bodyused
get bodyUsed() {
return util.isDisturbed(this);
}
// https://fetch.spec.whatwg.org/#dom-body-body
get body() {
if (!this[kBody]) {
this[kBody] = ReadableStreamFrom(this);
if (this[kConsume]) {
this[kBody].getReader();
assert(this[kBody].locked);
}
}
return this[kBody];
}
async dump(opts) {
let limit = opts && Number.isFinite(opts.limit) ? opts.limit : 262144;
try {
for await (const chunk of this) {
limit -= Buffer.byteLength(chunk);
if (limit < 0) {
return;
}
}
} catch {
}
}
};
function isLocked(self) {
return self[kBody] && self[kBody].locked === true || self[kConsume];
}
function isUnusable(self) {
return util.isDisturbed(self) || isLocked(self);
}
async function consume(stream, type) {
if (isUnusable(stream)) {
throw new TypeError("unusable");
}
assert(!stream[kConsume]);
return new Promise((resolve, reject) => {
stream[kConsume] = {
type,
stream,
resolve,
reject,
length: 0,
body: []
};
stream.on("error", function(err) {
consumeFinish(this[kConsume], err);
}).on("close", function() {
if (this[kConsume].body !== null) {
consumeFinish(this[kConsume], new RequestAbortedError());
}
});
process.nextTick(consumeStart, stream[kConsume]);
});
}
function consumeStart(consume2) {
if (consume2.body === null) {
return;
}
const { _readableState: state } = consume2.stream;
for (const chunk of state.buffer) {
consumePush(consume2, chunk);
}
if (state.endEmitted) {
consumeEnd(this[kConsume]);
} else {
consume2.stream.on("end", function() {
consumeEnd(this[kConsume]);
});
}
consume2.stream.resume();
while (consume2.stream.read() != null) {
}
}
function consumeEnd(consume2) {
const { type, body, resolve, stream, length } = consume2;
try {
if (type === "text") {
resolve(toUSVString(Buffer.concat(body)));
} else if (type === "json") {
resolve(JSON.parse(Buffer.concat(body)));
} else if (type === "arrayBuffer") {
const dst = new Uint8Array(length);
let pos = 0;
for (const buf of body) {
dst.set(buf, pos);
pos += buf.byteLength;
}
resolve(dst);
} else if (type === "blob") {
if (!Blob2) {
Blob2 = require("buffer").Blob;
}
resolve(new Blob2(body, { type: stream[kContentType] }));
}
consumeFinish(consume2);
} catch (err) {
stream.destroy(err);
}
}
function consumePush(consume2, chunk) {
consume2.length += chunk.length;
consume2.body.push(chunk);
}
function consumeFinish(consume2, err) {
if (consume2.body === null) {
return;
}
if (err) {
consume2.reject(err);
} else {
consume2.resolve();
}
consume2.type = null;
consume2.stream = null;
consume2.resolve = null;
consume2.reject = null;
consume2.length = 0;
consume2.body = null;
}
}
});
// lib/api/abort-signal.js
var require_abort_signal = __commonJS({
"lib/api/abort-signal.js"(exports2, module2) {
var { RequestAbortedError } = require_errors();
var kListener = Symbol("kListener");
var kSignal = Symbol("kSignal");
function abort(self) {
if (self.abort) {
self.abort();
} else {
self.onError(new RequestAbortedError());
}
}
function addSignal(self, signal) {
self[kSignal] = null;
self[kListener] = null;
if (!signal) {
return;
}
if (signal.aborted) {
abort(self);
return;
}
self[kSignal] = signal;
self[kListener] = () => {
abort(self);
};
if ("addEventListener" in self[kSignal]) {
self[kSignal].addEventListener("abort", self[kListener]);
} else {
self[kSignal].addListener("abort", self[kListener]);
}
}
function removeSignal(self) {
if (!self[kSignal]) {
return;
}
if ("removeEventListener" in self[kSignal]) {
self[kSignal].removeEventListener("abort", self[kListener]);
} else {
self[kSignal].removeListener("abort", self[kListener]);
}
self[kSignal] = null;
self[kListener] = null;
}
module2.exports = {
addSignal,
removeSignal
};
}
});
// lib/api/api-request.js
var require_api_request = __commonJS({
"lib/api/api-request.js"(exports2, module2) {
"use strict";
var Readable = require_readable();
var {
InvalidArgumentError,
RequestAbortedError,
ResponseStatusCodeError
} = require_errors();
var util = require_util();
var { AsyncResource } = require("async_hooks");
var { addSignal, removeSignal } = require_abort_signal();
var RequestHandler = class extends AsyncResource {
constructor(opts, callback) {
if (!opts || typeof opts !== "object") {
throw new InvalidArgumentError("invalid opts");
}
const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts;
try {
if (typeof callback !== "function") {
throw new InvalidArgumentError("invalid callback");
}
if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
}
if (method === "CONNECT") {
throw new InvalidArgumentError("invalid method");
}
if (onInfo && typeof onInfo !== "function") {
throw new InvalidArgumentError("invalid onInfo callback");
}
super("UNDICI_REQUEST");
} catch (err) {
if (util.isStream(body)) {
util.destroy(body.on("error", util.nop), err);
}
throw err;
}
this.responseHeaders = responseHeaders || null;
this.opaque = opaque || null;
this.callback = callback;
this.res = null;
this.abort = null;
this.body = body;
this.trailers = {};
this.context = null;
this.onInfo = onInfo || null;
this.throwOnError = throwOnError;
if (util.isStream(body)) {
body.on("error", (err) => {
this.onError(err);
});
}
addSignal(this, signal);
}
onConnect(abort, context) {
if (!this.callback) {
throw new RequestAbortedError();
}
this.abort = abort;
this.context = context;
}
onHeaders(statusCode, rawHeaders, resume, statusMessage) {
const { callback, opaque, abort, context } = this;
if (statusCode < 200) {
if (this.onInfo) {
const headers2 = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
this.onInfo({ statusCode, headers: headers2 });
}
return;
}
const parsedHeaders = util.parseHeaders(rawHeaders);
const contentType = parsedHeaders["content-type"];
const body = new Readable(resume, abort, contentType);
this.callback = null;
this.res = body;
const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
if (callback !== null) {
if (this.throwOnError && statusCode >= 400) {
this.runInAsyncScope(
getResolveErrorBodyCallback,
null,
{ callback, body, contentType, statusCode, statusMessage, headers }
);
return;
}
this.runInAsyncScope(callback, null, null, {
statusCode,
headers,
trailers: this.trailers,
opaque,
body,
context
});
}
}
onData(chunk) {
const { res } = this;
return res.push(chunk);
}
onComplete(trailers) {
const { res } = this;
removeSignal(this);
util.parseHeaders(trailers, this.trailers);
res.push(null);
}
onError(err) {
const { res, callback, body, opaque } = this;
removeSignal(this);
if (callback) {
this.callback = null;
queueMicrotask(() => {
this.runInAsyncScope(callback, null, err, { opaque });
});
}
if (res) {
this.res = null;
queueMicrotask(() => {
util.destroy(res, err);
});
}
if (body) {
this.body = null;
util.destroy(body, err);
}
}
};
async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) {
if (statusCode === 204 || !contentType) {
body.dump();
process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers));
return;
}
try {
if (contentType.startsWith("application/json")) {
const payload = await body.json();
process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload));
return;
}
if (contentType.startsWith("text/")) {
const payload = await body.text();
process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload));
return;
}
} catch (err) {
}
body.dump();
process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers));
}
function request(opts, callback) {
if (callback === void 0) {
return new Promise((resolve, reject) => {
request.call(this, opts, (err, data) => {
return err ? reject(err) : resolve(data);
});
});
}
try {
this.dispatch(opts, new RequestHandler(opts, callback));
} catch (err) {
if (typeof callback !== "function") {
throw err;
}
const opaque = opts && opts.opaque;
queueMicrotask(() => callback(err, { opaque }));
}
}
module2.exports = request;
}
});
// lib/api/api-stream.js
var require_api_stream = __commonJS({
"lib/api/api-stream.js"(exports2, module2) {
"use strict";
var { finished } = require("stream");
var {
InvalidArgumentError,
InvalidReturnValueError,
RequestAbortedError
} = require_errors();
var util = require_util();
var { AsyncResource } = require("async_hooks");
var { addSignal, removeSignal } = require_abort_signal();
var StreamHandler = class extends AsyncResource {
constructor(opts, factory, callback) {
if (!opts || typeof opts !== "object") {
throw new InvalidArgumentError("invalid opts");
}
const { signal, method, opaque, body, onInfo, responseHeaders } = opts;
try {
if (typeof callback !== "function") {
throw new InvalidArgumentError("invalid callback");
}
if (typeof factory !== "function") {
throw new InvalidArgumentError("invalid factory");
}
if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
}
if (method === "CONNECT") {
throw new InvalidArgumentError("invalid method");
}
if (onInfo && typeof onInfo !== "function") {
throw new InvalidArgumentError("invalid onInfo callback");
}
super("UNDICI_STREAM");
} catch (err) {
if (util.isStream(body)) {
util.destroy(body.on("error", util.nop), err);
}
throw err;
}
this.responseHeaders = responseHeaders || null;
this.opaque = opaque || null;
this.factory = factory;
this.callback = callback;
this.res = null;
this.abort = null;
this.context = null;
this.trailers = null;
this.body = body;
this.onInfo = onInfo || null;
if (util.isStream(body)) {
body.on("error", (err) => {
this.onError(err);
});
}
addSignal(this, signal);
}
onConnect(abort, context) {
if (!this.callback) {
throw new RequestAbortedError();
}
this.abort = abort;
this.context = context;
}
onHeaders(statusCode, rawHeaders, resume) {
const { factory, opaque, context } = this;
if (statusCode < 200) {
if (this.onInfo) {
const headers2 = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
this.onInfo({ statusCode, headers: headers2 });
}
return;
}
this.factory = null;
const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
const res = this.runInAsyncScope(factory, null, {
statusCode,
headers,
opaque,
context
});
if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") {
throw new InvalidReturnValueError("expected Writable");
}
res.on("drain", resume);
finished(res, { readable: false }, (err) => {
const { callback, res: res2, opaque: opaque2, trailers, abort } = this;
this.res = null;
if (err || !res2.readable) {
util.destroy(res2, err);
}
this.callback = null;
this.runInAsyncScope(callback, null, err || null, { opaque: opaque2, trailers });
if (err) {
abort();
}
});
this.res = res;
const needDrain = res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState && res._writableState.needDrain;
return needDrain !== true;
}
onData(chunk) {
const { res } = this;
return res.write(chunk);
}
onComplete(trailers) {
const { res } = this;
removeSignal(this);
this.trailers = util.parseHeaders(trailers);
res.end();
}
onError(err) {
const { res, callback, opaque, body } = this;
removeSignal(this);
this.factory = null;
if (res) {
this.res = null;
util.destroy(res, err);
} else if (callback) {
this.callback = null;
queueMicrotask(() => {
this.runInAsyncScope(callback, null, err, { opaque });
});
}
if (body) {
this.body = null;
util.destroy(body, err);
}
}
};
function stream(opts, factory, callback) {
if (callback === void 0) {
return new Promise((resolve, reject) => {
stream.call(this, opts, factory, (err, data) => {
return err ? reject(err) : resolve(data);
});
});
}
try {
this.dispatch(opts, new StreamHandler(opts, factory, callback));
} catch (err) {
if (typeof callback !== "function") {
throw err;
}
const opaque = opts && opts.opaque;
queueMicrotask(() => callback(err, { opaque }));
}
}
module2.exports = stream;
}
});
// lib/api/api-pipeline.js
var require_api_pipeline = __commonJS({
"lib/api/api-pipeline.js"(exports2, module2) {
"use strict";
var {
Readable,
Duplex,
PassThrough
} = require("stream");
var {
InvalidArgumentError,
InvalidReturnValueError,
RequestAbortedError
} = require_errors();
var util = require_util();
var { AsyncResource } = require("async_hooks");
var { addSignal, removeSignal } = require_abort_signal();
var assert = require("assert");
var kResume = Symbol("resume");
var PipelineRequest = class extends Readable {
constructor() {
super({ autoDestroy: true });
this[kResume] = null;
}
_read() {
const { [kResume]: resume } = this;
if (resume) {
this[kResume] = null;
resume();
}
}
_destroy(err, callback) {
this._read();
callback(err);
}
};
var PipelineResponse = class extends Readable {
constructor(resume) {
super({ autoDestroy: true });
this[kResume] = resume;
}
_read() {
this[kResume]();
}
_destroy(err, callback) {
if (!err && !this._readableState.endEmitted) {
err = new RequestAbortedError();
}
callback(err);
}
};
var PipelineHandler = class extends AsyncResource {
constructor(opts, handler) {
if (!opts || typeof opts !== "object") {
throw new InvalidArgumentError("invalid opts");
}
if (typeof handler !== "function") {
throw new InvalidArgumentError("invalid handler");
}
const { signal, method, opaque, onInfo, responseHeaders } = opts;
if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
}
if (method === "CONNECT") {
throw new InvalidArgumentError("invalid method");
}
if (onInfo && typeof onInfo !== "function") {
throw new InvalidArgumentError("invalid onInfo callback");
}
super("UNDICI_PIPELINE");
this.opaque = opaque || null;
this.responseHeaders = responseHeaders || null;
this.handler = handler;
this.abort = null;
this.context = null;
this.onInfo = onInfo || null;
this.req = new PipelineRequest().on("error", util.nop);
this.ret = new Duplex({
readableObjectMode: opts.objectMode,
autoDestroy: true,
read: () => {
const { body } = this;
if (body && body.resume) {
body.resume();
}
},
write: (chunk, encoding, callback) => {
const { req } = this;
if (req.push(chunk, encoding) || req._readableState.destroyed) {
callback();
} else {
req[kResume] = callback;
}
},
destroy: (err, callback) => {
const { body, req, res, ret, abort } = this;
if (!err && !ret._readableState.endEmitted) {
err = new RequestAbortedError();
}
if (abort && err) {
abort();
}
util.destroy(body, err);
util.destroy(req, err);
util.destroy(res, err);
removeSignal(this);
callback(err);
}
}).on("prefinish", () => {
const { req } = this;
req.push(null);
});
this.res = null;
addSignal(this, signal);
}
onConnect(abort, context) {
const { ret, res } = this;
assert(!res, "pipeline cannot be retried");
if (ret.destroyed) {
throw new RequestAbortedError();
}
this.abort = abort;
this.context = context;
}
onHeaders(statusCode, rawHeaders, resume) {
const { opaque, handler, context } = this;
if (statusCode < 200) {
if (this.onInfo) {
const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
this.onInfo({ statusCode, headers });
}
return;
}
this.res = new PipelineResponse(resume);
let body;
try {
this.handler = null;
const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
body = this.runInAsyncScope(handler, null, {
statusCode,
headers,
opaque,
body: this.res,
context
});
} catch (err) {
this.res.on("error", util.nop);
throw err;
}
if (!body || typeof body.on !== "function") {
throw new InvalidReturnValueError("expected Readable");
}
body.on("data", (chunk) => {
const { ret, body: body2 } = this;
if (!ret.push(chunk) && body2.pause) {
body2.pause();
}
}).on("error", (err) => {
const { ret } = this;
util.destroy(ret, err);
}).on("end", () => {
const { ret } = this;
ret.push(null);
}).on("close", () => {
const { ret } = this;
if (!ret._readableState.ended) {
util.destroy(ret, new RequestAbortedError());
}
});
this.body = body;
}
onData(chunk) {
const { res } = this;
return res.push(chunk);
}
onComplete(trailers) {
const { res } = this;
res.push(null);
}
onError(err) {
const { ret } = this;
this.handler = null;
util.destroy(ret, err);
}
};
function pipeline(opts, handler) {
try {
const pipelineHandler = new PipelineHandler(opts, handler);
this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler);
return pipelineHandler.ret;
} catch (err) {
return new PassThrough().destroy(err);
}
}
module2.exports = pipeline;
}
});
// lib/api/api-upgrade.js
var require_api_upgrade = __commonJS({
"lib/api/api-upgrade.js"(exports2, module2) {
"use strict";
var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors();
var { AsyncResource } = require("async_hooks");
var util = require_util();
var { addSignal, removeSignal } = require_abort_signal();
var assert = require("assert");
var UpgradeHandler = class extends AsyncResource {
constructor(opts, callback) {
if (!opts || typeof opts !== "object") {
throw new InvalidArgumentError("invalid opts");
}
if (typeof callback !== "function") {
throw new InvalidArgumentError("invalid callback");
}
const { signal, opaque, responseHeaders } = opts;
if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
}
super("UNDICI_UPGRADE");
this.responseHeaders = responseHeaders || null;
this.opaque = opaque || null;
this.callback = callback;
this.abort = null;
this.context = null;
addSignal(this, signal);
}
onConnect(abort, context) {
if (!this.callback) {
throw new RequestAbortedError();
}
this.abort = abort;
this.context = null;
}
onHeaders() {
throw new SocketError("bad upgrade", null);
}
onUpgrade(statusCode, rawHeaders, socket) {
const { callback, opaque, context } = this;
assert.strictEqual(statusCode, 101);
removeSignal(this);
this.callback = null;
const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
this.runInAsyncScope(callback, null, null, {
headers,
socket,
opaque,
context
});
}
onError(err) {
const { callback, opaque } = this;
removeSignal(this);
if (callback) {
this.callback = null;
queueMicrotask(() => {
this.runInAsyncScope(callback, null, err, { opaque });
});
}
}
};
function upgrade(opts, callback) {
if (callback === void 0) {
return new Promise((resolve, reject) => {
upgrade.call(this, opts, (err, data) => {
return err ? reject(err) : resolve(data);
});
});
}
try {
const upgradeHandler = new UpgradeHandler(opts, callback);
this.dispatch({
...opts,
method: opts.method || "GET",
upgrade: opts.protocol || "Websocket"
}, upgradeHandler);
} catch (err) {
if (typeof callback !== "function") {
throw err;
}
const opaque = opts && opts.opaque;
queueMicrotask(() => callback(err, { opaque }));
}
}
module2.exports = upgrade;
}
});
// lib/api/api-connect.js
var require_api_connect = __commonJS({
"lib/api/api-connect.js"(exports2, module2) {
"use strict";
var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors();
var { AsyncResource } = require("async_hooks");
var util = require_util();
var { addSignal, removeSignal } = require_abort_signal();
var ConnectHandler = class extends AsyncResource {
constructor(opts, callback) {
if (!opts || typeof opts !== "object") {
throw new InvalidArgumentError("invalid opts");
}
if (typeof callback !== "function") {
throw new InvalidArgumentError("invalid callback");
}
const { signal, opaque, responseHeaders } = opts;
if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
}
super("UNDICI_CONNECT");
this.opaque = opaque || null;
this.responseHeaders = responseHeaders || null;
this.callback = callback;
this.abort = null;
addSignal(this, signal);
}
onConnect(abort, context) {
if (!this.callback) {
throw new RequestAbortedError();
}
this.abort = abort;
this.context = context;
}
onHeaders() {
throw new SocketError("bad connect", null);
}
onUpgrade(statusCode, rawHeaders, socket) {
const { callback, opaque, context } = this;
removeSignal(this);
this.callback = null;
const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
this.runInAsyncScope(callback, null, null, {
statusCode,
headers,
socket,
opaque,
context
});
}
onError(err) {
const { callback, opaque } = this;
removeSignal(this);
if (callback) {
this.callback = null;
queueMicrotask(() => {
this.runInAsyncScope(callback, null, err, { opaque });
});
}
}
};
function connect(opts, callback) {
if (callback === void 0) {
return new Promise((resolve, reject) => {
connect.call(this, opts, (err, data) => {
return err ? reject(err) : resolve(data);
});
});
}
try {
const connectHandler = new ConnectHandler(opts, callback);
this.dispatch({ ...opts, method: "CONNECT" }, connectHandler);
} catch (err) {
if (typeof callback !== "function") {
throw err;
}
const opaque = opts && opts.opaque;
queueMicrotask(() => callback(err, { opaque }));
}
}
module2.exports = connect;
}
});
// lib/api/index.js
var require_api = __commonJS({
"lib/api/index.js"(exports2, module2) {
"use strict";
module2.exports.request = require_api_request();
module2.exports.stream = require_api_stream();
module2.exports.pipeline = require_api_pipeline();
module2.exports.upgrade = require_api_upgrade();
module2.exports.connect = require_api_connect();
}
});
// lib/mock/mock-errors.js
var require_mock_errors = __commonJS({
"lib/mock/mock-errors.js"(exports2, module2) {
"use strict";
var { UndiciError } = require_errors();
var MockNotMatchedError = class extends UndiciError {
constructor(message) {
super(message);
Error.captureStackTrace(this, MockNotMatchedError);
this.name = "MockNotMatchedError";
this.message = message || "The request does not match any registered mock dispatches";
this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED";
}
};
module2.exports = {
MockNotMatchedError
};
}
});
// lib/mock/mock-symbols.js
var require_mock_symbols = __commonJS({
"lib/mock/mock-symbols.js"(exports2, module2) {
"use strict";
module2.exports = {
kAgent: Symbol("agent"),
kOptions: Symbol("options"),
kFactory: Symbol("factory"),
kDispatches: Symbol("dispatches"),
kDispatchKey: Symbol("dispatch key"),
kDefaultHeaders: Symbol("default headers"),
kDefaultTrailers: Symbol("default trailers"),
kContentLength: Symbol("content length"),
kMockAgent: Symbol("mock agent"),
kMockAgentSet: Symbol("mock agent set"),
kMockAgentGet: Symbol("mock agent get"),
kMockDispatch: Symbol("mock dispatch"),
kClose: Symbol("close"),
kOriginalClose: Symbol("original agent close"),
kOrigin: Symbol("origin"),
kIsMockActive: Symbol("is mock active"),
kNetConnect: Symbol("net connect"),
kGetNetConnect: Symbol("get net connect"),
kConnected: Symbol("connected")
};
}
});
// lib/mock/mock-utils.js
var require_mock_utils = __commonJS({
"lib/mock/mock-utils.js"(exports2, module2) {
"use strict";
var { MockNotMatchedError } = require_mock_errors();
var {
kDispatches,
kMockAgent,
kOriginalDispatch,
kOrigin,
kGetNetConnect
} = require_mock_symbols();
var { buildURL, nop } = require_util();
var { STATUS_CODES } = require("http");
var {
types: {
isPromise
}
} = require("util");
function matchValue(match, value) {
if (typeof match === "string") {
return match === value;
}
if (match instanceof RegExp) {
return match.test(value);
}
if (typeof match === "function") {
return match(value) === true;
}
return false;
}
function lowerCaseEntries(headers) {
return Object.fromEntries(
Object.entries(headers).map(([headerName, headerValue]) => {
return [headerName.toLocaleLowerCase(), headerValue];
})
);
}
function getHeaderByName(headers, key) {
if (Array.isArray(headers)) {
for (let i = 0; i < headers.length; i += 2) {
if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) {
return headers[i + 1];
}
}
return void 0;
} else if (typeof headers.get === "function") {
return headers.get(key);
} else {
return lowerCaseEntries(headers)[key.toLocaleLowerCase()];
}
}
function buildHeadersFromArray(headers) {
const clone = headers.slice();
const entries = [];
for (let index = 0; index < clone.length; index += 2) {
entries.push([clone[index], clone[index + 1]]);
}
return Object.fromEntries(entries);
}
function matchHeaders(mockDispatch2, headers) {
if (typeof mockDispatch2.headers === "function") {
if (Array.isArray(headers)) {
headers = buildHeadersFromArray(headers);
}
return mockDispatch2.headers(headers ? lowerCaseEntries(headers) : {});
}
if (typeof mockDispatch2.headers === "undefined") {
return true;
}
if (typeof headers !== "object" || typeof mockDispatch2.headers !== "object") {
return false;
}
for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch2.headers)) {
const headerValue = getHeaderByName(headers, matchHeaderName);
if (!matchValue(matchHeaderValue, headerValue)) {
return false;
}
}
return true;
}
function safeUrl(path) {
if (typeof path !== "string") {
return path;
}
const pathSegments = path.split("?");
if (pathSegments.length !== 2) {
return path;
}
const qp = new URLSearchParams(pathSegments.pop());
qp.sort();
return [...pathSegments, qp.toString()].join("?");
}
function matchKey(mockDispatch2, { path, method, body, headers }) {
const pathMatch = matchValue(mockDispatch2.path, path);
const methodMatch = matchValue(mockDispatch2.method, method);
const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
const headersMatch = matchHeaders(mockDispatch2, headers);
return pathMatch && methodMatch && bodyMatch && headersMatch;
}
function getResponseData(data) {
if (Buffer.isBuffer(data)) {
return data;
} else if (typeof data === "object") {
return JSON.stringify(data);
} else {
return data.toString();
}
}
function getMockDispatch(mockDispatches, key) {
const basePath = key.query ? buildURL(key.path, key.query) : key.path;
const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path }) => matchValue(safeUrl(path), resolvedPath));
if (matchedMockDispatches.length === 0) {
throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
}
matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method));
if (matchedMockDispatches.length === 0) {
throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}'`);
}
matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true);
if (matchedMockDispatches.length === 0) {
throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}'`);
}
matchedMockDispatches = matchedMockDispatches.filter((mockDispatch2) => matchHeaders(mockDispatch2, key.headers));
if (matchedMockDispatches.length === 0) {
throw new MockNotMatchedError(`Mock dispatch not matched for headers '${typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers}'`);
}
return matchedMockDispatches[0];
}
function addMockDispatch(mockDispatches, key, data) {
const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false };
const replyData = typeof data === "function" ? { callback: data } : { ...data };
const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } };
mockDispatches.push(newMockDispatch);
return newMockDispatch;
}
function deleteMockDispatch(mockDispatches, key) {
const index = mockDispatches.findIndex((dispatch) => {
if (!dispatch.consumed) {
return false;
}
return matchKey(dispatch, key);
});
if (index !== -1) {
mockDispatches.splice(index, 1);
}
}
function buildKey(opts) {
const { path, method, body, headers, query } = opts;
return {
path,
method,
body,
headers,
query
};
}
function generateKeyValues(data) {
return Object.entries(data).reduce((keyValuePairs, [key, value]) => [...keyValuePairs, key, value], []);
}
function getStatusText(statusCode) {
return STATUS_CODES[statusCode] || "unknown";
}
async function getResponse(body) {
const buffers = [];
for await (const data of body) {
buffers.push(data);
}
return Buffer.concat(buffers).toString("utf8");
}
function mockDispatch(opts, handler) {
const key = buildKey(opts);
const mockDispatch2 = getMockDispatch(this[kDispatches], key);
mockDispatch2.timesInvoked++;
if (mockDispatch2.data.callback) {
mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) };
}
const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch2;
const { timesInvoked, times } = mockDispatch2;
mockDispatch2.consumed = !persist && timesInvoked >= times;
mockDispatch2.pending = timesInvoked < times;
if (error !== null) {
deleteMockDispatch(this[kDispatches], key);
handler.onError(error);
return true;
}
if (typeof delay === "number" && delay > 0) {
setTimeout(() => {
handleReply(this[kDispatches]);
}, delay);
} else {
handleReply(this[kDispatches]);
}
function handleReply(mockDispatches, _data = data) {
const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers;
const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data;
if (isPromise(body)) {
body.then((newData) => handleReply(mockDispatches, newData));
return;
}
const responseData = getResponseData(body);
const responseHeaders = generateKeyValues(headers);
const responseTrailers = generateKeyValues(trailers);
handler.abort = nop;
handler.onHeaders(statusCode, responseHeaders, resume, getStatusText(statusCode));
handler.onData(Buffer.from(responseData));
handler.onComplete(responseTrailers);
deleteMockDispatch(mockDispatches, key);
}
function resume() {
}
return true;
}
function buildMockDispatch() {
const agent = this[kMockAgent];
const origin = this[kOrigin];
const originalDispatch = this[kOriginalDispatch];
return function dispatch(opts, handler) {
if (agent.isMockActive) {
try {
mockDispatch.call(this, opts, handler);
} catch (error) {
if (error instanceof MockNotMatchedError) {
const netConnect = agent[kGetNetConnect]();
if (netConnect === false) {
throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`);
}
if (checkNetConnect(netConnect, origin)) {
originalDispatch.call(this, opts, handler);
} else {
throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`);
}
} else {
throw error;
}
}
} else {
originalDispatch.call(this, opts, handler);
}
};
}
function checkNetConnect(netConnect, origin) {
const url = new URL(origin);
if (netConnect === true) {
return true;
} else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) {
return true;
}
return false;
}
function buildMockOptions(opts) {
if (opts) {
const { agent, ...mockOptions } = opts;
return mockOptions;
}
}
module2.exports = {
getResponseData,
getMockDispatch,
addMockDispatch,
deleteMockDispatch,
buildKey,
generateKeyValues,
matchValue,
getResponse,
getStatusText,
mockDispatch,
buildMockDispatch,
checkNetConnect,
buildMockOptions,
getHeaderByName
};
}
});
// lib/mock/mock-interceptor.js
var require_mock_interceptor = __commonJS({
"lib/mock/mock-interceptor.js"(exports2, module2) {
"use strict";
var { getResponseData, buildKey, addMockDispatch } = require_mock_utils();
var {
kDispatches,
kDispatchKey,
kDefaultHeaders,
kDefaultTrailers,
kContentLength,
kMockDispatch
} = require_mock_symbols();
var { InvalidArgumentError } = require_errors();
var { buildURL } = require_util();
var MockScope = class {
constructor(mockDispatch) {
this[kMockDispatch] = mockDispatch;
}
/**
* Delay a reply by a set amount in ms.
*/
delay(waitInMs) {
if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) {
throw new InvalidArgumentError("waitInMs must be a valid integer > 0");
}
this[kMockDispatch].delay = waitInMs;
return this;
}
/**
* For a defined reply, never mark as consumed.
*/
persist() {
this[kMockDispatch].persist = true;
return this;
}
/**
* Allow one to define a reply for a set amount of matching requests.
*/
times(repeatTimes) {
if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) {
throw new InvalidArgumentError("repeatTimes must be a valid integer > 0");
}
this[kMockDispatch].times = repeatTimes;
return this;
}
};
var MockInterceptor = class {
constructor(opts, mockDispatches) {
if (typeof opts !== "object") {
throw new InvalidArgumentError("opts must be an object");
}
if (typeof opts.path === "undefined") {
throw new InvalidArgumentError("opts.path must be defined");
}
if (typeof opts.method === "undefined") {
opts.method = "GET";
}
if (typeof opts.path === "string") {
if (opts.query) {
opts.path = buildURL(opts.path, opts.query);
} else {
const parsedURL = new URL(opts.path, "data://");
opts.path = parsedURL.pathname + parsedURL.search;
}
}
if (typeof opts.method === "string") {
opts.method = opts.method.toUpperCase();
}
this[kDispatchKey] = buildKey(opts);
this[kDispatches] = mockDispatches;
this[kDefaultHeaders] = {};
this[kDefaultTrailers] = {};
this[kContentLength] = false;
}
createMockScopeDispatchData(statusCode, data, responseOptions = {}) {
const responseData = getResponseData(data);
const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {};
const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers };
const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers };
return { statusCode, data, headers, trailers };
}
validateReplyParameters(statusCode, data, responseOptions) {
if (typeof statusCode === "undefined") {
throw new InvalidArgumentError("statusCode must be defined");
}
if (typeof data === "undefined") {
throw new InvalidArgumentError("data must be defined");
}
if (typeof responseOptions !== "object") {
throw new InvalidArgumentError("responseOptions must be an object");
}
}
/**
* Mock an undici request with a defined reply.
*/
reply(replyData) {
if (typeof replyData === "function") {
const wrappedDefaultsCallback = (opts) => {
const resolvedData = replyData(opts);
if (typeof resolvedData !== "object") {
throw new InvalidArgumentError("reply options callback must return an object");
}
const { statusCode: statusCode2, data: data2 = "", responseOptions: responseOptions2 = {} } = resolvedData;
this.validateReplyParameters(statusCode2, data2, responseOptions2);
return {
...this.createMockScopeDispatchData(statusCode2, data2, responseOptions2)
};
};
const newMockDispatch2 = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback);
return new MockScope(newMockDispatch2);
}
const [statusCode, data = "", responseOptions = {}] = [...arguments];
this.validateReplyParameters(statusCode, data, responseOptions);
const dispatchData = this.createMockScopeDispatchData(statusCode, data, responseOptions);
const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData);
return new MockScope(newMockDispatch);
}
/**
* Mock an undici request with a defined error.
*/
replyWithError(error) {
if (typeof error === "undefined") {
throw new InvalidArgumentError("error must be defined");
}
const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error });
return new MockScope(newMockDispatch);
}
/**
* Set default reply headers on the interceptor for subsequent replies
*/
defaultReplyHeaders(headers) {
if (typeof headers === "undefined") {
throw new InvalidArgumentError("headers must be defined");
}
this[kDefaultHeaders] = headers;
return this;
}
/**
* Set default reply trailers on the interceptor for subsequent replies
*/
defaultReplyTrailers(trailers) {
if (typeof trailers === "undefined") {
throw new InvalidArgumentError("trailers must be defined");
}
this[kDefaultTrailers] = trailers;
return this;
}
/**
* Set reply content length header for replies on the interceptor
*/
replyContentLength() {
this[kContentLength] = true;
return this;
}
};
module2.exports.MockInterceptor = MockInterceptor;
module2.exports.MockScope = MockScope;
}
});
// lib/mock/mock-client.js
var require_mock_client = __commonJS({
"lib/mock/mock-client.js"(exports2, module2) {
"use strict";
var { promisify } = require("util");
var Client = require_client();
var { buildMockDispatch } = require_mock_utils();
var {
kDispatches,
kMockAgent,
kClose,
kOriginalClose,
kOrigin,
kOriginalDispatch,
kConnected
} = require_mock_symbols();
var { MockInterceptor } = require_mock_interceptor();
var Symbols = require_symbols();
var { InvalidArgumentError } = require_errors();
var MockClient = class extends Client {
constructor(origin, opts) {
super(origin, opts);
if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
throw new InvalidArgumentError("Argument opts.agent must implement Agent");
}
this[kMockAgent] = opts.agent;
this[kOrigin] = origin;
this[kDispatches] = [];
this[kConnected] = 1;
this[kOriginalDispatch] = this.dispatch;
this[kOriginalClose] = this.close.bind(this);
this.dispatch = buildMockDispatch.call(this);
this.close = this[kClose];
}
get [Symbols.kConnected]() {
return this[kConnected];
}
/**
* Sets up the base interceptor for mocking replies from undici.
*/
intercept(opts) {
return new MockInterceptor(opts, this[kDispatches]);
}
async [kClose]() {
await promisify(this[kOriginalClose])();
this[kConnected] = 0;
this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
}
};
module2.exports = MockClient;
}
});
// lib/mock/mock-pool.js
var require_mock_pool = __commonJS({
"lib/mock/mock-pool.js"(exports2, module2) {
"use strict";
var { promisify } = require("util");
var Pool = require_pool();
var { buildMockDispatch } = require_mock_utils();
var {
kDispatches,
kMockAgent,
kClose,
kOriginalClose,
kOrigin,
kOriginalDispatch,
kConnected
} = require_mock_symbols();
var { MockInterceptor } = require_mock_interceptor();
var Symbols = require_symbols();
var { InvalidArgumentError } = require_errors();
var MockPool = class extends Pool {
constructor(origin, opts) {
super(origin, opts);
if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
throw new InvalidArgumentError("Argument opts.agent must implement Agent");
}
this[kMockAgent] = opts.agent;
this[kOrigin] = origin;
this[kDispatches] = [];
this[kConnected] = 1;
this[kOriginalDispatch] = this.dispatch;
this[kOriginalClose] = this.close.bind(this);
this.dispatch = buildMockDispatch.call(this);
this.close = this[kClose];
}
get [Symbols.kConnected]() {
return this[kConnected];
}
/**
* Sets up the base interceptor for mocking replies from undici.
*/
intercept(opts) {
return new MockInterceptor(opts, this[kDispatches]);
}
async [kClose]() {
await promisify(this[kOriginalClose])();
this[kConnected] = 0;
this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
}
};
module2.exports = MockPool;
}
});
// lib/mock/pluralizer.js
var require_pluralizer = __commonJS({
"lib/mock/pluralizer.js"(exports2, module2) {
"use strict";
var singulars = {
pronoun: "it",
is: "is",
was: "was",
this: "this"
};
var plurals = {
pronoun: "they",
is: "are",
was: "were",
this: "these"
};
module2.exports = class Pluralizer {
constructor(singular, plural) {
this.singular = singular;
this.plural = plural;
}
pluralize(count) {
const one = count === 1;
const keys = one ? singulars : plurals;
const noun = one ? this.singular : this.plural;
return { ...keys, count, noun };
}
};
}
});
// lib/mock/pending-interceptors-formatter.js
var require_pending_interceptors_formatter = __commonJS({
"lib/mock/pending-interceptors-formatter.js"(exports2, module2) {
"use strict";
var { Transform } = require("stream");
var { Console } = require("console");
module2.exports = class PendingInterceptorsFormatter {
constructor({ disableColors } = {}) {
this.transform = new Transform({
transform(chunk, _enc, cb) {
cb(null, chunk);
}
});
this.logger = new Console({
stdout: this.transform,
inspectOptions: {
colors: !disableColors && !process.env.CI
}
});
}
format(pendingInterceptors) {
const withPrettyHeaders = pendingInterceptors.map(
({ method, path, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
Method: method,
Origin: origin,
Path: path,
"Status code": statusCode,
Persistent: persist ? "\u2705" : "\u274C",
Invocations: timesInvoked,
Remaining: persist ? Infinity : times - timesInvoked
})
);
this.logger.table(withPrettyHeaders);
return this.transform.read().toString();
}
};
}
});
// lib/mock/mock-agent.js
var require_mock_agent = __commonJS({
"lib/mock/mock-agent.js"(exports2, module2) {
"use strict";
var { kClients } = require_symbols();
var Agent = require_agent();
var {
kAgent,
kMockAgentSet,
kMockAgentGet,
kDispatches,
kIsMockActive,
kNetConnect,
kGetNetConnect,
kOptions,
kFactory
} = require_mock_symbols();
var MockClient = require_mock_client();
var MockPool = require_mock_pool();
var { matchValue, buildMockOptions } = require_mock_utils();
var { InvalidArgumentError, UndiciError } = require_errors();
var Dispatcher = require_dispatcher();
var Pluralizer = require_pluralizer();
var PendingInterceptorsFormatter = require_pending_interceptors_formatter();
var FakeWeakRef = class {
constructor(value) {
this.value = value;
}
deref() {
return this.value;
}
};
var MockAgent = class extends Dispatcher {
constructor(opts) {
super(opts);
this[kNetConnect] = true;
this[kIsMockActive] = true;
if (opts && opts.agent && typeof opts.agent.dispatch !== "function") {
throw new InvalidArgumentError("Argument opts.agent must implement Agent");
}
const agent = opts && opts.agent ? opts.agent : new Agent(opts);
this[kAgent] = agent;
this[kClients] = agent[kClients];
this[kOptions] = buildMockOptions(opts);
}
get(origin) {
let dispatcher = this[kMockAgentGet](origin);
if (!dispatcher) {
dispatcher = this[kFactory](origin);
this[kMockAgentSet](origin, dispatcher);
}
return dispatcher;
}
dispatch(opts, handler) {
this.get(opts.origin);
return this[kAgent].dispatch(opts, handler);
}
async close() {
await this[kAgent].close();
this[kClients].clear();
}
deactivate() {
this[kIsMockActive] = false;
}
activate() {
this[kIsMockActive] = true;
}
enableNetConnect(matcher) {
if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) {
if (Array.isArray(this[kNetConnect])) {
this[kNetConnect].push(matcher);
} else {
this[kNetConnect] = [matcher];
}
} else if (typeof matcher === "undefined") {
this[kNetConnect] = true;
} else {
throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp.");
}
}
disableNetConnect() {
this[kNetConnect] = false;
}
// This is required to bypass issues caused by using global symbols - see:
// https://github.com/nodejs/undici/issues/1447
get isMockActive() {
return this[kIsMockActive];
}
[kMockAgentSet](origin, dispatcher) {
this[kClients].set(origin, new FakeWeakRef(dispatcher));
}
[kFactory](origin) {
const mockOptions = Object.assign({ agent: this }, this[kOptions]);
return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions);
}
[kMockAgentGet](origin) {
const ref = this[kClients].get(origin);
if (ref) {
return ref.deref();
}
if (typeof origin !== "string") {
const dispatcher = this[kFactory]("http://localhost:9999");
this[kMockAgentSet](origin, dispatcher);
return dispatcher;
}
for (const [keyMatcher, nonExplicitRef] of Array.from(this[kClients])) {
const nonExplicitDispatcher = nonExplicitRef.deref();
if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) {
const dispatcher = this[kFactory](origin);
this[kMockAgentSet](origin, dispatcher);
dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches];
return dispatcher;
}
}
}
[kGetNetConnect]() {
return this[kNetConnect];
}
pendingInterceptors() {
const mockAgentClients = this[kClients];
return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope.deref()[kDispatches].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending);
}
assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) {
const pending = this.pendingInterceptors();
if (pending.length === 0) {
return;
}
const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length);
throw new UndiciError(`
${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending:
${pendingInterceptorsFormatter.format(pending)}
`.trim());
}
};
module2.exports = MockAgent;
}
});
// lib/proxy-agent.js
var require_proxy_agent = __commonJS({
"lib/proxy-agent.js"(exports2, module2) {
"use strict";
var { kProxy, kClose, kDestroy, kInterceptors } = require_symbols();
var { URL: URL2 } = require("url");
var Agent = require_agent();
var Client = require_client();
var DispatcherBase = require_dispatcher_base();
var { InvalidArgumentError, RequestAbortedError } = require_errors();
var buildConnector = require_connect();
var kAgent = Symbol("proxy agent");
var kClient = Symbol("proxy client");
var kProxyHeaders = Symbol("proxy headers");
var kRequestTls = Symbol("request tls settings");
var kProxyTls = Symbol("proxy tls settings");
var kConnectEndpoint = Symbol("connect endpoint function");
function defaultProtocolPort(protocol) {
return protocol === "https:" ? 443 : 80;
}
function buildProxyOptions(opts) {
if (typeof opts === "string") {
opts = { uri: opts };
}
if (!opts || !opts.uri) {
throw new InvalidArgumentError("Proxy opts.uri is mandatory");
}
return {
uri: opts.uri,
protocol: opts.protocol || "https"
};
}
var ProxyAgent = class extends DispatcherBase {
constructor(opts) {
super(opts);
this[kProxy] = buildProxyOptions(opts);
this[kAgent] = new Agent(opts);
this[kInterceptors] = opts.interceptors && opts.interceptors.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : [];
if (typeof opts === "string") {
opts = { uri: opts };
}
if (!opts || !opts.uri) {
throw new InvalidArgumentError("Proxy opts.uri is mandatory");
}
this[kRequestTls] = opts.requestTls;
this[kProxyTls] = opts.proxyTls;
this[kProxyHeaders] = {};
if (opts.auth && opts.token) {
throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token");
} else if (opts.auth) {
this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`;
} else if (opts.token) {
this[kProxyHeaders]["proxy-authorization"] = opts.token;
}
const resolvedUrl = new URL2(opts.uri);
const { origin, port, host } = resolvedUrl;
const connect = buildConnector({ ...opts.proxyTls });
this[kConnectEndpoint] = buildConnector({ ...opts.requestTls });
this[kClient] = new Client(resolvedUrl, { connect });
this[kAgent] = new Agent({
...opts,
connect: async (opts2, callback) => {
let requestedHost = opts2.host;
if (!opts2.port) {
requestedHost += `:${defaultProtocolPort(opts2.protocol)}`;
}
try {
const { socket, statusCode } = await this[kClient].connect({
origin,
port,
path: requestedHost,
signal: opts2.signal,
headers: {
...this[kProxyHeaders],
host
}
});
if (statusCode !== 200) {
socket.on("error", () => {
}).destroy();
callback(new RequestAbortedError("Proxy response !== 200 when HTTP Tunneling"));
}
if (opts2.protocol !== "https:") {
callback(null, socket);
return;
}
let servername;
if (this[kRequestTls]) {
servername = this[kRequestTls].servername;
} else {
servername = opts2.servername;
}
this[kConnectEndpoint]({ ...opts2, servername, httpSocket: socket }, callback);
} catch (err) {
callback(err);
}
}
});
}
dispatch(opts, handler) {
const { host } = new URL2(opts.origin);
const headers = buildHeaders(opts.headers);
throwIfProxyAuthIsSent(headers);
return this[kAgent].dispatch(
{
...opts,
headers: {
...headers,
host
}
},
handler
);
}
async [kClose]() {
await this[kAgent].close();
await this[kClient].close();
}
async [kDestroy]() {
await this[kAgent].destroy();
await this[kClient].destroy();
}
};
function buildHeaders(headers) {
if (Array.isArray(headers)) {
const headersPair = {};
for (let i = 0; i < headers.length; i += 2) {
headersPair[headers[i]] = headers[i + 1];
}
return headersPair;
}
return headers;
}
function throwIfProxyAuthIsSent(headers) {
const existProxyAuth = headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization");
if (existProxyAuth) {
throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor");
}
}
module2.exports = ProxyAgent;
}
});
// 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
});
}
function getGlobalDispatcher() {
return globalThis[globalDispatcher];
}
module2.exports = {
setGlobalDispatcher,
getGlobalDispatcher
};
}
});
// lib/handler/DecoratorHandler.js
var require_DecoratorHandler = __commonJS({
"lib/handler/DecoratorHandler.js"(exports2, module2) {
"use strict";
module2.exports = class DecoratorHandler {
constructor(handler) {
this.handler = handler;
}
onConnect(...args) {
return this.handler.onConnect(...args);
}
onError(...args) {
return this.handler.onError(...args);
}
onUpgrade(...args) {
return this.handler.onUpgrade(...args);
}
onHeaders(...args) {
return this.handler.onHeaders(...args);
}
onData(...args) {
return this.handler.onData(...args);
}
onComplete(...args) {
return this.handler.onComplete(...args);
}
onBodySent(...args) {
return this.handler.onBodySent(...args);
}
};
}
});
// lib/fileapi/symbols.js
var require_symbols3 = __commonJS({
"lib/fileapi/symbols.js"(exports2, module2) {
"use strict";
module2.exports = {
kState: Symbol("FileReader state"),
kResult: Symbol("FileReader result"),
kError: Symbol("FileReader error"),
kLastProgressEventFired: Symbol("FileReader last progress event fired timestamp"),
kEvents: Symbol("FileReader events"),
kAborted: Symbol("FileReader aborted")
};
}
});
// lib/fileapi/progressevent.js
var require_progressevent = __commonJS({
"lib/fileapi/progressevent.js"(exports2, module2) {
"use strict";
var { webidl } = require_webidl();
var kState = Symbol("ProgressEvent state");
var ProgressEvent = class extends Event {
constructor(type, eventInitDict = {}) {
type = webidl.converters.DOMString(type);
eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {});
super(type, eventInitDict);
this[kState] = {
lengthComputable: eventInitDict.lengthComputable,
loaded: eventInitDict.loaded,
total: eventInitDict.total
};
}
get lengthComputable() {
webidl.brandCheck(this, ProgressEvent);
return this[kState].lengthComputable;
}
get loaded() {
webidl.brandCheck(this, ProgressEvent);
return this[kState].loaded;
}
get total() {
webidl.brandCheck(this, ProgressEvent);
return this[kState].total;
}
};
webidl.converters.ProgressEventInit = webidl.dictionaryConverter([
{
key: "lengthComputable",
converter: webidl.converters.boolean,
defaultValue: false
},
{
key: "loaded",
converter: webidl.converters["unsigned long long"],
defaultValue: 0
},
{
key: "total",
converter: webidl.converters["unsigned long long"],
defaultValue: 0
},
{
key: "bubbles",
converter: webidl.converters.boolean,
defaultValue: false
},
{
key: "cancelable",
converter: webidl.converters.boolean,
defaultValue: false
},
{
key: "composed",
converter: webidl.converters.boolean,
defaultValue: false
}
]);
module2.exports = {
ProgressEvent
};
}
});
// lib/fileapi/encoding.js
var require_encoding = __commonJS({
"lib/fileapi/encoding.js"(exports2, module2) {
"use strict";
function getEncoding(label) {
switch (label.trim().toLowerCase()) {
case "unicode-1-1-utf-8":
case "unicode11utf8":
case "unicode20utf8":
case "utf-8":
case "utf8":
case "x-unicode20utf8":
return "UTF-8";
case "866":
case "cp866":
case "csibm866":
case "ibm866":
return "IBM866";
case "csisolatin2":
case "iso-8859-2":
case "iso-ir-101":
case "iso8859-2":
case "iso88592":
case "iso_8859-2":
case "iso_8859-2:1987":
case "l2":
case "latin2":
return "ISO-8859-2";
case "csisolatin3":
case "iso-8859-3":
case "iso-ir-109":
case "iso8859-3":
case "iso88593":
case "iso_8859-3":
case "iso_8859-3:1988":
case "l3":
case "latin3":
return "ISO-8859-3";
case "csisolatin4":
case "iso-8859-4":
case "iso-ir-110":
case "iso8859-4":
case "iso88594":
case "iso_8859-4":
case "iso_8859-4:1988":
case "l4":
case "latin4":
return "ISO-8859-4";
case "csisolatincyrillic":
case "cyrillic":
case "iso-8859-5":
case "iso-ir-144":
case "iso8859-5":
case "iso88595":
case "iso_8859-5":
case "iso_8859-5:1988":
return "ISO-8859-5";
case "arabic":
case "asmo-708":
case "csiso88596e":
case "csiso88596i":
case "csisolatinarabic":
case "ecma-114":
case "iso-8859-6":
case "iso-8859-6-e":
case "iso-8859-6-i":
case "iso-ir-127":
case "iso8859-6":
case "iso88596":
case "iso_8859-6":
case "iso_8859-6:1987":
return "ISO-8859-6";
case "csisolatingreek":
case "ecma-118":
case "elot_928":
case "greek":
case "greek8":
case "iso-8859-7":
case "iso-ir-126":
case "iso8859-7":
case "iso88597":
case "iso_8859-7":
case "iso_8859-7:1987":
case "sun_eu_greek":
return "ISO-8859-7";
case "csiso88598e":
case "csisolatinhebrew":
case "hebrew":
case "iso-8859-8":
case "iso-8859-8-e":
case "iso-ir-138":
case "iso8859-8":
case "iso88598":
case "iso_8859-8":
case "iso_8859-8:1988":
case "visual":
return "ISO-8859-8";
case "csiso88598i":
case "iso-8859-8-i":
case "logical":
return "ISO-8859-8-I";
case "csisolatin6":
case "iso-8859-10":
case "iso-ir-157":
case "iso8859-10":
case "iso885910":
case "l6":
case "latin6":
return "ISO-8859-10";
case "iso-8859-13":
case "iso8859-13":
case "iso885913":
return "ISO-8859-13";
case "iso-8859-14":
case "iso8859-14":
case "iso885914":
return "ISO-8859-14";
case "csisolatin9":
case "iso-8859-15":
case "iso8859-15":
case "iso885915":
case "iso_8859-15":
case "l9":
return "ISO-8859-15";
case "iso-8859-16":
return "ISO-8859-16";
case "cskoi8r":
case "koi":
case "koi8":
case "koi8-r":
case "koi8_r":
return "KOI8-R";
case "koi8-ru":
case "koi8-u":
return "KOI8-U";
case "csmacintosh":
case "mac":
case "macintosh":
case "x-mac-roman":
return "macintosh";
case "iso-8859-11":
case "iso8859-11":
case "iso885911":
case "tis-620":
case "windows-874":
return "windows-874";
case "cp1250":
case "windows-1250":
case "x-cp1250":
return "windows-1250";
case "cp1251":
case "windows-1251":
case "x-cp1251":
return "windows-1251";
case "ansi_x3.4-1968":
case "ascii":
case "cp1252":
case "cp819":
case "csisolatin1":
case "ibm819":
case "iso-8859-1":
case "iso-ir-100":
case "iso8859-1":
case "iso88591":
case "iso_8859-1":
case "iso_8859-1:1987":
case "l1":
case "latin1":
case "us-ascii":
case "windows-1252":
case "x-cp1252":
return "windows-1252";
case "cp1253":
case "windows-1253":
case "x-cp1253":
return "windows-1253";
case "cp1254":
case "csisolatin5":
case "iso-8859-9":
case "iso-ir-148":
case "iso8859-9":
case "iso88599":
case "iso_8859-9":
case "iso_8859-9:1989":
case "l5":
case "latin5":
case "windows-1254":
case "x-cp1254":
return "windows-1254";
case "cp1255":
case "windows-1255":
case "x-cp1255":
return "windows-1255";
case "cp1256":
case "windows-1256":
case "x-cp1256":
return "windows-1256";
case "cp1257":
case "windows-1257":
case "x-cp1257":
return "windows-1257";
case "cp1258":
case "windows-1258":
case "x-cp1258":
return "windows-1258";
case "x-mac-cyrillic":
case "x-mac-ukrainian":
return "x-mac-cyrillic";
case "chinese":
case "csgb2312":
case "csiso58gb231280":
case "gb2312":
case "gb_2312":
case "gb_2312-80":
case "gbk":
case "iso-ir-58":
case "x-gbk":
return "GBK";
case "gb18030":
return "gb18030";
case "big5":
case "big5-hkscs":
case "cn-big5":
case "csbig5":
case "x-x-big5":
return "Big5";
case "cseucpkdfmtjapanese":
case "euc-jp":
case "x-euc-jp":
return "EUC-JP";
case "csiso2022jp":
case "iso-2022-jp":
return "ISO-2022-JP";
case "csshiftjis":
case "ms932":
case "ms_kanji":
case "shift-jis":
case "shift_jis":
case "sjis":
case "windows-31j":
case "x-sjis":
return "Shift_JIS";
case "cseuckr":
case "csksc56011987":
case "euc-kr":
case "iso-ir-149":
case "korean":
case "ks_c_5601-1987":
case "ks_c_5601-1989":
case "ksc5601":
case "ksc_5601":
case "windows-949":
return "EUC-KR";
case "csiso2022kr":
case "hz-gb-2312":
case "iso-2022-cn":
case "iso-2022-cn-ext":
case "iso-2022-kr":
case "replacement":
return "replacement";
case "unicodefffe":
case "utf-16be":
return "UTF-16BE";
case "csunicode":
case "iso-10646-ucs-2":
case "ucs-2":
case "unicode":
case "unicodefeff":
case "utf-16":
case "utf-16le":
return "UTF-16LE";
case "x-user-defined":
return "x-user-defined";
default:
return "failure";
}
}
module2.exports = {
getEncoding
};
}
});
// lib/fileapi/util.js
var require_util3 = __commonJS({
"lib/fileapi/util.js"(exports2, module2) {
"use strict";
var {
kState,
kError,
kResult,
kAborted,
kLastProgressEventFired
} = require_symbols3();
var { ProgressEvent } = require_progressevent();
var { getEncoding } = require_encoding();
var { DOMException } = require_constants();
var { serializeAMimeType, parseMIMEType } = require_dataURL();
var { types } = require("util");
var { StringDecoder } = require("string_decoder");
var { btoa } = require("buffer");
var staticPropertyDescriptors = {
enumerable: true,
writable: false,
configurable: false
};
function readOperation(fr, blob, type, encodingName) {
if (fr[kState] === "loading") {
throw new DOMException("Invalid state", "InvalidStateError");
}
fr[kState] = "loading";
fr[kResult] = null;
fr[kError] = null;
const stream = blob.stream();
const reader = stream.getReader();
const bytes = [];
let chunkPromise = reader.read();
let isFirstChunk = true;
(async () => {
while (!fr[kAborted]) {
try {
const { done, value } = await chunkPromise;
if (isFirstChunk && !fr[kAborted]) {
queueMicrotask(() => {
fireAProgressEvent("loadstart", fr);
});
}
isFirstChunk = false;
if (!done && types.isUint8Array(value)) {
bytes.push(value);
if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) {
fr[kLastProgressEventFired] = Date.now();
queueMicrotask(() => {
fireAProgressEvent("progress", fr);
});
}
chunkPromise = reader.read();
} else if (done) {
queueMicrotask(() => {
fr[kState] = "done";
try {
const result = packageData(bytes, type, blob.type, encodingName);
if (fr[kAborted]) {
return;
}
fr[kResult] = result;
fireAProgressEvent("load", fr);
} catch (error) {
fr[kError] = error;
fireAProgressEvent("error", fr);
}
if (fr[kState] !== "loading") {
fireAProgressEvent("loadend", fr);
}
});
break;
}
} catch (error) {
if (fr[kAborted]) {
return;
}
queueMicrotask(() => {
fr[kState] = "done";
fr[kError] = error;
fireAProgressEvent("error", fr);
if (fr[kState] !== "loading") {
fireAProgressEvent("loadend", fr);
}
});
break;
}
}
})();
}
function fireAProgressEvent(e, reader) {
const event = new ProgressEvent(e, {
bubbles: false,
cancelable: false
});
reader.dispatchEvent(event);
}
function packageData(bytes, type, mimeType, encodingName) {
switch (type) {
case "DataURL": {
let dataURL = "data:";
const parsed = parseMIMEType(mimeType || "application/octet-stream");
if (parsed !== "failure") {
dataURL += serializeAMimeType(parsed);
}
dataURL += ";base64,";
const decoder = new StringDecoder("latin1");
for (const chunk of bytes) {
dataURL += btoa(decoder.write(chunk));
}
dataURL += btoa(decoder.end());
return dataURL;
}
case "Text": {
let encoding = "failure";
if (encodingName) {
encoding = getEncoding(encodingName);
}
if (encoding === "failure" && mimeType) {
const type2 = parseMIMEType(mimeType);
if (type2 !== "failure") {
encoding = getEncoding(type2.parameters.get("charset"));
}
}
if (encoding === "failure") {
encoding = "UTF-8";
}
return decode(bytes, encoding);
}
case "ArrayBuffer": {
const sequence = combineByteSequences(bytes);
return sequence.buffer;
}
case "BinaryString": {
let binaryString = "";
const decoder = new StringDecoder("latin1");
for (const chunk of bytes) {
binaryString += decoder.write(chunk);
}
binaryString += decoder.end();
return binaryString;
}
}
}
function decode(ioQueue, encoding) {
const bytes = combineByteSequences(ioQueue);
const BOMEncoding = BOMSniffing(bytes);
let slice = 0;
if (BOMEncoding !== null) {
encoding = BOMEncoding;
slice = BOMEncoding === "UTF-8" ? 3 : 2;
}
const sliced = bytes.slice(slice);
return new TextDecoder(encoding).decode(sliced);
}
function BOMSniffing(ioQueue) {
const [a, b, c] = ioQueue;
if (a === 239 && b === 187 && c === 191) {
return "UTF-8";
} else if (a === 254 && b === 255) {
return "UTF-16BE";
} else if (a === 255 && b === 254) {
return "UTF-16LE";
}
return null;
}
function combineByteSequences(sequences) {
const size = sequences.reduce((a, b) => {
return a + b.byteLength;
}, 0);
let offset = 0;
return sequences.reduce((a, b) => {
a.set(b, offset);
offset += b.byteLength;
return a;
}, new Uint8Array(size));
}
module2.exports = {
staticPropertyDescriptors,
readOperation,
fireAProgressEvent
};
}
});
// lib/fileapi/filereader.js
var require_filereader = __commonJS({
"lib/fileapi/filereader.js"(exports2, module2) {
"use strict";
var {
staticPropertyDescriptors,
readOperation,
fireAProgressEvent
} = require_util3();
var {
kState,
kError,
kResult,
kEvents,
kAborted
} = require_symbols3();
var { webidl } = require_webidl();
var { kEnumerableProperty } = require_util();
var FileReader = class extends EventTarget {
constructor() {
super();
this[kState] = "empty";
this[kResult] = null;
this[kError] = null;
this[kEvents] = {
loadend: null,
error: null,
abort: null,
load: null,
progress: null,
loadstart: null
};
}
/**
* @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer
* @param {import('buffer').Blob} blob
*/
readAsArrayBuffer(blob) {
webidl.brandCheck(this, FileReader);
webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsArrayBuffer" });
blob = webidl.converters.Blob(blob, { strict: false });
readOperation(this, blob, "ArrayBuffer");
}
/**
* @see https://w3c.github.io/FileAPI/#readAsBinaryString
* @param {import('buffer').Blob} blob
*/
readAsBinaryString(blob) {
webidl.brandCheck(this, FileReader);
webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsBinaryString" });
blob = webidl.converters.Blob(blob, { strict: false });
readOperation(this, blob, "BinaryString");
}
/**
* @see https://w3c.github.io/FileAPI/#readAsDataText
* @param {import('buffer').Blob} blob
* @param {string?} encoding
*/
readAsText(blob, encoding = void 0) {
webidl.brandCheck(this, FileReader);
webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsText" });
blob = webidl.converters.Blob(blob, { strict: false });
if (encoding !== void 0) {
encoding = webidl.converters.DOMString(encoding);
}
readOperation(this, blob, "Text", encoding);
}
/**
* @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL
* @param {import('buffer').Blob} blob
*/
readAsDataURL(blob) {
webidl.brandCheck(this, FileReader);
webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsDataURL" });
blob = webidl.converters.Blob(blob, { strict: false });
readOperation(this, blob, "DataURL");
}
/**
* @see https://w3c.github.io/FileAPI/#dfn-abort
*/
abort() {
if (this[kState] === "empty" || this[kState] === "done") {
this[kResult] = null;
return;
}
if (this[kState] === "loading") {
this[kState] = "done";
this[kResult] = null;
}
this[kAborted] = true;
fireAProgressEvent("abort", this);
if (this[kState] !== "loading") {
fireAProgressEvent("loadend", this);
}
}
/**
* @see https://w3c.github.io/FileAPI/#dom-filereader-readystate
*/
get readyState() {
webidl.brandCheck(this, FileReader);
switch (this[kState]) {
case "empty":
return this.EMPTY;
case "loading":
return this.LOADING;
case "done":
return this.DONE;
}
}
/**
* @see https://w3c.github.io/FileAPI/#dom-filereader-result
*/
get result() {
webidl.brandCheck(this, FileReader);
return this[kResult];
}
/**
* @see https://w3c.github.io/FileAPI/#dom-filereader-error
*/
get error() {
webidl.brandCheck(this, FileReader);
return this[kError];
}
get onloadend() {
webidl.brandCheck(this, FileReader);
return this[kEvents].loadend;
}
set onloadend(fn) {
webidl.brandCheck(this, FileReader);
if (this[kEvents].loadend) {
this.removeEventListener("loadend", this[kEvents].loadend);
}
if (typeof fn === "function") {
this[kEvents].loadend = fn;
this.addEventListener("loadend", fn);
} else {
this[kEvents].loadend = null;
}
}
get onerror() {
webidl.brandCheck(this, FileReader);
return this[kEvents].error;
}
set onerror(fn) {
webidl.brandCheck(this, FileReader);
if (this[kEvents].error) {
this.removeEventListener("error", this[kEvents].error);
}
if (typeof fn === "function") {
this[kEvents].error = fn;
this.addEventListener("error", fn);
} else {
this[kEvents].error = null;
}
}
get onloadstart() {
webidl.brandCheck(this, FileReader);
return this[kEvents].loadstart;
}
set onloadstart(fn) {
webidl.brandCheck(this, FileReader);
if (this[kEvents].loadstart) {
this.removeEventListener("loadstart", this[kEvents].loadstart);
}
if (typeof fn === "function") {
this[kEvents].loadstart = fn;
this.addEventListener("loadstart", fn);
} else {
this[kEvents].loadstart = null;
}
}
get onprogress() {
webidl.brandCheck(this, FileReader);
return this[kEvents].progress;
}
set onprogress(fn) {
webidl.brandCheck(this, FileReader);
if (this[kEvents].progress) {
this.removeEventListener("progress", this[kEvents].progress);
}
if (typeof fn === "function") {
this[kEvents].progress = fn;
this.addEventListener("progress", fn);
} else {
this[kEvents].progress = null;
}
}
get onload() {
webidl.brandCheck(this, FileReader);
return this[kEvents].load;
}
set onload(fn) {
webidl.brandCheck(this, FileReader);
if (this[kEvents].load) {
this.removeEventListener("load", this[kEvents].load);
}
if (typeof fn === "function") {
this[kEvents].load = fn;
this.addEventListener("load", fn);
} else {
this[kEvents].load = null;
}
}
get onabort() {
webidl.brandCheck(this, FileReader);
return this[kEvents].abort;
}
set onabort(fn) {
webidl.brandCheck(this, FileReader);
if (this[kEvents].abort) {
this.removeEventListener("abort", this[kEvents].abort);
}
if (typeof fn === "function") {
this[kEvents].abort = fn;
this.addEventListener("abort", fn);
} else {
this[kEvents].abort = null;
}
}
};
FileReader.EMPTY = FileReader.prototype.EMPTY = 0;
FileReader.LOADING = FileReader.prototype.LOADING = 1;
FileReader.DONE = FileReader.prototype.DONE = 2;
Object.defineProperties(FileReader.prototype, {
EMPTY: staticPropertyDescriptors,
LOADING: staticPropertyDescriptors,
DONE: staticPropertyDescriptors,
readAsArrayBuffer: kEnumerableProperty,
readAsBinaryString: kEnumerableProperty,
readAsText: kEnumerableProperty,
readAsDataURL: kEnumerableProperty,
abort: kEnumerableProperty,
readyState: kEnumerableProperty,
result: kEnumerableProperty,
error: kEnumerableProperty,
onloadstart: kEnumerableProperty,
onprogress: kEnumerableProperty,
onload: kEnumerableProperty,
onabort: kEnumerableProperty,
onerror: kEnumerableProperty,
onloadend: kEnumerableProperty,
[Symbol.toStringTag]: {
value: "FileReader",
writable: false,
enumerable: false,
configurable: true
}
});
Object.defineProperties(FileReader, {
EMPTY: staticPropertyDescriptors,
LOADING: staticPropertyDescriptors,
DONE: staticPropertyDescriptors
});
module2.exports = {
FileReader
};
}
});
// lib/cookies/constants.js
var require_constants3 = __commonJS({
"lib/cookies/constants.js"(exports2, module2) {
"use strict";
var maxAttributeValueSize = 1024;
var maxNameValuePairSize = 4096;
module2.exports = {
maxAttributeValueSize,
maxNameValuePairSize
};
}
});
// lib/cookies/util.js
var require_util4 = __commonJS({
"lib/cookies/util.js"(exports2, module2) {
"use strict";
var assert = require("assert");
var { kHeadersList } = require_symbols();
function isCTLExcludingHtab(value) {
if (value.length === 0) {
return false;
}
for (const char of value) {
const code = char.charCodeAt(0);
if (code >= 0 || code <= 8 || (code >= 10 || code <= 31) || code === 127) {
return false;
}
}
}
function validateCookieName(name) {
for (const char of name) {
const code = char.charCodeAt(0);
if (code <= 32 || code > 127 || char === "(" || char === ")" || char === ">" || char === "<" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}") {
throw new Error("Invalid cookie name");
}
}
}
function validateCookieValue(value) {
for (const char of value) {
const code = char.charCodeAt(0);
if (code < 33 || // exclude CTLs (0-31)
code === 34 || code === 44 || code === 59 || code === 92 || code > 126) {
throw new Error("Invalid header value");
}
}
}
function validateCookiePath(path) {
for (const char of path) {
const code = char.charCodeAt(0);
if (code < 33 || char === ";") {
throw new Error("Invalid cookie path");
}
}
}
function validateCookieDomain(domain) {
if (domain.startsWith("-") || domain.endsWith(".") || domain.endsWith("-")) {
throw new Error("Invalid cookie domain");
}
}
function toIMFDate(date) {
if (typeof date === "number") {
date = new Date(date);
}
const days = [
"Sun",
"Mon",
"Tue",
"Wed",
"Thu",
"Fri",
"Sat"
];
const months = [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
];
const dayName = days[date.getUTCDay()];
const day = date.getUTCDate().toString().padStart(2, "0");
const month = months[date.getUTCMonth()];
const year = date.getUTCFullYear();
const hour = date.getUTCHours().toString().padStart(2, "0");
const minute = date.getUTCMinutes().toString().padStart(2, "0");
const second = date.getUTCSeconds().toString().padStart(2, "0");
return `${dayName}, ${day} ${month} ${year} ${hour}:${minute}:${second} GMT`;
}
function validateCookieMaxAge(maxAge) {
if (maxAge < 0) {
throw new Error("Invalid cookie max-age");
}
}
function stringify(cookie) {
if (cookie.name.length === 0) {
return null;
}
validateCookieName(cookie.name);
validateCookieValue(cookie.value);
const out = [`${cookie.name}=${cookie.value}`];
if (cookie.name.startsWith("__Secure-")) {
cookie.secure = true;
}
if (cookie.name.startsWith("__Host-")) {
cookie.secure = true;
cookie.domain = null;
cookie.path = "/";
}
if (cookie.secure) {
out.push("Secure");
}
if (cookie.httpOnly) {
out.push("HttpOnly");
}
if (typeof cookie.maxAge === "number") {
validateCookieMaxAge(cookie.maxAge);
out.push(`Max-Age=${cookie.maxAge}`);
}
if (cookie.domain) {
validateCookieDomain(cookie.domain);
out.push(`Domain=${cookie.domain}`);
}
if (cookie.path) {
validateCookiePath(cookie.path);
out.push(`Path=${cookie.path}`);
}
if (cookie.expires && cookie.expires.toString() !== "Invalid Date") {
out.push(`Expires=${toIMFDate(cookie.expires)}`);
}
if (cookie.sameSite) {
out.push(`SameSite=${cookie.sameSite}`);
}
for (const part of cookie.unparsed) {
if (!part.includes("=")) {
throw new Error("Invalid unparsed");
}
const [key, ...value] = part.split("=");
out.push(`${key.trim()}=${value.join("=")}`);
}
return out.join("; ");
}
var kHeadersListNode;
function getHeadersList(headers) {
if (headers[kHeadersList]) {
return headers[kHeadersList];
}
if (!kHeadersListNode) {
kHeadersListNode = Object.getOwnPropertySymbols(headers).find(
(symbol) => symbol.description === "headers list"
);
assert(kHeadersListNode, "Headers cannot be parsed");
}
const headersList = headers[kHeadersListNode];
assert(headersList);
return headersList;
}
module2.exports = {
isCTLExcludingHtab,
stringify,
getHeadersList
};
}
});
// lib/cookies/parse.js
var require_parse = __commonJS({
"lib/cookies/parse.js"(exports2, module2) {
"use strict";
var { maxNameValuePairSize, maxAttributeValueSize } = require_constants3();
var { isCTLExcludingHtab } = require_util4();
var { collectASequenceOfCodePoints } = require_dataURL();
var assert = require("assert");
function parseSetCookie(header) {
if (isCTLExcludingHtab(header)) {
return null;
}
let nameValuePair = "";
let unparsedAttributes = "";
let name = "";
let value = "";
if (header.includes(";")) {
const position = { position: 0 };
nameValuePair = collectASequenceOfCodePoints((char) => char !== ";", header, position);
unparsedAttributes = header.slice(position.position);
} else {
nameValuePair = header;
}
if (!nameValuePair.includes("=")) {
value = nameValuePair;
} else {
const position = { position: 0 };
name = collectASequenceOfCodePoints(
(char) => char !== "=",
nameValuePair,
position
);
value = nameValuePair.slice(position.position + 1);
}
name = name.trim();
value = value.trim();
if (name.length + value.length > maxNameValuePairSize) {
return null;
}
return {
name,
value,
...parseUnparsedAttributes(unparsedAttributes)
};
}
function parseUnparsedAttributes(unparsedAttributes, cookieAttributeList = {}) {
if (unparsedAttributes.length === 0) {
return cookieAttributeList;
}
assert(unparsedAttributes[0] === ";");
unparsedAttributes = unparsedAttributes.slice(1);
let cookieAv = "";
if (unparsedAttributes.includes(";")) {
cookieAv = collectASequenceOfCodePoints(
(char) => char !== ";",
unparsedAttributes,
{ position: 0 }
);
unparsedAttributes = unparsedAttributes.slice(cookieAv.length);
} else {
cookieAv = unparsedAttributes;
unparsedAttributes = "";
}
let attributeName = "";
let attributeValue = "";
if (cookieAv.includes("=")) {
const position = { position: 0 };
attributeName = collectASequenceOfCodePoints(
(char) => char !== "=",
cookieAv,
position
);
attributeValue = cookieAv.slice(position.position + 1);
} else {
attributeName = cookieAv;
}
attributeName = attributeName.trim();
attributeValue = attributeValue.trim();
if (attributeValue.length > maxAttributeValueSize) {
return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
}
const attributeNameLowercase = attributeName.toLowerCase();
if (attributeNameLowercase === "expires") {
const expiryTime = new Date(attributeValue);
cookieAttributeList.expires = expiryTime;
} else if (attributeNameLowercase === "max-age") {
const charCode = attributeValue.charCodeAt(0);
if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") {
return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
}
if (!/^\d+$/.test(attributeValue)) {
return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
}
const deltaSeconds = Number(attributeValue);
cookieAttributeList.maxAge = deltaSeconds;
} else if (attributeNameLowercase === "domain") {
let cookieDomain = attributeValue;
if (cookieDomain[0] === ".") {
cookieDomain = cookieDomain.slice(1);
}
cookieDomain = cookieDomain.toLowerCase();
cookieAttributeList.domain = cookieDomain;
} else if (attributeNameLowercase === "path") {
let cookiePath = "";
if (attributeValue.length === 0 || attributeValue[0] !== "/") {
cookiePath = "/";
} else {
cookiePath = attributeValue;
}
cookieAttributeList.path = cookiePath;
} else if (attributeNameLowercase === "secure") {
cookieAttributeList.secure = true;
} else if (attributeNameLowercase === "httponly") {
cookieAttributeList.httpOnly = true;
} else if (attributeNameLowercase === "samesite") {
let enforcement = "Default";
const attributeValueLowercase = attributeValue.toLowerCase();
if (attributeValueLowercase.includes("none")) {
enforcement = "None";
}
if (attributeValueLowercase.includes("strict")) {
enforcement = "Strict";
}
if (attributeValueLowercase.includes("lax")) {
enforcement = "Lax";
}
cookieAttributeList.sameSite = enforcement;
} else {
cookieAttributeList.unparsed ??= [];
cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`);
}
return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
}
module2.exports = {
parseSetCookie,
parseUnparsedAttributes
};
}
});
// lib/cookies/index.js
var require_cookies = __commonJS({
"lib/cookies/index.js"(exports2, module2) {
"use strict";
var { parseSetCookie } = require_parse();
var { stringify, getHeadersList } = require_util4();
var { webidl } = require_webidl();
var { Headers } = require_headers();
function getCookies(headers) {
webidl.argumentLengthCheck(arguments, 1, { header: "getCookies" });
webidl.brandCheck(headers, Headers, { strict: false });
const cookie = headers.get("cookie");
const out = {};
if (!cookie) {
return out;
}
for (const piece of cookie.split(";")) {
const [name, ...value] = piece.split("=");
out[name.trim()] = value.join("=");
}
return out;
}
function deleteCookie(headers, name, attributes) {
webidl.argumentLengthCheck(arguments, 2, { header: "deleteCookie" });
webidl.brandCheck(headers, Headers, { strict: false });
name = webidl.converters.DOMString(name);
attributes = webidl.converters.DeleteCookieAttributes(attributes);
setCookie(headers, {
name,
value: "",
expires: new Date(0),
...attributes
});
}
function getSetCookies(headers) {
webidl.argumentLengthCheck(arguments, 1, { header: "getSetCookies" });
webidl.brandCheck(headers, Headers, { strict: false });
const cookies = getHeadersList(headers).cookies;
if (!cookies) {
return [];
}
return cookies.map((pair) => parseSetCookie(pair[1]));
}
function setCookie(headers, cookie) {
webidl.argumentLengthCheck(arguments, 2, { header: "setCookie" });
webidl.brandCheck(headers, Headers, { strict: false });
cookie = webidl.converters.Cookie(cookie);
const str = stringify(cookie);
if (str) {
headers.append("Set-Cookie", stringify(cookie));
}
}
webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([
{
converter: webidl.nullableConverter(webidl.converters.DOMString),
key: "path",
defaultValue: null
},
{
converter: webidl.nullableConverter(webidl.converters.DOMString),
key: "domain",
defaultValue: null
}
]);
webidl.converters.Cookie = webidl.dictionaryConverter([
{
converter: webidl.converters.DOMString,
key: "name"
},
{
converter: webidl.converters.DOMString,
key: "value"
},
{
converter: webidl.nullableConverter((value) => {
if (typeof value === "number") {
return webidl.converters["unsigned long long"](value);
}
return new Date(value);
}),
key: "expires",
defaultValue: null
},
{
converter: webidl.nullableConverter(webidl.converters["long long"]),
key: "maxAge",
defaultValue: null
},
{
converter: webidl.nullableConverter(webidl.converters.DOMString),
key: "domain",
defaultValue: null
},
{
converter: webidl.nullableConverter(webidl.converters.DOMString),
key: "path",
defaultValue: null
},
{
converter: webidl.nullableConverter(webidl.converters.boolean),
key: "secure",
defaultValue: null
},
{
converter: webidl.nullableConverter(webidl.converters.boolean),
key: "httpOnly",
defaultValue: null
},
{
converter: webidl.converters.USVString,
key: "sameSite",
allowedValues: ["Strict", "Lax", "None"]
},
{
converter: webidl.sequenceConverter(webidl.converters.DOMString),
key: "unparsed",
defaultValue: []
}
]);
module2.exports = {
getCookies,
deleteCookie,
getSetCookies,
setCookie
};
}
});
// 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_symbols4 = __commonJS({
"lib/websocket/symbols.js"(exports2, module2) {
"use strict";
module2.exports = {
kWebSocketURL: Symbol("url"),
kReadyState: Symbol("ready state"),
kController: Symbol("controller"),
kResponse: Symbol("response"),
kExtensions: Symbol("extensions"),
kProtocol: Symbol("protocol"),
kBinaryType: Symbol("binary type"),
kClosingFrame: Symbol("closing frame"),
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("worker_threads");
var MessageEvent = class extends Event {
#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 extends Event {
#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 extends Event {
#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_util5 = __commonJS({
"lib/websocket/util.js"(exports2, module2) {
"use strict";
var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols4();
var { states, opcodes } = require_constants4();
var { MessageEvent, ErrorEvent } = require_events();
function isEstablished(ws) {
return ws[kReadyState] === states.OPEN;
}
function isClosing(ws) {
return ws[kReadyState] === states.CLOSING;
}
function isClosed(ws) {
return ws[kReadyState] === states.CLOSED;
}
function fireEvent(e, target, eventConstructor = Event, eventInitDict) {
const event = new eventConstructor(e, eventInitDict);
target.dispatchEvent(event);
}
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
});
}
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;
}
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;
}
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)
});
}
}
module2.exports = {
isEstablished,
isClosing,
isClosed,
fireEvent,
isValidSubprotocol,
isValidStatusCode,
failWebsocketConnection,
websocketMessageReceived
};
}
});
// lib/websocket/frame.js
var require_frame = __commonJS({
"lib/websocket/frame.js"(exports2, module2) {
"use strict";
var { randomBytes } = require("crypto");
var { maxUnsigned16Bit } = require_constants4();
var WebsocketFrameSend = class {
/**
* @param {Buffer|undefined} data
*/
constructor(data) {
this.frameData = data;
this.maskKey = 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) {
new DataView(buffer.buffer).setUint16(2, bodyLength);
} 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("stream");
var diagnosticsChannel = require("diagnostics_channel");
var { parserStates, opcodes, states, emptyBuffer } = require_constants4();
var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols4();
var { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require_util5();
var { WebsocketFrameSend } = require_frame();
var channels = {};
channels.ping = diagnosticsChannel.channel("undici:websocket:ping");
channels.pong = diagnosticsChannel.channel("undici:websocket:pong");
var ByteParser = class extends Writable {
#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]) {
const 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) {
continue;
} else {
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/connection.js
var require_connection = __commonJS({
"lib/websocket/connection.js"(exports2, module2) {
"use strict";
var { randomBytes, createHash } = require("crypto");
var diagnosticsChannel = require("diagnostics_channel");
var { uid, states } = require_constants4();
var {
kReadyState,
kResponse,
kExtensions,
kProtocol,
kSentClose,
kByteParser,
kReceivedClose
} = require_symbols4();
var { fireEvent, failWebsocketConnection } = require_util5();
var { CloseEvent } = require_events();
var { ByteParser } = require_receiver();
var { makeRequest } = require_request();
var { fetching } = require_fetch();
var { getGlobalDispatcher } = require_node_undici_5_15_0_dfsg1_cs20_10_9();
var channels = {};
channels.open = diagnosticsChannel.channel("undici:websocket:open");
channels.close = diagnosticsChannel.channel("undici:websocket:close");
channels.socketError = diagnosticsChannel.channel("undici:websocket:socket_error");
function establishWebSocketConnection(url, protocols, ws) {
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"
});
const keyValue = 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: 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 = 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;
}
ws[kResponse] = response;
const parser = new ByteParser(ws);
response.socket.ws = ws;
ws[kByteParser] = parser;
whenConnectionEstablished(ws);
response.socket.on("data", onSocketData);
response.socket.on("close", onSocketClose);
response.socket.on("error", onSocketError);
parser.on("drain", onParserDrain);
}
});
return controller;
}
function whenConnectionEstablished(ws) {
const { [kResponse]: response } = ws;
ws[kReadyState] = states.OPEN;
const extensions = response.headersList.get("sec-websocket-extensions");
if (extensions !== null) {
ws[kExtensions] = extensions;
}
const protocol = response.headersList.get("sec-websocket-protocol");
if (protocol !== null) {
ws[kProtocol] = protocol;
}
fireEvent("open", ws);
if (channels.open.hasSubscribers) {
channels.open.publish({
address: response.socket.address(),
protocol,
extensions
});
}
}
function onSocketData(chunk) {
if (!this.ws[kByteParser].write(chunk)) {
this.pause();
}
}
function onParserDrain() {
this.ws[kResponse].socket.resume();
}
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
});
}
}
function onSocketError(error) {
const { ws } = this;
ws[kReadyState] = states.CLOSING;
if (channels.socketError.hasSubscribers) {
channels.socketError.publish(error);
}
this.destroy();
}
module2.exports = {
establishWebSocketConnection
};
}
});
// lib/websocket/websocket.js
var require_websocket = __commonJS({
"lib/websocket/websocket.js"(exports2, module2) {
"use strict";
var { webidl } = require_webidl();
var { DOMException } = require_constants();
var { URLSerializer } = require_dataURL();
var { staticPropertyDescriptors, states, opcodes, emptyBuffer } = require_constants4();
var {
kWebSocketURL,
kReadyState,
kController,
kExtensions,
kProtocol,
kBinaryType,
kResponse,
kSentClose
} = require_symbols4();
var { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection } = require_util5();
var { establishWebSocketConnection } = require_connection();
var { WebsocketFrameSend } = require_frame();
var { kEnumerableProperty, isBlobLike } = require_util();
var { types } = require("util");
var experimentalWarned = false;
var WebSocket = class extends EventTarget {
#events = {
open: null,
error: null,
close: null,
message: null
};
#bufferedAmount = 0;
/**
* @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"
});
}
url = webidl.converters.USVString(url);
protocols = webidl.converters["DOMString or sequence<DOMString>"](protocols);
let urlRecord;
try {
urlRecord = new URL(url);
} catch (e) {
throw new DOMException(e, "SyntaxError");
}
if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") {
throw new DOMException(
`Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
"SyntaxError"
);
}
if (urlRecord.hash) {
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] = urlRecord;
this[kController] = establishWebSocketConnection(urlRecord, protocols, this);
this[kReadyState] = WebSocket.CONNECTING;
this[kExtensions] = "";
this[kProtocol] = "";
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 = new ArrayBuffer(data.byteLength);
if (Buffer.isBuffer(data)) {
Buffer.from(ab).set(data);
} else {
new data.constructor(ab).set(data);
}
const value = Buffer.from(ab);
const frame = new WebsocketFrameSend(value);
const buffer = frame.createFrame(opcodes.BINARY);
this.#bufferedAmount += value.byteLength;
socket.write(buffer, () => {
this.#bufferedAmount -= value.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[kExtensions];
}
get protocol() {
webidl.brandCheck(this, WebSocket);
return this[kProtocol];
}
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;
}
}
};
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.WebSocketSendData = function(V) {
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);
}
}
return webidl.converters.USVString(V);
};
module2.exports = {
WebSocket
};
}
});
// index.js
var require_node_undici_5_15_0_dfsg1_cs20_10_9 = __commonJS({
"index.js"(exports2, module2) {
"use strict";
var Client = require_client();
var Dispatcher = require_dispatcher();
var errors = require_errors();
var Pool = require_pool();
var BalancedPool = require_balanced_pool();
var Agent = require_agent();
var util = require_util();
var { InvalidArgumentError } = errors;
var api = require_api();
var buildConnector = require_connect();
var MockClient = require_mock_client();
var MockAgent = require_mock_agent();
var MockPool = require_mock_pool();
var mockErrors = require_mock_errors();
var ProxyAgent = require_proxy_agent();
var { getGlobalDispatcher, setGlobalDispatcher } = require_global2();
var DecoratorHandler = require_DecoratorHandler();
var RedirectHandler = require_RedirectHandler();
var createRedirectInterceptor = require_redirectInterceptor();
var nodeVersion = process.versions.node.split(".");
var nodeMajor = Number(nodeVersion[0]);
var nodeMinor = Number(nodeVersion[1]);
Object.assign(Dispatcher.prototype, api);
module2.exports.Dispatcher = Dispatcher;
module2.exports.Client = Client;
module2.exports.Pool = Pool;
module2.exports.BalancedPool = BalancedPool;
module2.exports.Agent = Agent;
module2.exports.ProxyAgent = ProxyAgent;
module2.exports.DecoratorHandler = DecoratorHandler;
module2.exports.RedirectHandler = RedirectHandler;
module2.exports.createRedirectInterceptor = createRedirectInterceptor;
module2.exports.buildConnector = buildConnector;
module2.exports.errors = errors;
function makeDispatcher(fn) {
return (url, opts, handler) => {
if (typeof opts === "function") {
handler = opts;
opts = null;
}
if (!url || typeof url !== "string" && typeof url !== "object" && !(url instanceof URL)) {
throw new InvalidArgumentError("invalid url");
}
if (opts != null && typeof opts !== "object") {
throw new InvalidArgumentError("invalid opts");
}
if (opts && opts.path != null) {
if (typeof opts.path !== "string") {
throw new InvalidArgumentError("invalid opts.path");
}
let path = opts.path;
if (!opts.path.startsWith("/")) {
path = `/${path}`;
}
url = new URL(util.parseOrigin(url).origin + path);
} else {
if (!opts) {
opts = typeof url === "object" ? url : {};
}
url = util.parseURL(url);
}
const { agent, dispatcher = getGlobalDispatcher() } = opts;
if (agent) {
throw new InvalidArgumentError("unsupported opts.agent. Did you mean opts.client?");
}
return fn.call(dispatcher, {
...opts,
origin: url.origin,
path: url.search ? `${url.pathname}${url.search}` : url.pathname,
method: opts.method || (opts.body ? "PUT" : "GET")
}, handler);
};
}
module2.exports.setGlobalDispatcher = setGlobalDispatcher;
module2.exports.getGlobalDispatcher = getGlobalDispatcher;
if (nodeMajor > 16 || nodeMajor === 16 && nodeMinor >= 8) {
let fetchImpl2 = null;
module2.exports.fetch = async function fetch2(resource) {
if (!fetchImpl2) {
fetchImpl2 = require_fetch().fetch;
}
try {
return await fetchImpl2(...arguments);
} catch (err) {
Error.captureStackTrace(err, this);
throw err;
}
};
module2.exports.Headers = require_headers().Headers;
module2.exports.Response = require_response().Response;
module2.exports.Request = require_request().Request;
module2.exports.FormData = require_formdata().FormData;
module2.exports.File = require_file().File;
module2.exports.FileReader = require_filereader().FileReader;
const { setGlobalOrigin, getGlobalOrigin } = require_global();
module2.exports.setGlobalOrigin = setGlobalOrigin;
module2.exports.getGlobalOrigin = getGlobalOrigin;
}
if (nodeMajor >= 16) {
const { deleteCookie, getCookies, getSetCookies, setCookie } = require_cookies();
module2.exports.deleteCookie = deleteCookie;
module2.exports.getCookies = getCookies;
module2.exports.getSetCookies = getSetCookies;
module2.exports.setCookie = setCookie;
}
if (nodeMajor >= 18) {
const { WebSocket } = require_websocket();
module2.exports.WebSocket = WebSocket;
}
module2.exports.request = makeDispatcher(api.request);
module2.exports.stream = makeDispatcher(api.stream);
module2.exports.pipeline = makeDispatcher(api.pipeline);
module2.exports.connect = makeDispatcher(api.connect);
module2.exports.upgrade = makeDispatcher(api.upgrade);
module2.exports.MockClient = MockClient;
module2.exports.MockPool = MockPool;
module2.exports.MockAgent = MockAgent;
module2.exports.mockErrors = mockErrors;
}
});
// lib/fetch/index.js
var require_fetch = __commonJS({
"lib/fetch/index.js"(exports2, module2) {
"use strict";
var {
Response,
makeNetworkError,
makeAppropriateNetworkError,
filterResponse,
makeResponse
} = require_response();
var { Headers } = require_headers();
var { Request, makeRequest } = require_request();
var zlib = require("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
} = require_util2();
var { kState, kHeaders, kGuard, kRealm, kHeadersCaseInsensitive } = require_symbols2();
var assert = require("assert");
var { safelyExtractBody } = require_body();
var {
redirectStatus,
nullBodyStatus,
safeMethods,
requestBodyHeader,
subresource,
DOMException
} = require_constants();
var { kHeadersList } = require_symbols();
var EE = require("events");
var { Readable, pipeline } = require("stream");
var { isErrored, isReadable } = require_util();
var { dataURLProcessor, serializeAMimeType } = require_dataURL();
var { TransformStream } = require("stream/web");
var { getGlobalDispatcher } = require_node_undici_5_15_0_dfsg1_cs20_10_9();
var { webidl } = require_webidl();
var { STATUS_CODES } = require("http");
var resolveObjectURL;
var ReadableStream = globalThis.ReadableStream;
var nodeVersion = process.versions.node.split(".");
var nodeMajor = Number(nodeVersion[0]);
var nodeMinor = Number(nodeVersion[1]);
var Fetch = class extends EE {
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);
}
};
async function fetch2(input, init = {}) {
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;
requestObject.signal.addEventListener(
"abort",
() => {
locallyAborted = true;
abortFetch(p, request, responseObject, requestObject.signal.reason);
if (controller != null) {
controller.abort();
}
},
{ once: true }
);
const handleFetchDone = (response) => finalizeAndReportTiming(response, "fetch");
const processResponse = (response) => {
if (locallyAborted) {
return;
}
if (response.aborted) {
abortFetch(p, request, responseObject, controller.serializedAbortReason);
return;
}
if (response.type === "error") {
p.reject(
Object.assign(new TypeError("fetch failed"), { cause: response.error })
);
return;
}
responseObject = new Response();
responseObject[kState] = response;
responseObject[kRealm] = relevantRealm;
responseObject[kHeaders][kHeadersList] = response.headersList;
responseObject[kHeaders][kGuard] = "immutable";
responseObject[kHeaders][kRealm] = relevantRealm;
p.resolve(responseObject);
};
controller = fetching({
request,
processResponseEndOfBody: handleFetchDone,
processResponse,
dispatcher: init.dispatcher ?? getGlobalDispatcher()
// undici
});
return p.promise;
}
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 (!/^https?:/.test(originalURL.protocol)) {
return;
}
if (timingInfo === null) {
return;
}
if (!timingInfo.timingAllowPassed) {
timingInfo = createOpaqueTimingInfo({
startTime: timingInfo.startTime
});
cacheState = "";
}
response.timingInfo.endTime = coarsenedSharedCurrentTime();
response.timingInfo = timingInfo;
markResourceTiming(
timingInfo,
originalURL,
initiatorType,
globalThis,
cacheState
);
}
function markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState) {
if (nodeMajor >= 18 && nodeMinor >= 2) {
performance.markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState);
}
}
function abortFetch(p, request, responseObject, error) {
if (!error) {
error = new DOMException("The operation was aborted.", "AbortError");
}
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;
});
}
}
function fetching({
request,
processRequestBodyChunkLength,
processRequestEndOfBody,
processResponse,
processResponseEndOfBody,
processResponseConsumeBody,
useParallelQueue = false,
dispatcher
// undici
}) {
let taskDestination = null;
let crossOriginIsolatedCapability = false;
if (request.client != null) {
taskDestination = request.client.globalObject;
crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability;
}
const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability);
const timingInfo = createOpaqueTimingInfo({
startTime: currenTime
});
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")) {
const value = "*/*";
request.headersList.append("accept", value);
}
if (!request.headersList.contains("accept-language")) {
request.headersList.append("accept-language", "*");
}
if (request.priority === null) {
}
if (subresource.includes(request.destination)) {
}
mainFetch(fetchParams).catch((err) => {
fetchParams.controller.terminate(err);
});
return fetchParams.controller;
}
async function mainFetch(fetchParams, recursive = false) {
const request = fetchParams.request;
let response = null;
if (request.localURLsOnly && !/^(about|blob|data):/.test(requestCurrentURL(request).protocol)) {
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 (!/^https?:/.test(requestCurrentURL(request).protocol)) {
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")) {
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 = (reason) => fetchFinale(fetchParams, makeNetworkError(reason));
if (request.responseTainting === "opaque" || response.body == null) {
processBodyError(response.error);
return;
}
const processBody = (bytes) => {
if (!bytesMatch(bytes, request.integrity)) {
processBodyError("integrity mismatch");
return;
}
response.body = safelyExtractBody(bytes)[0];
fetchFinale(fetchParams, response);
};
await fullyReadBody(response.body, processBody, processBodyError);
} else {
fetchFinale(fetchParams, response);
}
}
async function schemeFetch(fetchParams) {
if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
return makeAppropriateNetworkError(fetchParams);
}
const { request } = fetchParams;
const { protocol: scheme } = requestCurrentURL(request);
switch (scheme) {
case "about:": {
return makeNetworkError("about scheme is not supported");
}
case "blob:": {
if (!resolveObjectURL) {
resolveObjectURL = require("buffer").resolveObjectURL;
}
const blobURLEntry = requestCurrentURL(request);
if (blobURLEntry.search.length !== 0) {
return makeNetworkError("NetworkError when attempting to fetch resource.");
}
const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString());
if (request.method !== "GET" || !isBlobLike(blobURLEntryObject)) {
return makeNetworkError("invalid method");
}
const bodyWithType = safelyExtractBody(blobURLEntryObject);
const body = bodyWithType[0];
const length = isomorphicEncode(`${body.length}`);
const type = bodyWithType[1] ?? "";
const response = makeResponse({
statusText: "OK",
headersList: [
["content-length", { name: "Content-Length", value: length }],
["content-type", { name: "Content-Type", value: type }]
]
});
response.body = body;
return response;
}
case "data:": {
const currentURL = requestCurrentURL(request);
const dataURLStruct = dataURLProcessor(currentURL);
if (dataURLStruct === "failure") {
return makeNetworkError("failed to fetch the data URL");
}
const mimeType = serializeAMimeType(dataURLStruct.mimeType);
return makeResponse({
statusText: "OK",
headersList: [
["content-type", { name: "Content-Type", value: mimeType }]
],
body: safelyExtractBody(dataURLStruct.body)[0]
});
}
case "file:": {
return makeNetworkError("not implemented... yet...");
}
case "http:":
case "https:": {
return await httpFetch(fetchParams).catch((err) => makeNetworkError(err));
}
default: {
return makeNetworkError("unknown scheme");
}
}
}
function finalizeResponse(fetchParams, response) {
fetchParams.request.done = true;
if (fetchParams.processResponseDone != null) {
queueMicrotask(() => fetchParams.processResponseDone(response));
}
}
async function fetchFinale(fetchParams, response) {
if (response.type === "error") {
response.urlList = [fetchParams.request.urlList[0]];
response.timingInfo = createOpaqueTimingInfo({
startTime: fetchParams.timingInfo.startTime
});
}
const processResponseEndOfBody = () => {
fetchParams.request.done = true;
if (fetchParams.processResponseEndOfBody != null) {
queueMicrotask(() => fetchParams.processResponseEndOfBody(response));
}
};
if (fetchParams.processResponse != null) {
queueMicrotask(() => fetchParams.processResponse(response));
}
if (response.body == null) {
processResponseEndOfBody();
} else {
const identityTransformAlgorithm = (chunk, controller) => {
controller.enqueue(chunk);
};
const transformStream = new TransformStream({
start() {
},
transform: identityTransformAlgorithm,
flush: processResponseEndOfBody
}, {
size() {
return 1;
}
}, {
size() {
return 1;
}
});
response.body = { stream: response.body.stream.pipeThrough(transformStream) };
}
if (fetchParams.processResponseConsumeBody != null) {
const processBody = (nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes);
const processBodyError = (failure) => fetchParams.processResponseConsumeBody(response, failure);
if (response.body == null) {
queueMicrotask(() => processBody(null));
} else {
await fullyReadBody(response.body, processBody, processBodyError);
}
}
}
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 (redirectStatus.includes(actualResponse.status)) {
if (request.redirect !== "manual") {
fetchParams.controller.connection.destroy();
}
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;
}
async 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 makeNetworkError(err);
}
if (!/^https?:/.test(locationURL.protocol)) {
return makeNetworkError("URL scheme must be a HTTP(S) scheme");
}
if (request.redirectCount === 20) {
return makeNetworkError("redirect count exceeded");
}
request.redirectCount += 1;
if (request.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request, locationURL)) {
return makeNetworkError('cross origin not allowed for request mode "cors"');
}
if (request.responseTainting === "cors" && (locationURL.username || locationURL.password)) {
return makeNetworkError(
'URL cannot contain credentials for request mode "cors"'
);
}
if (actualResponse.status !== 303 && request.body != null && request.body.source == null) {
return makeNetworkError();
}
if ([301, 302].includes(actualResponse.status) && request.method === "POST" || actualResponse.status === 303 && !["GET", "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");
request.headersList.delete("cookie");
request.headersList.delete("host");
}
if (request.body != null) {
assert(request.body.source);
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);
}
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);
}
if (contentLength != null && httpRequest.keepalive) {
}
if (httpRequest.referrer instanceof URL) {
httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href));
}
appendRequestOriginHeader(httpRequest);
appendFetchMetadata(httpRequest);
if (!httpRequest.headersList.contains("user-agent")) {
httpRequest.headersList.append("user-agent", "undici");
}
if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since") || httpRequest.headersList.contains("if-none-match") || httpRequest.headersList.contains("if-unmodified-since") || httpRequest.headersList.contains("if-match") || httpRequest.headersList.contains("if-range"))) {
httpRequest.cache = "no-store";
}
if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control")) {
httpRequest.headersList.append("cache-control", "max-age=0");
}
if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") {
if (!httpRequest.headersList.contains("pragma")) {
httpRequest.headersList.append("pragma", "no-cache");
}
if (!httpRequest.headersList.contains("cache-control")) {
httpRequest.headersList.append("cache-control", "no-cache");
}
}
if (httpRequest.headersList.contains("range")) {
httpRequest.headersList.append("accept-encoding", "identity");
}
if (!httpRequest.headersList.contains("accept-encoding")) {
if (/^https:/.test(requestCurrentURL(httpRequest).protocol)) {
httpRequest.headersList.append("accept-encoding", "br, gzip, deflate");
} else {
httpRequest.headersList.append("accept-encoding", "gzip, deflate");
}
}
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 (!safeMethods.includes(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")) {
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;
}
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) {
if (!this.destroyed) {
this.destroyed = true;
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 = async function* (bytes) {
if (isCancelled(fetchParams)) {
return;
}
yield bytes;
fetchParams.processRequestBodyChunkLength?.(bytes.byteLength);
};
const processEndOfBody = () => {
if (isCancelled(fetchParams)) {
return;
}
if (fetchParams.processRequestEndOfBody) {
fetchParams.processRequestEndOfBody();
}
};
const processBodyError = (e) => {
if (isCancelled(fetchParams)) {
return;
}
if (e.name === "AbortError") {
fetchParams.controller.abort();
} else {
fetchParams.controller.terminate(e);
}
};
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);
}
return makeNetworkError(err);
}
const pullAlgorithm = () => {
fetchParams.controller.resume();
};
const cancelAlgorithm = (reason) => {
fetchParams.controller.abort(reason);
};
if (!ReadableStream) {
ReadableStream = require("stream/web").ReadableStream;
}
const stream = new ReadableStream(
{
async start(controller) {
fetchParams.controller.controller = controller;
},
async pull(controller) {
await pullAlgorithm(controller);
},
async cancel(reason) {
await cancelAlgorithm(reason);
}
},
{
highWaterMark: 0,
size() {
return 1;
}
}
);
response.body = { stream };
fetchParams.controller.on("terminated", onAborted);
fetchParams.controller.resume = async () => {
while (true) {
let bytes;
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;
}
}
if (bytes === void 0) {
readableStreamClose(fetchParams.controller.controller);
finalizeResponse(fetchParams, response);
return;
}
timingInfo.decodedBodySize += bytes?.byteLength ?? 0;
if (isErrorLike(bytes)) {
fetchParams.controller.terminate(bytes);
return;
}
fetchParams.controller.controller.enqueue(new Uint8Array(bytes));
if (isErrored(stream)) {
fetchParams.controller.terminate();
return;
}
if (!fetchParams.controller.controller.desiredSize) {
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();
}
return response;
async 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: fetchParams.controller.dispatcher.isMockActive ? request.body && request.body.source : body,
headers: request.headersList[kHeadersCaseInsensitive],
maxRedirections: 0,
bodyTimeout: 3e5,
headersTimeout: 3e5,
upgrade: request.mode === "websocket" ? "websocket" : void 0
},
{
body: null,
abort: null,
onConnect(abort) {
const { connection } = fetchParams.controller;
if (connection.destroyed) {
abort(new DOMException("The operation was aborted.", "AbortError"));
} else {
fetchParams.controller.on("terminated", abort);
this.abort = connection.abort = abort;
}
},
onHeaders(status, headersList, resume, statusText) {
if (status < 200) {
return;
}
let codings = [];
let location = "";
const headers = new Headers();
for (let n = 0; n < headersList.length; n += 2) {
const key = headersList[n + 0].toString("latin1");
const val = headersList[n + 1].toString("latin1");
if (key.toLowerCase() === "content-encoding") {
codings = val.split(",").map((x) => x.trim());
} else if (key.toLowerCase() === "location") {
location = val;
}
headers.append(key, val);
}
this.body = new Readable({ read: resume });
const decoders = [];
const willFollow = request.redirect === "follow" && location && redirectStatus.includes(status);
if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) {
for (const coding of codings) {
if (/(x-)?gzip/.test(coding)) {
decoders.push(zlib.createGunzip());
} else if (/(x-)?deflate/.test(coding)) {
decoders.push(zlib.createInflate());
} else if (coding === "br") {
decoders.push(zlib.createBrotliDecompress());
} else {
decoders.length = 0;
break;
}
}
}
resolve({
status,
statusText,
headersList: headers[kHeadersList],
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, headersList, socket) {
if (status !== 101) {
return;
}
const headers = new Headers();
for (let n = 0; n < headersList.length; n += 2) {
const key = headersList[n + 0].toString("latin1");
const val = headersList[n + 1].toString("latin1");
headers.append(key, val);
}
resolve({
status,
statusText: STATUS_CODES[status],
headersList: headers[kHeadersList],
socket
});
return true;
}
}
));
}
}
module2.exports = {
fetch: fetch2,
Fetch,
fetching,
finalizeAndReportTiming
};
}
});
// index-fetch.js
var fetchImpl = require_fetch().fetch;
module.exports.fetch = async function fetch(resource) {
try {
return await fetchImpl(...arguments);
} catch (err) {
Error.captureStackTrace(err, this);
throw err;
}
};
module.exports.FormData = require_formdata().FormData;
module.exports.Headers = require_headers().Headers;
module.exports.Response = require_response().Response;
module.exports.Request = require_request().Request;
/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
/*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> */
|