mirror of
https://github.com/actions/checkout.git
synced 2026-06-24 08:22:29 +03:00
Aiqiao Yan
42247 lines
1.4 MiB
Plaintext
42247 lines
1.4 MiB
Plaintext
import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";
|
|
/******/ var __webpack_modules__ = ({
|
|
|
|
/***/ 9659:
|
|
/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
|
|
|
|
|
|
/* eslint-disable @typescript-eslint/no-explicit-any */
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));
|
|
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
}) : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = (this && this.__importStar) || (function () {
|
|
var ownKeys = function(o) {
|
|
ownKeys = Object.getOwnPropertyNames || function (o) {
|
|
var ar = [];
|
|
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
|
|
return ar;
|
|
};
|
|
return ownKeys(o);
|
|
};
|
|
return function (mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
})();
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.HttpClient = exports.HttpClientResponse = exports.HttpClientError = exports.MediaTypes = exports.Headers = exports.HttpCodes = void 0;
|
|
exports.getProxyUrl = getProxyUrl;
|
|
exports.isHttps = isHttps;
|
|
const http = __importStar(__nccwpck_require__(8611));
|
|
const https = __importStar(__nccwpck_require__(5692));
|
|
const pm = __importStar(__nccwpck_require__(3335));
|
|
const tunnel = __importStar(__nccwpck_require__(770));
|
|
const undici_1 = __nccwpck_require__(6752);
|
|
var HttpCodes;
|
|
(function (HttpCodes) {
|
|
HttpCodes[HttpCodes["OK"] = 200] = "OK";
|
|
HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices";
|
|
HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently";
|
|
HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved";
|
|
HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther";
|
|
HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified";
|
|
HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy";
|
|
HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy";
|
|
HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect";
|
|
HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect";
|
|
HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest";
|
|
HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized";
|
|
HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired";
|
|
HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden";
|
|
HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound";
|
|
HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed";
|
|
HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable";
|
|
HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
|
|
HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout";
|
|
HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict";
|
|
HttpCodes[HttpCodes["Gone"] = 410] = "Gone";
|
|
HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests";
|
|
HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError";
|
|
HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented";
|
|
HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway";
|
|
HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable";
|
|
HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout";
|
|
})(HttpCodes || (exports.HttpCodes = HttpCodes = {}));
|
|
var Headers;
|
|
(function (Headers) {
|
|
Headers["Accept"] = "accept";
|
|
Headers["ContentType"] = "content-type";
|
|
})(Headers || (exports.Headers = Headers = {}));
|
|
var MediaTypes;
|
|
(function (MediaTypes) {
|
|
MediaTypes["ApplicationJson"] = "application/json";
|
|
})(MediaTypes || (exports.MediaTypes = MediaTypes = {}));
|
|
/**
|
|
* Returns the proxy URL, depending upon the supplied url and proxy environment variables.
|
|
* @param serverUrl The server URL where the request will be sent. For example, https://api.github.com
|
|
*/
|
|
function getProxyUrl(serverUrl) {
|
|
const proxyUrl = pm.getProxyUrl(new URL(serverUrl));
|
|
return proxyUrl ? proxyUrl.href : '';
|
|
}
|
|
const HttpRedirectCodes = [
|
|
HttpCodes.MovedPermanently,
|
|
HttpCodes.ResourceMoved,
|
|
HttpCodes.SeeOther,
|
|
HttpCodes.TemporaryRedirect,
|
|
HttpCodes.PermanentRedirect
|
|
];
|
|
const HttpResponseRetryCodes = [
|
|
HttpCodes.BadGateway,
|
|
HttpCodes.ServiceUnavailable,
|
|
HttpCodes.GatewayTimeout
|
|
];
|
|
const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD'];
|
|
const ExponentialBackoffCeiling = 10;
|
|
const ExponentialBackoffTimeSlice = 5;
|
|
class HttpClientError extends Error {
|
|
constructor(message, statusCode) {
|
|
super(message);
|
|
this.name = 'HttpClientError';
|
|
this.statusCode = statusCode;
|
|
Object.setPrototypeOf(this, HttpClientError.prototype);
|
|
}
|
|
}
|
|
exports.HttpClientError = HttpClientError;
|
|
class HttpClientResponse {
|
|
constructor(message) {
|
|
this.message = message;
|
|
}
|
|
readBody() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
|
|
let output = Buffer.alloc(0);
|
|
this.message.on('data', (chunk) => {
|
|
output = Buffer.concat([output, chunk]);
|
|
});
|
|
this.message.on('end', () => {
|
|
resolve(output.toString());
|
|
});
|
|
}));
|
|
});
|
|
}
|
|
readBodyBuffer() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
|
|
const chunks = [];
|
|
this.message.on('data', (chunk) => {
|
|
chunks.push(chunk);
|
|
});
|
|
this.message.on('end', () => {
|
|
resolve(Buffer.concat(chunks));
|
|
});
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
exports.HttpClientResponse = HttpClientResponse;
|
|
function isHttps(requestUrl) {
|
|
const parsedUrl = new URL(requestUrl);
|
|
return parsedUrl.protocol === 'https:';
|
|
}
|
|
class HttpClient {
|
|
constructor(userAgent, handlers, requestOptions) {
|
|
this._ignoreSslError = false;
|
|
this._allowRedirects = true;
|
|
this._allowRedirectDowngrade = false;
|
|
this._maxRedirects = 50;
|
|
this._allowRetries = false;
|
|
this._maxRetries = 1;
|
|
this._keepAlive = false;
|
|
this._disposed = false;
|
|
this.userAgent = this._getUserAgentWithOrchestrationId(userAgent);
|
|
this.handlers = handlers || [];
|
|
this.requestOptions = requestOptions;
|
|
if (requestOptions) {
|
|
if (requestOptions.ignoreSslError != null) {
|
|
this._ignoreSslError = requestOptions.ignoreSslError;
|
|
}
|
|
this._socketTimeout = requestOptions.socketTimeout;
|
|
if (requestOptions.allowRedirects != null) {
|
|
this._allowRedirects = requestOptions.allowRedirects;
|
|
}
|
|
if (requestOptions.allowRedirectDowngrade != null) {
|
|
this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade;
|
|
}
|
|
if (requestOptions.maxRedirects != null) {
|
|
this._maxRedirects = Math.max(requestOptions.maxRedirects, 0);
|
|
}
|
|
if (requestOptions.keepAlive != null) {
|
|
this._keepAlive = requestOptions.keepAlive;
|
|
}
|
|
if (requestOptions.allowRetries != null) {
|
|
this._allowRetries = requestOptions.allowRetries;
|
|
}
|
|
if (requestOptions.maxRetries != null) {
|
|
this._maxRetries = requestOptions.maxRetries;
|
|
}
|
|
}
|
|
}
|
|
options(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('OPTIONS', requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
get(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('GET', requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
del(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('DELETE', requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
post(requestUrl, data, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('POST', requestUrl, data, additionalHeaders || {});
|
|
});
|
|
}
|
|
patch(requestUrl, data, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('PATCH', requestUrl, data, additionalHeaders || {});
|
|
});
|
|
}
|
|
put(requestUrl, data, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('PUT', requestUrl, data, additionalHeaders || {});
|
|
});
|
|
}
|
|
head(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('HEAD', requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
sendStream(verb, requestUrl, stream, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request(verb, requestUrl, stream, additionalHeaders);
|
|
});
|
|
}
|
|
/**
|
|
* Gets a typed object from an endpoint
|
|
* Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise
|
|
*/
|
|
getJson(requestUrl_1) {
|
|
return __awaiter(this, arguments, void 0, function* (requestUrl, additionalHeaders = {}) {
|
|
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
|
const res = yield this.get(requestUrl, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
postJson(requestUrl_1, obj_1) {
|
|
return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) {
|
|
const data = JSON.stringify(obj, null, 2);
|
|
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
|
additionalHeaders[Headers.ContentType] =
|
|
this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson);
|
|
const res = yield this.post(requestUrl, data, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
putJson(requestUrl_1, obj_1) {
|
|
return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) {
|
|
const data = JSON.stringify(obj, null, 2);
|
|
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
|
additionalHeaders[Headers.ContentType] =
|
|
this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson);
|
|
const res = yield this.put(requestUrl, data, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
patchJson(requestUrl_1, obj_1) {
|
|
return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) {
|
|
const data = JSON.stringify(obj, null, 2);
|
|
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
|
additionalHeaders[Headers.ContentType] =
|
|
this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson);
|
|
const res = yield this.patch(requestUrl, data, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
/**
|
|
* Makes a raw http request.
|
|
* All other methods such as get, post, patch, and request ultimately call this.
|
|
* Prefer get, del, post and patch
|
|
*/
|
|
request(verb, requestUrl, data, headers) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (this._disposed) {
|
|
throw new Error('Client has already been disposed.');
|
|
}
|
|
const parsedUrl = new URL(requestUrl);
|
|
let info = this._prepareRequest(verb, parsedUrl, headers);
|
|
// Only perform retries on reads since writes may not be idempotent.
|
|
const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb)
|
|
? this._maxRetries + 1
|
|
: 1;
|
|
let numTries = 0;
|
|
let response;
|
|
do {
|
|
response = yield this.requestRaw(info, data);
|
|
// Check if it's an authentication challenge
|
|
if (response &&
|
|
response.message &&
|
|
response.message.statusCode === HttpCodes.Unauthorized) {
|
|
let authenticationHandler;
|
|
for (const handler of this.handlers) {
|
|
if (handler.canHandleAuthentication(response)) {
|
|
authenticationHandler = handler;
|
|
break;
|
|
}
|
|
}
|
|
if (authenticationHandler) {
|
|
return authenticationHandler.handleAuthentication(this, info, data);
|
|
}
|
|
else {
|
|
// We have received an unauthorized response but have no handlers to handle it.
|
|
// Let the response return to the caller.
|
|
return response;
|
|
}
|
|
}
|
|
let redirectsRemaining = this._maxRedirects;
|
|
while (response.message.statusCode &&
|
|
HttpRedirectCodes.includes(response.message.statusCode) &&
|
|
this._allowRedirects &&
|
|
redirectsRemaining > 0) {
|
|
const redirectUrl = response.message.headers['location'];
|
|
if (!redirectUrl) {
|
|
// if there's no location to redirect to, we won't
|
|
break;
|
|
}
|
|
const parsedRedirectUrl = new URL(redirectUrl);
|
|
if (parsedUrl.protocol === 'https:' &&
|
|
parsedUrl.protocol !== parsedRedirectUrl.protocol &&
|
|
!this._allowRedirectDowngrade) {
|
|
throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.');
|
|
}
|
|
// we need to finish reading the response before reassigning response
|
|
// which will leak the open socket.
|
|
yield response.readBody();
|
|
// strip authorization header if redirected to a different hostname
|
|
if (parsedRedirectUrl.hostname !== parsedUrl.hostname) {
|
|
for (const header in headers) {
|
|
// header names are case insensitive
|
|
if (header.toLowerCase() === 'authorization') {
|
|
delete headers[header];
|
|
}
|
|
}
|
|
}
|
|
// let's make the request with the new redirectUrl
|
|
info = this._prepareRequest(verb, parsedRedirectUrl, headers);
|
|
response = yield this.requestRaw(info, data);
|
|
redirectsRemaining--;
|
|
}
|
|
if (!response.message.statusCode ||
|
|
!HttpResponseRetryCodes.includes(response.message.statusCode)) {
|
|
// If not a retry code, return immediately instead of retrying
|
|
return response;
|
|
}
|
|
numTries += 1;
|
|
if (numTries < maxTries) {
|
|
yield response.readBody();
|
|
yield this._performExponentialBackoff(numTries);
|
|
}
|
|
} while (numTries < maxTries);
|
|
return response;
|
|
});
|
|
}
|
|
/**
|
|
* Needs to be called if keepAlive is set to true in request options.
|
|
*/
|
|
dispose() {
|
|
if (this._agent) {
|
|
this._agent.destroy();
|
|
}
|
|
this._disposed = true;
|
|
}
|
|
/**
|
|
* Raw request.
|
|
* @param info
|
|
* @param data
|
|
*/
|
|
requestRaw(info, data) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve, reject) => {
|
|
function callbackForResult(err, res) {
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
else if (!res) {
|
|
// If `err` is not passed, then `res` must be passed.
|
|
reject(new Error('Unknown error'));
|
|
}
|
|
else {
|
|
resolve(res);
|
|
}
|
|
}
|
|
this.requestRawWithCallback(info, data, callbackForResult);
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Raw request with callback.
|
|
* @param info
|
|
* @param data
|
|
* @param onResult
|
|
*/
|
|
requestRawWithCallback(info, data, onResult) {
|
|
if (typeof data === 'string') {
|
|
if (!info.options.headers) {
|
|
info.options.headers = {};
|
|
}
|
|
info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8');
|
|
}
|
|
let callbackCalled = false;
|
|
function handleResult(err, res) {
|
|
if (!callbackCalled) {
|
|
callbackCalled = true;
|
|
onResult(err, res);
|
|
}
|
|
}
|
|
const req = info.httpModule.request(info.options, (msg) => {
|
|
const res = new HttpClientResponse(msg);
|
|
handleResult(undefined, res);
|
|
});
|
|
let socket;
|
|
req.on('socket', sock => {
|
|
socket = sock;
|
|
});
|
|
// If we ever get disconnected, we want the socket to timeout eventually
|
|
req.setTimeout(this._socketTimeout || 3 * 60000, () => {
|
|
if (socket) {
|
|
socket.end();
|
|
}
|
|
handleResult(new Error(`Request timeout: ${info.options.path}`));
|
|
});
|
|
req.on('error', function (err) {
|
|
// err has statusCode property
|
|
// res should have headers
|
|
handleResult(err);
|
|
});
|
|
if (data && typeof data === 'string') {
|
|
req.write(data, 'utf8');
|
|
}
|
|
if (data && typeof data !== 'string') {
|
|
data.on('close', function () {
|
|
req.end();
|
|
});
|
|
data.pipe(req);
|
|
}
|
|
else {
|
|
req.end();
|
|
}
|
|
}
|
|
/**
|
|
* Gets an http agent. This function is useful when you need an http agent that handles
|
|
* routing through a proxy server - depending upon the url and proxy environment variables.
|
|
* @param serverUrl The server URL where the request will be sent. For example, https://api.github.com
|
|
*/
|
|
getAgent(serverUrl) {
|
|
const parsedUrl = new URL(serverUrl);
|
|
return this._getAgent(parsedUrl);
|
|
}
|
|
getAgentDispatcher(serverUrl) {
|
|
const parsedUrl = new URL(serverUrl);
|
|
const proxyUrl = pm.getProxyUrl(parsedUrl);
|
|
const useProxy = proxyUrl && proxyUrl.hostname;
|
|
if (!useProxy) {
|
|
return;
|
|
}
|
|
return this._getProxyAgentDispatcher(parsedUrl, proxyUrl);
|
|
}
|
|
_prepareRequest(method, requestUrl, headers) {
|
|
const info = {};
|
|
info.parsedUrl = requestUrl;
|
|
const usingSsl = info.parsedUrl.protocol === 'https:';
|
|
info.httpModule = usingSsl ? https : http;
|
|
const defaultPort = usingSsl ? 443 : 80;
|
|
info.options = {};
|
|
info.options.host = info.parsedUrl.hostname;
|
|
info.options.port = info.parsedUrl.port
|
|
? parseInt(info.parsedUrl.port)
|
|
: defaultPort;
|
|
info.options.path =
|
|
(info.parsedUrl.pathname || '') + (info.parsedUrl.search || '');
|
|
info.options.method = method;
|
|
info.options.headers = this._mergeHeaders(headers);
|
|
if (this.userAgent != null) {
|
|
info.options.headers['user-agent'] = this.userAgent;
|
|
}
|
|
info.options.agent = this._getAgent(info.parsedUrl);
|
|
// gives handlers an opportunity to participate
|
|
if (this.handlers) {
|
|
for (const handler of this.handlers) {
|
|
handler.prepareRequest(info.options);
|
|
}
|
|
}
|
|
return info;
|
|
}
|
|
_mergeHeaders(headers) {
|
|
if (this.requestOptions && this.requestOptions.headers) {
|
|
return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {}));
|
|
}
|
|
return lowercaseKeys(headers || {});
|
|
}
|
|
/**
|
|
* Gets an existing header value or returns a default.
|
|
* Handles converting number header values to strings since HTTP headers must be strings.
|
|
* Note: This returns string | string[] since some headers can have multiple values.
|
|
* For headers that must always be a single string (like Content-Type), use the
|
|
* specialized _getExistingOrDefaultContentTypeHeader method instead.
|
|
*/
|
|
_getExistingOrDefaultHeader(additionalHeaders, header, _default) {
|
|
let clientHeader;
|
|
if (this.requestOptions && this.requestOptions.headers) {
|
|
const headerValue = lowercaseKeys(this.requestOptions.headers)[header];
|
|
if (headerValue) {
|
|
clientHeader =
|
|
typeof headerValue === 'number' ? headerValue.toString() : headerValue;
|
|
}
|
|
}
|
|
const additionalValue = additionalHeaders[header];
|
|
if (additionalValue !== undefined) {
|
|
return typeof additionalValue === 'number'
|
|
? additionalValue.toString()
|
|
: additionalValue;
|
|
}
|
|
if (clientHeader !== undefined) {
|
|
return clientHeader;
|
|
}
|
|
return _default;
|
|
}
|
|
/**
|
|
* Specialized version of _getExistingOrDefaultHeader for Content-Type header.
|
|
* Always returns a single string (not an array) since Content-Type should be a single value.
|
|
* Converts arrays to comma-separated strings and numbers to strings to ensure type safety.
|
|
* This was split from _getExistingOrDefaultHeader to provide stricter typing for callers
|
|
* that assign the result to places expecting a string (e.g., additionalHeaders[Headers.ContentType]).
|
|
*/
|
|
_getExistingOrDefaultContentTypeHeader(additionalHeaders, _default) {
|
|
let clientHeader;
|
|
if (this.requestOptions && this.requestOptions.headers) {
|
|
const headerValue = lowercaseKeys(this.requestOptions.headers)[Headers.ContentType];
|
|
if (headerValue) {
|
|
if (typeof headerValue === 'number') {
|
|
clientHeader = String(headerValue);
|
|
}
|
|
else if (Array.isArray(headerValue)) {
|
|
clientHeader = headerValue.join(', ');
|
|
}
|
|
else {
|
|
clientHeader = headerValue;
|
|
}
|
|
}
|
|
}
|
|
const additionalValue = additionalHeaders[Headers.ContentType];
|
|
// Return the first non-undefined value, converting numbers or arrays to strings if necessary
|
|
if (additionalValue !== undefined) {
|
|
if (typeof additionalValue === 'number') {
|
|
return String(additionalValue);
|
|
}
|
|
else if (Array.isArray(additionalValue)) {
|
|
return additionalValue.join(', ');
|
|
}
|
|
else {
|
|
return additionalValue;
|
|
}
|
|
}
|
|
if (clientHeader !== undefined) {
|
|
return clientHeader;
|
|
}
|
|
return _default;
|
|
}
|
|
_getAgent(parsedUrl) {
|
|
let agent;
|
|
const proxyUrl = pm.getProxyUrl(parsedUrl);
|
|
const useProxy = proxyUrl && proxyUrl.hostname;
|
|
if (this._keepAlive && useProxy) {
|
|
agent = this._proxyAgent;
|
|
}
|
|
if (!useProxy) {
|
|
agent = this._agent;
|
|
}
|
|
// if agent is already assigned use that agent.
|
|
if (agent) {
|
|
return agent;
|
|
}
|
|
const usingSsl = parsedUrl.protocol === 'https:';
|
|
let maxSockets = 100;
|
|
if (this.requestOptions) {
|
|
maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets;
|
|
}
|
|
// This is `useProxy` again, but we need to check `proxyURl` directly for TypeScripts's flow analysis.
|
|
if (proxyUrl && proxyUrl.hostname) {
|
|
const agentOptions = {
|
|
maxSockets,
|
|
keepAlive: this._keepAlive,
|
|
proxy: Object.assign(Object.assign({}, ((proxyUrl.username || proxyUrl.password) && {
|
|
proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`
|
|
})), { host: proxyUrl.hostname, port: proxyUrl.port })
|
|
};
|
|
let tunnelAgent;
|
|
const overHttps = proxyUrl.protocol === 'https:';
|
|
if (usingSsl) {
|
|
tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp;
|
|
}
|
|
else {
|
|
tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp;
|
|
}
|
|
agent = tunnelAgent(agentOptions);
|
|
this._proxyAgent = agent;
|
|
}
|
|
// if tunneling agent isn't assigned create a new agent
|
|
if (!agent) {
|
|
const options = { keepAlive: this._keepAlive, maxSockets };
|
|
agent = usingSsl ? new https.Agent(options) : new http.Agent(options);
|
|
this._agent = agent;
|
|
}
|
|
if (usingSsl && this._ignoreSslError) {
|
|
// we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process
|
|
// http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options
|
|
// we have to cast it to any and change it directly
|
|
agent.options = Object.assign(agent.options || {}, {
|
|
rejectUnauthorized: false
|
|
});
|
|
}
|
|
return agent;
|
|
}
|
|
_getProxyAgentDispatcher(parsedUrl, proxyUrl) {
|
|
let proxyAgent;
|
|
if (this._keepAlive) {
|
|
proxyAgent = this._proxyAgentDispatcher;
|
|
}
|
|
// if agent is already assigned use that agent.
|
|
if (proxyAgent) {
|
|
return proxyAgent;
|
|
}
|
|
const usingSsl = parsedUrl.protocol === 'https:';
|
|
proxyAgent = new undici_1.ProxyAgent(Object.assign({ uri: proxyUrl.href, pipelining: !this._keepAlive ? 0 : 1 }, ((proxyUrl.username || proxyUrl.password) && {
|
|
token: `Basic ${Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`).toString('base64')}`
|
|
})));
|
|
this._proxyAgentDispatcher = proxyAgent;
|
|
if (usingSsl && this._ignoreSslError) {
|
|
// we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process
|
|
// http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options
|
|
// we have to cast it to any and change it directly
|
|
proxyAgent.options = Object.assign(proxyAgent.options.requestTls || {}, {
|
|
rejectUnauthorized: false
|
|
});
|
|
}
|
|
return proxyAgent;
|
|
}
|
|
_getUserAgentWithOrchestrationId(userAgent) {
|
|
const baseUserAgent = userAgent || 'actions/http-client';
|
|
const orchId = process.env['ACTIONS_ORCHESTRATION_ID'];
|
|
if (orchId) {
|
|
// Sanitize the orchestration ID to ensure it contains only valid characters
|
|
// Valid characters: 0-9, a-z, _, -, .
|
|
const sanitizedId = orchId.replace(/[^a-z0-9_.-]/gi, '_');
|
|
return `${baseUserAgent} actions_orchestration_id/${sanitizedId}`;
|
|
}
|
|
return baseUserAgent;
|
|
}
|
|
_performExponentialBackoff(retryNumber) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
|
|
const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
|
|
return new Promise(resolve => setTimeout(() => resolve(), ms));
|
|
});
|
|
}
|
|
_processResponse(res, options) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
|
|
const statusCode = res.message.statusCode || 0;
|
|
const response = {
|
|
statusCode,
|
|
result: null,
|
|
headers: {}
|
|
};
|
|
// not found leads to null obj returned
|
|
if (statusCode === HttpCodes.NotFound) {
|
|
resolve(response);
|
|
}
|
|
// get the result from the body
|
|
function dateTimeDeserializer(key, value) {
|
|
if (typeof value === 'string') {
|
|
const a = new Date(value);
|
|
if (!isNaN(a.valueOf())) {
|
|
return a;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
let obj;
|
|
let contents;
|
|
try {
|
|
contents = yield res.readBody();
|
|
if (contents && contents.length > 0) {
|
|
if (options && options.deserializeDates) {
|
|
obj = JSON.parse(contents, dateTimeDeserializer);
|
|
}
|
|
else {
|
|
obj = JSON.parse(contents);
|
|
}
|
|
response.result = obj;
|
|
}
|
|
response.headers = res.message.headers;
|
|
}
|
|
catch (err) {
|
|
// Invalid resource (contents not json); leaving result obj null
|
|
}
|
|
// note that 3xx redirects are handled by the http layer.
|
|
if (statusCode > 299) {
|
|
let msg;
|
|
// if exception/error in body, attempt to get better error
|
|
if (obj && obj.message) {
|
|
msg = obj.message;
|
|
}
|
|
else if (contents && contents.length > 0) {
|
|
// it may be the case that the exception is in the body message as string
|
|
msg = contents;
|
|
}
|
|
else {
|
|
msg = `Failed request: (${statusCode})`;
|
|
}
|
|
const err = new HttpClientError(msg, statusCode);
|
|
err.result = response.result;
|
|
reject(err);
|
|
}
|
|
else {
|
|
resolve(response);
|
|
}
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
exports.HttpClient = HttpClient;
|
|
const lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {});
|
|
//# sourceMappingURL=index.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3335:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.getProxyUrl = getProxyUrl;
|
|
exports.checkBypass = checkBypass;
|
|
function getProxyUrl(reqUrl) {
|
|
const usingSsl = reqUrl.protocol === 'https:';
|
|
if (checkBypass(reqUrl)) {
|
|
return undefined;
|
|
}
|
|
const proxyVar = (() => {
|
|
if (usingSsl) {
|
|
return process.env['https_proxy'] || process.env['HTTPS_PROXY'];
|
|
}
|
|
else {
|
|
return process.env['http_proxy'] || process.env['HTTP_PROXY'];
|
|
}
|
|
})();
|
|
if (proxyVar) {
|
|
try {
|
|
return new DecodedURL(proxyVar);
|
|
}
|
|
catch (_a) {
|
|
if (!proxyVar.startsWith('http://') && !proxyVar.startsWith('https://'))
|
|
return new DecodedURL(`http://${proxyVar}`);
|
|
}
|
|
}
|
|
else {
|
|
return undefined;
|
|
}
|
|
}
|
|
function checkBypass(reqUrl) {
|
|
if (!reqUrl.hostname) {
|
|
return false;
|
|
}
|
|
const reqHost = reqUrl.hostname;
|
|
if (isLoopbackAddress(reqHost)) {
|
|
return true;
|
|
}
|
|
const noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || '';
|
|
if (!noProxy) {
|
|
return false;
|
|
}
|
|
// Determine the request port
|
|
let reqPort;
|
|
if (reqUrl.port) {
|
|
reqPort = Number(reqUrl.port);
|
|
}
|
|
else if (reqUrl.protocol === 'http:') {
|
|
reqPort = 80;
|
|
}
|
|
else if (reqUrl.protocol === 'https:') {
|
|
reqPort = 443;
|
|
}
|
|
// Format the request hostname and hostname with port
|
|
const upperReqHosts = [reqUrl.hostname.toUpperCase()];
|
|
if (typeof reqPort === 'number') {
|
|
upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`);
|
|
}
|
|
// Compare request host against noproxy
|
|
for (const upperNoProxyItem of noProxy
|
|
.split(',')
|
|
.map(x => x.trim().toUpperCase())
|
|
.filter(x => x)) {
|
|
if (upperNoProxyItem === '*' ||
|
|
upperReqHosts.some(x => x === upperNoProxyItem ||
|
|
x.endsWith(`.${upperNoProxyItem}`) ||
|
|
(upperNoProxyItem.startsWith('.') &&
|
|
x.endsWith(`${upperNoProxyItem}`)))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isLoopbackAddress(host) {
|
|
const hostLower = host.toLowerCase();
|
|
return (hostLower === 'localhost' ||
|
|
hostLower.startsWith('127.') ||
|
|
hostLower.startsWith('[::1]') ||
|
|
hostLower.startsWith('[0:0:0:0:0:0:0:1]'));
|
|
}
|
|
class DecodedURL extends URL {
|
|
constructor(url, base) {
|
|
super(url, base);
|
|
this._decodedUsername = decodeURIComponent(super.username);
|
|
this._decodedPassword = decodeURIComponent(super.password);
|
|
}
|
|
get username() {
|
|
return this._decodedUsername;
|
|
}
|
|
get password() {
|
|
return this._decodedPassword;
|
|
}
|
|
}
|
|
//# sourceMappingURL=proxy.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7712:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const ANY = Symbol('SemVer ANY')
|
|
// hoisted class for cyclic dependency
|
|
class Comparator {
|
|
static get ANY () {
|
|
return ANY
|
|
}
|
|
|
|
constructor (comp, options) {
|
|
options = parseOptions(options)
|
|
|
|
if (comp instanceof Comparator) {
|
|
if (comp.loose === !!options.loose) {
|
|
return comp
|
|
} else {
|
|
comp = comp.value
|
|
}
|
|
}
|
|
|
|
comp = comp.trim().split(/\s+/).join(' ')
|
|
debug('comparator', comp, options)
|
|
this.options = options
|
|
this.loose = !!options.loose
|
|
this.parse(comp)
|
|
|
|
if (this.semver === ANY) {
|
|
this.value = ''
|
|
} else {
|
|
this.value = this.operator + this.semver.version
|
|
}
|
|
|
|
debug('comp', this)
|
|
}
|
|
|
|
parse (comp) {
|
|
const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
|
|
const m = comp.match(r)
|
|
|
|
if (!m) {
|
|
throw new TypeError(`Invalid comparator: ${comp}`)
|
|
}
|
|
|
|
this.operator = m[1] !== undefined ? m[1] : ''
|
|
if (this.operator === '=') {
|
|
this.operator = ''
|
|
}
|
|
|
|
// if it literally is just '>' or '' then allow anything.
|
|
if (!m[2]) {
|
|
this.semver = ANY
|
|
} else {
|
|
this.semver = new SemVer(m[2], this.options.loose)
|
|
}
|
|
}
|
|
|
|
toString () {
|
|
return this.value
|
|
}
|
|
|
|
test (version) {
|
|
debug('Comparator.test', version, this.options.loose)
|
|
|
|
if (this.semver === ANY || version === ANY) {
|
|
return true
|
|
}
|
|
|
|
if (typeof version === 'string') {
|
|
try {
|
|
version = new SemVer(version, this.options)
|
|
} catch (er) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return cmp(version, this.operator, this.semver, this.options)
|
|
}
|
|
|
|
intersects (comp, options) {
|
|
if (!(comp instanceof Comparator)) {
|
|
throw new TypeError('a Comparator is required')
|
|
}
|
|
|
|
if (this.operator === '') {
|
|
if (this.value === '') {
|
|
return true
|
|
}
|
|
return new Range(comp.value, options).test(this.value)
|
|
} else if (comp.operator === '') {
|
|
if (comp.value === '') {
|
|
return true
|
|
}
|
|
return new Range(this.value, options).test(comp.semver)
|
|
}
|
|
|
|
options = parseOptions(options)
|
|
|
|
// Special cases where nothing can possibly be lower
|
|
if (options.includePrerelease &&
|
|
(this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
|
|
return false
|
|
}
|
|
if (!options.includePrerelease &&
|
|
(this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
|
|
return false
|
|
}
|
|
|
|
// Same direction increasing (> or >=)
|
|
if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
|
|
return true
|
|
}
|
|
// Same direction decreasing (< or <=)
|
|
if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
|
|
return true
|
|
}
|
|
// same SemVer and both sides are inclusive (<= or >=)
|
|
if (
|
|
(this.semver.version === comp.semver.version) &&
|
|
this.operator.includes('=') && comp.operator.includes('=')) {
|
|
return true
|
|
}
|
|
// opposite directions less than
|
|
if (cmp(this.semver, '<', comp.semver, options) &&
|
|
this.operator.startsWith('>') && comp.operator.startsWith('<')) {
|
|
return true
|
|
}
|
|
// opposite directions greater than
|
|
if (cmp(this.semver, '>', comp.semver, options) &&
|
|
this.operator.startsWith('<') && comp.operator.startsWith('>')) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
|
|
module.exports = Comparator
|
|
|
|
const parseOptions = __nccwpck_require__(5131)
|
|
const { safeRe: re, t } = __nccwpck_require__(6102)
|
|
const cmp = __nccwpck_require__(9647)
|
|
const debug = __nccwpck_require__(1736)
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const Range = __nccwpck_require__(4535)
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4535:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SPACE_CHARACTERS = /\s+/g
|
|
|
|
// hoisted class for cyclic dependency
|
|
class Range {
|
|
constructor (range, options) {
|
|
options = parseOptions(options)
|
|
|
|
if (range instanceof Range) {
|
|
if (
|
|
range.loose === !!options.loose &&
|
|
range.includePrerelease === !!options.includePrerelease
|
|
) {
|
|
return range
|
|
} else {
|
|
return new Range(range.raw, options)
|
|
}
|
|
}
|
|
|
|
if (range instanceof Comparator) {
|
|
// just put it in the set and return
|
|
this.raw = range.value
|
|
this.set = [[range]]
|
|
this.formatted = undefined
|
|
return this
|
|
}
|
|
|
|
this.options = options
|
|
this.loose = !!options.loose
|
|
this.includePrerelease = !!options.includePrerelease
|
|
|
|
// First reduce all whitespace as much as possible so we do not have to rely
|
|
// on potentially slow regexes like \s*. This is then stored and used for
|
|
// future error messages as well.
|
|
this.raw = range.trim().replace(SPACE_CHARACTERS, ' ')
|
|
|
|
// First, split on ||
|
|
this.set = this.raw
|
|
.split('||')
|
|
// map the range to a 2d array of comparators
|
|
.map(r => this.parseRange(r.trim()))
|
|
// throw out any comparator lists that are empty
|
|
// this generally means that it was not a valid range, which is allowed
|
|
// in loose mode, but will still throw if the WHOLE range is invalid.
|
|
.filter(c => c.length)
|
|
|
|
if (!this.set.length) {
|
|
throw new TypeError(`Invalid SemVer Range: ${this.raw}`)
|
|
}
|
|
|
|
// if we have any that are not the null set, throw out null sets.
|
|
if (this.set.length > 1) {
|
|
// keep the first one, in case they're all null sets
|
|
const first = this.set[0]
|
|
this.set = this.set.filter(c => !isNullSet(c[0]))
|
|
if (this.set.length === 0) {
|
|
this.set = [first]
|
|
} else if (this.set.length > 1) {
|
|
// if we have any that are *, then the range is just *
|
|
for (const c of this.set) {
|
|
if (c.length === 1 && isAny(c[0])) {
|
|
this.set = [c]
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
this.formatted = undefined
|
|
}
|
|
|
|
get range () {
|
|
if (this.formatted === undefined) {
|
|
this.formatted = ''
|
|
for (let i = 0; i < this.set.length; i++) {
|
|
if (i > 0) {
|
|
this.formatted += '||'
|
|
}
|
|
const comps = this.set[i]
|
|
for (let k = 0; k < comps.length; k++) {
|
|
if (k > 0) {
|
|
this.formatted += ' '
|
|
}
|
|
this.formatted += comps[k].toString().trim()
|
|
}
|
|
}
|
|
}
|
|
return this.formatted
|
|
}
|
|
|
|
format () {
|
|
return this.range
|
|
}
|
|
|
|
toString () {
|
|
return this.range
|
|
}
|
|
|
|
parseRange (range) {
|
|
// strip build metadata so it can't bleed into the version
|
|
range = range.replace(BUILDSTRIPRE, '')
|
|
|
|
// memoize range parsing for performance.
|
|
// this is a very hot path, and fully deterministic.
|
|
const memoOpts =
|
|
(this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |
|
|
(this.options.loose && FLAG_LOOSE)
|
|
const memoKey = memoOpts + ':' + range
|
|
const cached = cache.get(memoKey)
|
|
if (cached) {
|
|
return cached
|
|
}
|
|
|
|
const loose = this.options.loose
|
|
// `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
|
|
const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
|
|
range = range.replace(hr, hyphenReplace(this.options.includePrerelease))
|
|
debug('hyphen replace', range)
|
|
|
|
// `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
|
|
range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
|
|
debug('comparator trim', range)
|
|
|
|
// `~ 1.2.3` => `~1.2.3`
|
|
range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
|
|
debug('tilde trim', range)
|
|
|
|
// `^ 1.2.3` => `^1.2.3`
|
|
range = range.replace(re[t.CARETTRIM], caretTrimReplace)
|
|
debug('caret trim', range)
|
|
|
|
// At this point, the range is completely trimmed and
|
|
// ready to be split into comparators.
|
|
|
|
let rangeList = range
|
|
.split(' ')
|
|
.map(comp => parseComparator(comp, this.options))
|
|
.join(' ')
|
|
.split(/\s+/)
|
|
// >=0.0.0 is equivalent to *
|
|
.map(comp => replaceGTE0(comp, this.options))
|
|
|
|
if (loose) {
|
|
// in loose mode, throw out any that are not valid comparators
|
|
rangeList = rangeList.filter(comp => {
|
|
debug('loose invalid filter', comp, this.options)
|
|
return !!comp.match(re[t.COMPARATORLOOSE])
|
|
})
|
|
}
|
|
debug('range list', rangeList)
|
|
|
|
// if any comparators are the null set, then replace with JUST null set
|
|
// if more than one comparator, remove any * comparators
|
|
// also, don't include the same comparator more than once
|
|
const rangeMap = new Map()
|
|
const comparators = rangeList.map(comp => new Comparator(comp, this.options))
|
|
for (const comp of comparators) {
|
|
if (isNullSet(comp)) {
|
|
return [comp]
|
|
}
|
|
rangeMap.set(comp.value, comp)
|
|
}
|
|
if (rangeMap.size > 1 && rangeMap.has('')) {
|
|
rangeMap.delete('')
|
|
}
|
|
|
|
const result = [...rangeMap.values()]
|
|
cache.set(memoKey, result)
|
|
return result
|
|
}
|
|
|
|
intersects (range, options) {
|
|
if (!(range instanceof Range)) {
|
|
throw new TypeError('a Range is required')
|
|
}
|
|
|
|
return this.set.some((thisComparators) => {
|
|
return (
|
|
isSatisfiable(thisComparators, options) &&
|
|
range.set.some((rangeComparators) => {
|
|
return (
|
|
isSatisfiable(rangeComparators, options) &&
|
|
thisComparators.every((thisComparator) => {
|
|
return rangeComparators.every((rangeComparator) => {
|
|
return thisComparator.intersects(rangeComparator, options)
|
|
})
|
|
})
|
|
)
|
|
})
|
|
)
|
|
})
|
|
}
|
|
|
|
// if ANY of the sets match ALL of its comparators, then pass
|
|
test (version) {
|
|
if (!version) {
|
|
return false
|
|
}
|
|
|
|
if (typeof version === 'string') {
|
|
try {
|
|
version = new SemVer(version, this.options)
|
|
} catch (er) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
for (let i = 0; i < this.set.length; i++) {
|
|
if (testSet(this.set[i], version, this.options)) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
|
|
module.exports = Range
|
|
|
|
const LRU = __nccwpck_require__(1018)
|
|
const cache = new LRU()
|
|
|
|
const parseOptions = __nccwpck_require__(5131)
|
|
const Comparator = __nccwpck_require__(7712)
|
|
const debug = __nccwpck_require__(1736)
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const {
|
|
safeRe: re,
|
|
src,
|
|
t,
|
|
comparatorTrimReplace,
|
|
tildeTrimReplace,
|
|
caretTrimReplace,
|
|
} = __nccwpck_require__(6102)
|
|
const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = __nccwpck_require__(9962)
|
|
|
|
// unbounded global build-metadata stripper used by parseRange
|
|
const BUILDSTRIPRE = new RegExp(src[t.BUILD], 'g')
|
|
|
|
const isNullSet = c => c.value === '<0.0.0-0'
|
|
const isAny = c => c.value === ''
|
|
|
|
// take a set of comparators and determine whether there
|
|
// exists a version which can satisfy it
|
|
const isSatisfiable = (comparators, options) => {
|
|
let result = true
|
|
const remainingComparators = comparators.slice()
|
|
let testComparator = remainingComparators.pop()
|
|
|
|
while (result && remainingComparators.length) {
|
|
result = remainingComparators.every((otherComparator) => {
|
|
return testComparator.intersects(otherComparator, options)
|
|
})
|
|
|
|
testComparator = remainingComparators.pop()
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// comprised of xranges, tildes, stars, and gtlt's at this point.
|
|
// already replaced the hyphen ranges
|
|
// turn into a set of JUST comparators.
|
|
const parseComparator = (comp, options) => {
|
|
comp = comp.replace(re[t.BUILD], '')
|
|
debug('comp', comp, options)
|
|
comp = replaceCarets(comp, options)
|
|
debug('caret', comp)
|
|
comp = replaceTildes(comp, options)
|
|
debug('tildes', comp)
|
|
comp = replaceXRanges(comp, options)
|
|
debug('xrange', comp)
|
|
comp = replaceStars(comp, options)
|
|
debug('stars', comp)
|
|
return comp
|
|
}
|
|
|
|
const isX = id => !id || id.toLowerCase() === 'x' || id === '*'
|
|
|
|
const invalidXRangeOrder = (M, m, p) => (
|
|
(isX(M) && !isX(m)) ||
|
|
(isX(m) && p && !isX(p))
|
|
)
|
|
|
|
// ~, ~> --> * (any, kinda silly)
|
|
// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
|
|
// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
|
|
// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
|
|
// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
|
|
// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
|
|
// ~0.0.1 --> >=0.0.1 <0.1.0-0
|
|
const replaceTildes = (comp, options) => {
|
|
return comp
|
|
.trim()
|
|
.split(/\s+/)
|
|
.map((c) => replaceTilde(c, options))
|
|
.join(' ')
|
|
}
|
|
|
|
const replaceTilde = (comp, options) => {
|
|
const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
|
|
return comp.replace(r, (_, M, m, p, pr) => {
|
|
debug('tilde', comp, _, M, m, p, pr)
|
|
let ret
|
|
|
|
if (isX(M)) {
|
|
ret = ''
|
|
} else if (isX(m)) {
|
|
ret = `>=${M}.0.0 <${+M + 1}.0.0-0`
|
|
} else if (isX(p)) {
|
|
// ~1.2 == >=1.2.0 <1.3.0-0
|
|
ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`
|
|
} else if (pr) {
|
|
debug('replaceTilde pr', pr)
|
|
ret = `>=${M}.${m}.${p}-${pr
|
|
} <${M}.${+m + 1}.0-0`
|
|
} else {
|
|
// ~1.2.3 == >=1.2.3 <1.3.0-0
|
|
ret = `>=${M}.${m}.${p
|
|
} <${M}.${+m + 1}.0-0`
|
|
}
|
|
|
|
debug('tilde return', ret)
|
|
return ret
|
|
})
|
|
}
|
|
|
|
// ^ --> * (any, kinda silly)
|
|
// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
|
|
// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
|
|
// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
|
|
// ^1.2.3 --> >=1.2.3 <2.0.0-0
|
|
// ^1.2.0 --> >=1.2.0 <2.0.0-0
|
|
// ^0.0.1 --> >=0.0.1 <0.0.2-0
|
|
// ^0.1.0 --> >=0.1.0 <0.2.0-0
|
|
const replaceCarets = (comp, options) => {
|
|
return comp
|
|
.trim()
|
|
.split(/\s+/)
|
|
.map((c) => replaceCaret(c, options))
|
|
.join(' ')
|
|
}
|
|
|
|
const replaceCaret = (comp, options) => {
|
|
debug('caret', comp, options)
|
|
const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
|
|
const z = options.includePrerelease ? '-0' : ''
|
|
return comp.replace(r, (_, M, m, p, pr) => {
|
|
debug('caret', comp, _, M, m, p, pr)
|
|
let ret
|
|
|
|
if (isX(M)) {
|
|
ret = ''
|
|
} else if (isX(m)) {
|
|
ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`
|
|
} else if (isX(p)) {
|
|
if (M === '0') {
|
|
ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`
|
|
} else {
|
|
ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`
|
|
}
|
|
} else if (pr) {
|
|
debug('replaceCaret pr', pr)
|
|
if (M === '0') {
|
|
if (m === '0') {
|
|
ret = `>=${M}.${m}.${p}-${pr
|
|
} <${M}.${m}.${+p + 1}-0`
|
|
} else {
|
|
ret = `>=${M}.${m}.${p}-${pr
|
|
} <${M}.${+m + 1}.0-0`
|
|
}
|
|
} else {
|
|
ret = `>=${M}.${m}.${p}-${pr
|
|
} <${+M + 1}.0.0-0`
|
|
}
|
|
} else {
|
|
debug('no pr')
|
|
if (M === '0') {
|
|
if (m === '0') {
|
|
ret = `>=${M}.${m}.${p
|
|
} <${M}.${m}.${+p + 1}-0`
|
|
} else {
|
|
ret = `>=${M}.${m}.${p
|
|
} <${M}.${+m + 1}.0-0`
|
|
}
|
|
} else {
|
|
ret = `>=${M}.${m}.${p
|
|
} <${+M + 1}.0.0-0`
|
|
}
|
|
}
|
|
|
|
debug('caret return', ret)
|
|
return ret
|
|
})
|
|
}
|
|
|
|
const replaceXRanges = (comp, options) => {
|
|
debug('replaceXRanges', comp, options)
|
|
return comp
|
|
.split(/\s+/)
|
|
.map((c) => replaceXRange(c, options))
|
|
.join(' ')
|
|
}
|
|
|
|
const replaceXRange = (comp, options) => {
|
|
comp = comp.trim()
|
|
const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
|
|
return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
|
|
debug('xRange', comp, ret, gtlt, M, m, p, pr)
|
|
if (invalidXRangeOrder(M, m, p)) {
|
|
return comp
|
|
}
|
|
|
|
const xM = isX(M)
|
|
const xm = xM || isX(m)
|
|
const xp = xm || isX(p)
|
|
const anyX = xp
|
|
|
|
if (gtlt === '=' && anyX) {
|
|
gtlt = ''
|
|
}
|
|
|
|
// if we're including prereleases in the match, then we need
|
|
// to fix this to -0, the lowest possible prerelease value
|
|
pr = options.includePrerelease ? '-0' : ''
|
|
|
|
if (xM) {
|
|
if (gtlt === '>' || gtlt === '<') {
|
|
// nothing is allowed
|
|
ret = '<0.0.0-0'
|
|
} else {
|
|
// nothing is forbidden
|
|
ret = '*'
|
|
}
|
|
} else if (gtlt && anyX) {
|
|
// we know patch is an x, because we have any x at all.
|
|
// replace X with 0
|
|
if (xm) {
|
|
m = 0
|
|
}
|
|
p = 0
|
|
|
|
if (gtlt === '>') {
|
|
// >1 => >=2.0.0
|
|
// >1.2 => >=1.3.0
|
|
gtlt = '>='
|
|
if (xm) {
|
|
M = +M + 1
|
|
m = 0
|
|
p = 0
|
|
} else {
|
|
m = +m + 1
|
|
p = 0
|
|
}
|
|
} else if (gtlt === '<=') {
|
|
// <=0.7.x is actually <0.8.0, since any 0.7.x should
|
|
// pass. Similarly, <=7.x is actually <8.0.0, etc.
|
|
gtlt = '<'
|
|
if (xm) {
|
|
M = +M + 1
|
|
} else {
|
|
m = +m + 1
|
|
}
|
|
}
|
|
|
|
if (gtlt === '<') {
|
|
pr = '-0'
|
|
}
|
|
|
|
ret = `${gtlt + M}.${m}.${p}${pr}`
|
|
} else if (xm) {
|
|
ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`
|
|
} else if (xp) {
|
|
ret = `>=${M}.${m}.0${pr
|
|
} <${M}.${+m + 1}.0-0`
|
|
}
|
|
|
|
debug('xRange return', ret)
|
|
|
|
return ret
|
|
})
|
|
}
|
|
|
|
// Because * is AND-ed with everything else in the comparator,
|
|
// and '' means "any version", just remove the *s entirely.
|
|
const replaceStars = (comp, options) => {
|
|
debug('replaceStars', comp, options)
|
|
// Looseness is ignored here. star is always as loose as it gets!
|
|
return comp
|
|
.trim()
|
|
.replace(re[t.STAR], '')
|
|
}
|
|
|
|
const replaceGTE0 = (comp, options) => {
|
|
debug('replaceGTE0', comp, options)
|
|
return comp
|
|
.trim()
|
|
.replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
|
|
}
|
|
|
|
// This function is passed to string.replace(re[t.HYPHENRANGE])
|
|
// M, m, patch, prerelease, build
|
|
// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
|
|
// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
|
|
// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
|
|
// TODO build?
|
|
const hyphenReplace = incPr => ($0,
|
|
from, fM, fm, fp, fpr, fb,
|
|
to, tM, tm, tp, tpr) => {
|
|
if (isX(fM)) {
|
|
from = ''
|
|
} else if (isX(fm)) {
|
|
from = `>=${fM}.0.0${incPr ? '-0' : ''}`
|
|
} else if (isX(fp)) {
|
|
from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`
|
|
} else if (fpr) {
|
|
from = `>=${from}`
|
|
} else {
|
|
from = `>=${from}${incPr ? '-0' : ''}`
|
|
}
|
|
|
|
if (isX(tM)) {
|
|
to = ''
|
|
} else if (isX(tm)) {
|
|
to = `<${+tM + 1}.0.0-0`
|
|
} else if (isX(tp)) {
|
|
to = `<${tM}.${+tm + 1}.0-0`
|
|
} else if (tpr) {
|
|
to = `<=${tM}.${tm}.${tp}-${tpr}`
|
|
} else if (incPr) {
|
|
to = `<${tM}.${tm}.${+tp + 1}-0`
|
|
} else {
|
|
to = `<=${to}`
|
|
}
|
|
|
|
return `${from} ${to}`.trim()
|
|
}
|
|
|
|
const testSet = (set, version, options) => {
|
|
for (let i = 0; i < set.length; i++) {
|
|
if (!set[i].test(version)) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
if (version.prerelease.length && !options.includePrerelease) {
|
|
// Find the set of versions that are allowed to have prereleases
|
|
// For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
|
|
// That should allow `1.2.3-pr.2` to pass.
|
|
// However, `1.2.4-alpha.notready` should NOT be allowed,
|
|
// even though it's within the range set by the comparators.
|
|
for (let i = 0; i < set.length; i++) {
|
|
debug(set[i].semver)
|
|
if (set[i].semver === Comparator.ANY) {
|
|
continue
|
|
}
|
|
|
|
if (set[i].semver.prerelease.length > 0) {
|
|
const allowed = set[i].semver
|
|
if (allowed.major === version.major &&
|
|
allowed.minor === version.minor &&
|
|
allowed.patch === version.patch) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
// Version has a -pre, but it's not one of the ones we like.
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6644:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const debug = __nccwpck_require__(1736)
|
|
const { MAX_LENGTH, MAX_SAFE_INTEGER } = __nccwpck_require__(9962)
|
|
const { safeRe: re, t } = __nccwpck_require__(6102)
|
|
|
|
const parseOptions = __nccwpck_require__(5131)
|
|
const { compareIdentifiers } = __nccwpck_require__(3411)
|
|
|
|
const isPrereleaseIdentifier = (prerelease, identifier) => {
|
|
const identifiers = identifier.split('.')
|
|
if (identifiers.length > prerelease.length) {
|
|
return false
|
|
}
|
|
|
|
for (let i = 0; i < identifiers.length; i++) {
|
|
if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
class SemVer {
|
|
constructor (version, options) {
|
|
options = parseOptions(options)
|
|
|
|
if (version instanceof SemVer) {
|
|
if (version.loose === !!options.loose &&
|
|
version.includePrerelease === !!options.includePrerelease) {
|
|
return version
|
|
} else {
|
|
version = version.version
|
|
}
|
|
} else if (typeof version !== 'string') {
|
|
throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
|
|
}
|
|
|
|
if (version.length > MAX_LENGTH) {
|
|
throw new TypeError(
|
|
`version is longer than ${MAX_LENGTH} characters`
|
|
)
|
|
}
|
|
|
|
debug('SemVer', version, options)
|
|
this.options = options
|
|
this.loose = !!options.loose
|
|
// this isn't actually relevant for versions, but keep it so that we
|
|
// don't run into trouble passing this.options around.
|
|
this.includePrerelease = !!options.includePrerelease
|
|
|
|
const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
|
|
|
|
if (!m) {
|
|
throw new TypeError(`Invalid Version: ${version}`)
|
|
}
|
|
|
|
this.raw = version
|
|
|
|
// these are actually numbers
|
|
this.major = +m[1]
|
|
this.minor = +m[2]
|
|
this.patch = +m[3]
|
|
|
|
if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
|
|
throw new TypeError('Invalid major version')
|
|
}
|
|
|
|
if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
|
|
throw new TypeError('Invalid minor version')
|
|
}
|
|
|
|
if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
|
|
throw new TypeError('Invalid patch version')
|
|
}
|
|
|
|
// numberify any prerelease numeric ids
|
|
if (!m[4]) {
|
|
this.prerelease = []
|
|
} else {
|
|
this.prerelease = m[4].split('.').map((id) => {
|
|
if (/^[0-9]+$/.test(id)) {
|
|
const num = +id
|
|
if (num >= 0 && num < MAX_SAFE_INTEGER) {
|
|
return num
|
|
}
|
|
}
|
|
return id
|
|
})
|
|
}
|
|
|
|
this.build = m[5] ? m[5].split('.') : []
|
|
this.format()
|
|
}
|
|
|
|
format () {
|
|
this.version = `${this.major}.${this.minor}.${this.patch}`
|
|
if (this.prerelease.length) {
|
|
this.version += `-${this.prerelease.join('.')}`
|
|
}
|
|
return this.version
|
|
}
|
|
|
|
toString () {
|
|
return this.version
|
|
}
|
|
|
|
compare (other) {
|
|
debug('SemVer.compare', this.version, this.options, other)
|
|
if (!(other instanceof SemVer)) {
|
|
if (typeof other === 'string' && other === this.version) {
|
|
return 0
|
|
}
|
|
other = new SemVer(other, this.options)
|
|
}
|
|
|
|
if (other.version === this.version) {
|
|
return 0
|
|
}
|
|
|
|
return this.compareMain(other) || this.comparePre(other)
|
|
}
|
|
|
|
compareMain (other) {
|
|
if (!(other instanceof SemVer)) {
|
|
other = new SemVer(other, this.options)
|
|
}
|
|
|
|
if (this.major < other.major) {
|
|
return -1
|
|
}
|
|
if (this.major > other.major) {
|
|
return 1
|
|
}
|
|
if (this.minor < other.minor) {
|
|
return -1
|
|
}
|
|
if (this.minor > other.minor) {
|
|
return 1
|
|
}
|
|
if (this.patch < other.patch) {
|
|
return -1
|
|
}
|
|
if (this.patch > other.patch) {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
comparePre (other) {
|
|
if (!(other instanceof SemVer)) {
|
|
other = new SemVer(other, this.options)
|
|
}
|
|
|
|
// NOT having a prerelease is > having one
|
|
if (this.prerelease.length && !other.prerelease.length) {
|
|
return -1
|
|
} else if (!this.prerelease.length && other.prerelease.length) {
|
|
return 1
|
|
} else if (!this.prerelease.length && !other.prerelease.length) {
|
|
return 0
|
|
}
|
|
|
|
let i = 0
|
|
do {
|
|
const a = this.prerelease[i]
|
|
const b = other.prerelease[i]
|
|
debug('prerelease compare', i, a, b)
|
|
if (a === undefined && b === undefined) {
|
|
return 0
|
|
} else if (b === undefined) {
|
|
return 1
|
|
} else if (a === undefined) {
|
|
return -1
|
|
} else if (a === b) {
|
|
continue
|
|
} else {
|
|
return compareIdentifiers(a, b)
|
|
}
|
|
} while (++i)
|
|
}
|
|
|
|
compareBuild (other) {
|
|
if (!(other instanceof SemVer)) {
|
|
other = new SemVer(other, this.options)
|
|
}
|
|
|
|
let i = 0
|
|
do {
|
|
const a = this.build[i]
|
|
const b = other.build[i]
|
|
debug('build compare', i, a, b)
|
|
if (a === undefined && b === undefined) {
|
|
return 0
|
|
} else if (b === undefined) {
|
|
return 1
|
|
} else if (a === undefined) {
|
|
return -1
|
|
} else if (a === b) {
|
|
continue
|
|
} else {
|
|
return compareIdentifiers(a, b)
|
|
}
|
|
} while (++i)
|
|
}
|
|
|
|
// preminor will bump the version up to the next minor release, and immediately
|
|
// down to pre-release. premajor and prepatch work the same way.
|
|
inc (release, identifier, identifierBase) {
|
|
if (release.startsWith('pre')) {
|
|
if (!identifier && identifierBase === false) {
|
|
throw new Error('invalid increment argument: identifier is empty')
|
|
}
|
|
// Avoid an invalid semver results
|
|
if (identifier) {
|
|
const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE])
|
|
if (!match || match[1] !== identifier) {
|
|
throw new Error(`invalid identifier: ${identifier}`)
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (release) {
|
|
case 'premajor':
|
|
this.prerelease.length = 0
|
|
this.patch = 0
|
|
this.minor = 0
|
|
this.major++
|
|
this.inc('pre', identifier, identifierBase)
|
|
break
|
|
case 'preminor':
|
|
this.prerelease.length = 0
|
|
this.patch = 0
|
|
this.minor++
|
|
this.inc('pre', identifier, identifierBase)
|
|
break
|
|
case 'prepatch':
|
|
// If this is already a prerelease, it will bump to the next version
|
|
// drop any prereleases that might already exist, since they are not
|
|
// relevant at this point.
|
|
this.prerelease.length = 0
|
|
this.inc('patch', identifier, identifierBase)
|
|
this.inc('pre', identifier, identifierBase)
|
|
break
|
|
// If the input is a non-prerelease version, this acts the same as
|
|
// prepatch.
|
|
case 'prerelease':
|
|
if (this.prerelease.length === 0) {
|
|
this.inc('patch', identifier, identifierBase)
|
|
}
|
|
this.inc('pre', identifier, identifierBase)
|
|
break
|
|
case 'release':
|
|
if (this.prerelease.length === 0) {
|
|
throw new Error(`version ${this.raw} is not a prerelease`)
|
|
}
|
|
this.prerelease.length = 0
|
|
break
|
|
|
|
case 'major':
|
|
// If this is a pre-major version, bump up to the same major version.
|
|
// Otherwise increment major.
|
|
// 1.0.0-5 bumps to 1.0.0
|
|
// 1.1.0 bumps to 2.0.0
|
|
if (
|
|
this.minor !== 0 ||
|
|
this.patch !== 0 ||
|
|
this.prerelease.length === 0
|
|
) {
|
|
this.major++
|
|
}
|
|
this.minor = 0
|
|
this.patch = 0
|
|
this.prerelease = []
|
|
break
|
|
case 'minor':
|
|
// If this is a pre-minor version, bump up to the same minor version.
|
|
// Otherwise increment minor.
|
|
// 1.2.0-5 bumps to 1.2.0
|
|
// 1.2.1 bumps to 1.3.0
|
|
if (this.patch !== 0 || this.prerelease.length === 0) {
|
|
this.minor++
|
|
}
|
|
this.patch = 0
|
|
this.prerelease = []
|
|
break
|
|
case 'patch':
|
|
// If this is not a pre-release version, it will increment the patch.
|
|
// If it is a pre-release it will bump up to the same patch version.
|
|
// 1.2.0-5 patches to 1.2.0
|
|
// 1.2.0 patches to 1.2.1
|
|
if (this.prerelease.length === 0) {
|
|
this.patch++
|
|
}
|
|
this.prerelease = []
|
|
break
|
|
// This probably shouldn't be used publicly.
|
|
// 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
|
|
case 'pre': {
|
|
const base = Number(identifierBase) ? 1 : 0
|
|
|
|
if (this.prerelease.length === 0) {
|
|
this.prerelease = [base]
|
|
} else {
|
|
let i = this.prerelease.length
|
|
while (--i >= 0) {
|
|
if (typeof this.prerelease[i] === 'number') {
|
|
this.prerelease[i]++
|
|
i = -2
|
|
}
|
|
}
|
|
if (i === -1) {
|
|
// didn't increment anything
|
|
if (identifier === this.prerelease.join('.') && identifierBase === false) {
|
|
throw new Error('invalid increment argument: identifier already exists')
|
|
}
|
|
this.prerelease.push(base)
|
|
}
|
|
}
|
|
if (identifier) {
|
|
// 1.2.0-beta.1 bumps to 1.2.0-beta.2,
|
|
// 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
|
|
let prerelease = [identifier, base]
|
|
if (identifierBase === false) {
|
|
prerelease = [identifier]
|
|
}
|
|
if (isPrereleaseIdentifier(this.prerelease, identifier)) {
|
|
const prereleaseBase = this.prerelease[identifier.split('.').length]
|
|
if (isNaN(prereleaseBase)) {
|
|
this.prerelease = prerelease
|
|
}
|
|
} else {
|
|
this.prerelease = prerelease
|
|
}
|
|
}
|
|
break
|
|
}
|
|
default:
|
|
throw new Error(`invalid increment argument: ${release}`)
|
|
}
|
|
this.raw = this.format()
|
|
if (this.build.length) {
|
|
this.raw += `+${this.build.join('.')}`
|
|
}
|
|
return this
|
|
}
|
|
}
|
|
|
|
module.exports = SemVer
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3590:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const parse = __nccwpck_require__(2080)
|
|
const clean = (version, options) => {
|
|
const s = parse(version.trim().replace(/^[=v]+/, ''), options)
|
|
return s ? s.version : null
|
|
}
|
|
module.exports = clean
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9647:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const eq = __nccwpck_require__(273)
|
|
const neq = __nccwpck_require__(2991)
|
|
const gt = __nccwpck_require__(3740)
|
|
const gte = __nccwpck_require__(6297)
|
|
const lt = __nccwpck_require__(2115)
|
|
const lte = __nccwpck_require__(9824)
|
|
|
|
const cmp = (a, op, b, loose) => {
|
|
switch (op) {
|
|
case '===':
|
|
if (typeof a === 'object') {
|
|
a = a.version
|
|
}
|
|
if (typeof b === 'object') {
|
|
b = b.version
|
|
}
|
|
return a === b
|
|
|
|
case '!==':
|
|
if (typeof a === 'object') {
|
|
a = a.version
|
|
}
|
|
if (typeof b === 'object') {
|
|
b = b.version
|
|
}
|
|
return a !== b
|
|
|
|
case '':
|
|
case '=':
|
|
case '==':
|
|
return eq(a, b, loose)
|
|
|
|
case '!=':
|
|
return neq(a, b, loose)
|
|
|
|
case '>':
|
|
return gt(a, b, loose)
|
|
|
|
case '>=':
|
|
return gte(a, b, loose)
|
|
|
|
case '<':
|
|
return lt(a, b, loose)
|
|
|
|
case '<=':
|
|
return lte(a, b, loose)
|
|
|
|
default:
|
|
throw new TypeError(`Invalid operator: ${op}`)
|
|
}
|
|
}
|
|
module.exports = cmp
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6141:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const parse = __nccwpck_require__(2080)
|
|
const { safeRe: re, t } = __nccwpck_require__(6102)
|
|
|
|
const coerce = (version, options) => {
|
|
if (version instanceof SemVer) {
|
|
return version
|
|
}
|
|
|
|
if (typeof version === 'number') {
|
|
version = String(version)
|
|
}
|
|
|
|
if (typeof version !== 'string') {
|
|
return null
|
|
}
|
|
|
|
options = options || {}
|
|
|
|
let match = null
|
|
if (!options.rtl) {
|
|
match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE])
|
|
} else {
|
|
// Find the right-most coercible string that does not share
|
|
// a terminus with a more left-ward coercible string.
|
|
// Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
|
|
// With includePrerelease option set, '1.2.3.4-rc' wants to coerce '2.3.4-rc', not '2.3.4'
|
|
//
|
|
// Walk through the string checking with a /g regexp
|
|
// Manually set the index so as to pick up overlapping matches.
|
|
// Stop when we get a match that ends at the string end, since no
|
|
// coercible string can be more right-ward without the same terminus.
|
|
const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL]
|
|
let next
|
|
while ((next = coerceRtlRegex.exec(version)) &&
|
|
(!match || match.index + match[0].length !== version.length)
|
|
) {
|
|
if (!match ||
|
|
next.index + next[0].length !== match.index + match[0].length) {
|
|
match = next
|
|
}
|
|
coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length
|
|
}
|
|
// leave it in a clean state
|
|
coerceRtlRegex.lastIndex = -1
|
|
}
|
|
|
|
if (match === null) {
|
|
return null
|
|
}
|
|
|
|
const major = match[2]
|
|
const minor = match[3] || '0'
|
|
const patch = match[4] || '0'
|
|
const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : ''
|
|
const build = options.includePrerelease && match[6] ? `+${match[6]}` : ''
|
|
|
|
return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options)
|
|
}
|
|
module.exports = coerce
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2237:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const compareBuild = (a, b, loose) => {
|
|
const versionA = new SemVer(a, loose)
|
|
const versionB = new SemVer(b, loose)
|
|
return versionA.compare(versionB) || versionA.compareBuild(versionB)
|
|
}
|
|
module.exports = compareBuild
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9539:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const compare = __nccwpck_require__(1136)
|
|
const compareLoose = (a, b) => compare(a, b, true)
|
|
module.exports = compareLoose
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1136:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const compare = (a, b, loose) =>
|
|
new SemVer(a, loose).compare(new SemVer(b, loose))
|
|
|
|
module.exports = compare
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3496:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const parse = __nccwpck_require__(2080)
|
|
|
|
const diff = (version1, version2) => {
|
|
const v1 = parse(version1, null, true)
|
|
const v2 = parse(version2, null, true)
|
|
const comparison = v1.compare(v2)
|
|
|
|
if (comparison === 0) {
|
|
return null
|
|
}
|
|
|
|
const v1Higher = comparison > 0
|
|
const highVersion = v1Higher ? v1 : v2
|
|
const lowVersion = v1Higher ? v2 : v1
|
|
const highHasPre = !!highVersion.prerelease.length
|
|
const lowHasPre = !!lowVersion.prerelease.length
|
|
|
|
if (lowHasPre && !highHasPre) {
|
|
// Going from prerelease -> no prerelease requires some special casing
|
|
|
|
// If the low version has only a major, then it will always be a major
|
|
// Some examples:
|
|
// 1.0.0-1 -> 1.0.0
|
|
// 1.0.0-1 -> 1.1.1
|
|
// 1.0.0-1 -> 2.0.0
|
|
if (!lowVersion.patch && !lowVersion.minor) {
|
|
return 'major'
|
|
}
|
|
|
|
// If the main part has no difference
|
|
if (lowVersion.compareMain(highVersion) === 0) {
|
|
if (lowVersion.minor && !lowVersion.patch) {
|
|
return 'minor'
|
|
}
|
|
return 'patch'
|
|
}
|
|
}
|
|
|
|
// add the `pre` prefix if we are going to a prerelease version
|
|
const prefix = highHasPre ? 'pre' : ''
|
|
|
|
if (v1.major !== v2.major) {
|
|
return prefix + 'major'
|
|
}
|
|
|
|
if (v1.minor !== v2.minor) {
|
|
return prefix + 'minor'
|
|
}
|
|
|
|
if (v1.patch !== v2.patch) {
|
|
return prefix + 'patch'
|
|
}
|
|
|
|
// high and low are prereleases
|
|
return 'prerelease'
|
|
}
|
|
|
|
module.exports = diff
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 273:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const compare = __nccwpck_require__(1136)
|
|
const eq = (a, b, loose) => compare(a, b, loose) === 0
|
|
module.exports = eq
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3740:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const compare = __nccwpck_require__(1136)
|
|
const gt = (a, b, loose) => compare(a, b, loose) > 0
|
|
module.exports = gt
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6297:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const compare = __nccwpck_require__(1136)
|
|
const gte = (a, b, loose) => compare(a, b, loose) >= 0
|
|
module.exports = gte
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1999:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SemVer = __nccwpck_require__(6644)
|
|
|
|
const inc = (version, release, options, identifier, identifierBase) => {
|
|
if (typeof (options) === 'string') {
|
|
identifierBase = identifier
|
|
identifier = options
|
|
options = undefined
|
|
}
|
|
|
|
try {
|
|
return new SemVer(
|
|
version instanceof SemVer ? version.version : version,
|
|
options
|
|
).inc(release, identifier, identifierBase).version
|
|
} catch (er) {
|
|
return null
|
|
}
|
|
}
|
|
module.exports = inc
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2115:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const compare = __nccwpck_require__(1136)
|
|
const lt = (a, b, loose) => compare(a, b, loose) < 0
|
|
module.exports = lt
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9824:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const compare = __nccwpck_require__(1136)
|
|
const lte = (a, b, loose) => compare(a, b, loose) <= 0
|
|
module.exports = lte
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 474:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const major = (a, loose) => new SemVer(a, loose).major
|
|
module.exports = major
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2430:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const minor = (a, loose) => new SemVer(a, loose).minor
|
|
module.exports = minor
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2991:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const compare = __nccwpck_require__(1136)
|
|
const neq = (a, b, loose) => compare(a, b, loose) !== 0
|
|
module.exports = neq
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2080:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const parse = (version, options, throwErrors = false) => {
|
|
if (version instanceof SemVer) {
|
|
return version
|
|
}
|
|
try {
|
|
return new SemVer(version, options)
|
|
} catch (er) {
|
|
if (!throwErrors) {
|
|
return null
|
|
}
|
|
throw er
|
|
}
|
|
}
|
|
|
|
module.exports = parse
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9629:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const patch = (a, loose) => new SemVer(a, loose).patch
|
|
module.exports = patch
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6593:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const parse = __nccwpck_require__(2080)
|
|
const prerelease = (version, options) => {
|
|
const parsed = parse(version, options)
|
|
return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
|
|
}
|
|
module.exports = prerelease
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4018:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const compare = __nccwpck_require__(1136)
|
|
const rcompare = (a, b, loose) => compare(b, a, loose)
|
|
module.exports = rcompare
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1749:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const compareBuild = __nccwpck_require__(2237)
|
|
const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))
|
|
module.exports = rsort
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6326:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const Range = __nccwpck_require__(4535)
|
|
const satisfies = (version, range, options) => {
|
|
try {
|
|
range = new Range(range, options)
|
|
} catch (er) {
|
|
return false
|
|
}
|
|
return range.test(version)
|
|
}
|
|
module.exports = satisfies
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5783:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const compareBuild = __nccwpck_require__(2237)
|
|
const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))
|
|
module.exports = sort
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7537:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const parse = __nccwpck_require__(2080)
|
|
const constants = __nccwpck_require__(9962)
|
|
const SemVer = __nccwpck_require__(6644)
|
|
|
|
const truncate = (version, truncation, options) => {
|
|
if (!constants.RELEASE_TYPES.includes(truncation)) {
|
|
return null
|
|
}
|
|
|
|
const clonedVersion = cloneInputVersion(version, options)
|
|
return clonedVersion && doTruncation(clonedVersion, truncation)
|
|
}
|
|
|
|
const cloneInputVersion = (version, options) => {
|
|
const versionStringToParse = (
|
|
version instanceof SemVer ? version.version : version
|
|
)
|
|
|
|
return parse(versionStringToParse, options)
|
|
}
|
|
|
|
const doTruncation = (version, truncation) => {
|
|
if (isPrerelease(truncation)) {
|
|
return version.version
|
|
}
|
|
|
|
version.prerelease = []
|
|
|
|
switch (truncation) {
|
|
case 'major':
|
|
version.minor = 0
|
|
version.patch = 0
|
|
break
|
|
case 'minor':
|
|
version.patch = 0
|
|
break
|
|
}
|
|
|
|
return version.format()
|
|
}
|
|
|
|
const isPrerelease = (type) => {
|
|
return type.startsWith('pre')
|
|
}
|
|
|
|
module.exports = truncate
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3769:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const parse = __nccwpck_require__(2080)
|
|
const valid = (version, options) => {
|
|
const v = parse(version, options)
|
|
return v ? v.version : null
|
|
}
|
|
module.exports = valid
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 885:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
// just pre-load all the stuff that index.js lazily exports
|
|
const internalRe = __nccwpck_require__(6102)
|
|
const constants = __nccwpck_require__(9962)
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const identifiers = __nccwpck_require__(3411)
|
|
const parse = __nccwpck_require__(2080)
|
|
const valid = __nccwpck_require__(3769)
|
|
const clean = __nccwpck_require__(3590)
|
|
const inc = __nccwpck_require__(1999)
|
|
const diff = __nccwpck_require__(3496)
|
|
const major = __nccwpck_require__(474)
|
|
const minor = __nccwpck_require__(2430)
|
|
const patch = __nccwpck_require__(9629)
|
|
const prerelease = __nccwpck_require__(6593)
|
|
const compare = __nccwpck_require__(1136)
|
|
const rcompare = __nccwpck_require__(4018)
|
|
const compareLoose = __nccwpck_require__(9539)
|
|
const compareBuild = __nccwpck_require__(2237)
|
|
const sort = __nccwpck_require__(5783)
|
|
const rsort = __nccwpck_require__(1749)
|
|
const gt = __nccwpck_require__(3740)
|
|
const lt = __nccwpck_require__(2115)
|
|
const eq = __nccwpck_require__(273)
|
|
const neq = __nccwpck_require__(2991)
|
|
const gte = __nccwpck_require__(6297)
|
|
const lte = __nccwpck_require__(9824)
|
|
const cmp = __nccwpck_require__(9647)
|
|
const coerce = __nccwpck_require__(6141)
|
|
const truncate = __nccwpck_require__(7537)
|
|
const Comparator = __nccwpck_require__(7712)
|
|
const Range = __nccwpck_require__(4535)
|
|
const satisfies = __nccwpck_require__(6326)
|
|
const toComparators = __nccwpck_require__(7583)
|
|
const maxSatisfying = __nccwpck_require__(3036)
|
|
const minSatisfying = __nccwpck_require__(7534)
|
|
const minVersion = __nccwpck_require__(9725)
|
|
const validRange = __nccwpck_require__(9282)
|
|
const outside = __nccwpck_require__(9955)
|
|
const gtr = __nccwpck_require__(2915)
|
|
const ltr = __nccwpck_require__(1102)
|
|
const intersects = __nccwpck_require__(7116)
|
|
const simplifyRange = __nccwpck_require__(6077)
|
|
const subset = __nccwpck_require__(1880)
|
|
module.exports = {
|
|
parse,
|
|
valid,
|
|
clean,
|
|
inc,
|
|
diff,
|
|
major,
|
|
minor,
|
|
patch,
|
|
prerelease,
|
|
compare,
|
|
rcompare,
|
|
compareLoose,
|
|
compareBuild,
|
|
sort,
|
|
rsort,
|
|
gt,
|
|
lt,
|
|
eq,
|
|
neq,
|
|
gte,
|
|
lte,
|
|
cmp,
|
|
coerce,
|
|
truncate,
|
|
Comparator,
|
|
Range,
|
|
satisfies,
|
|
toComparators,
|
|
maxSatisfying,
|
|
minSatisfying,
|
|
minVersion,
|
|
validRange,
|
|
outside,
|
|
gtr,
|
|
ltr,
|
|
intersects,
|
|
simplifyRange,
|
|
subset,
|
|
SemVer,
|
|
re: internalRe.re,
|
|
src: internalRe.src,
|
|
tokens: internalRe.t,
|
|
SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
|
|
RELEASE_TYPES: constants.RELEASE_TYPES,
|
|
compareIdentifiers: identifiers.compareIdentifiers,
|
|
rcompareIdentifiers: identifiers.rcompareIdentifiers,
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9962:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
// Note: this is the semver.org version of the spec that it implements
|
|
// Not necessarily the package version of this code.
|
|
const SEMVER_SPEC_VERSION = '2.0.0'
|
|
|
|
const MAX_LENGTH = 256
|
|
const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
|
|
/* istanbul ignore next */ 9007199254740991
|
|
|
|
// Max safe segment length for coercion.
|
|
const MAX_SAFE_COMPONENT_LENGTH = 16
|
|
|
|
// Max safe length for a build identifier. The max length minus 6 characters for
|
|
// the shortest version with a build 0.0.0+BUILD.
|
|
const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6
|
|
|
|
const RELEASE_TYPES = [
|
|
'major',
|
|
'premajor',
|
|
'minor',
|
|
'preminor',
|
|
'patch',
|
|
'prepatch',
|
|
'prerelease',
|
|
]
|
|
|
|
module.exports = {
|
|
MAX_LENGTH,
|
|
MAX_SAFE_COMPONENT_LENGTH,
|
|
MAX_SAFE_BUILD_LENGTH,
|
|
MAX_SAFE_INTEGER,
|
|
RELEASE_TYPES,
|
|
SEMVER_SPEC_VERSION,
|
|
FLAG_INCLUDE_PRERELEASE: 0b001,
|
|
FLAG_LOOSE: 0b010,
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1736:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
const debug = (
|
|
typeof process === 'object' &&
|
|
process.env &&
|
|
process.env.NODE_DEBUG &&
|
|
/\bsemver\b/i.test(process.env.NODE_DEBUG)
|
|
) ? (...args) => console.error('SEMVER', ...args)
|
|
: () => {}
|
|
|
|
module.exports = debug
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3411:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
const numeric = /^[0-9]+$/
|
|
const compareIdentifiers = (a, b) => {
|
|
if (typeof a === 'number' && typeof b === 'number') {
|
|
return a === b ? 0 : a < b ? -1 : 1
|
|
}
|
|
|
|
const anum = numeric.test(a)
|
|
const bnum = numeric.test(b)
|
|
|
|
if (anum && bnum) {
|
|
a = +a
|
|
b = +b
|
|
}
|
|
|
|
return a === b ? 0
|
|
: (anum && !bnum) ? -1
|
|
: (bnum && !anum) ? 1
|
|
: a < b ? -1
|
|
: 1
|
|
}
|
|
|
|
const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)
|
|
|
|
module.exports = {
|
|
compareIdentifiers,
|
|
rcompareIdentifiers,
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1018:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
class LRUCache {
|
|
constructor () {
|
|
this.max = 1000
|
|
this.map = new Map()
|
|
}
|
|
|
|
get (key) {
|
|
const value = this.map.get(key)
|
|
if (value === undefined) {
|
|
return undefined
|
|
} else {
|
|
// Remove the key from the map and add it to the end
|
|
this.map.delete(key)
|
|
this.map.set(key, value)
|
|
return value
|
|
}
|
|
}
|
|
|
|
delete (key) {
|
|
return this.map.delete(key)
|
|
}
|
|
|
|
set (key, value) {
|
|
const deleted = this.delete(key)
|
|
|
|
if (!deleted && value !== undefined) {
|
|
// If cache is full, delete the least recently used item
|
|
if (this.map.size >= this.max) {
|
|
const firstKey = this.map.keys().next().value
|
|
this.delete(firstKey)
|
|
}
|
|
|
|
this.map.set(key, value)
|
|
}
|
|
|
|
return this
|
|
}
|
|
}
|
|
|
|
module.exports = LRUCache
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5131:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
// parse out just the options we care about
|
|
const looseOption = Object.freeze({ loose: true })
|
|
const emptyOpts = Object.freeze({ })
|
|
const parseOptions = options => {
|
|
if (!options) {
|
|
return emptyOpts
|
|
}
|
|
|
|
if (typeof options !== 'object') {
|
|
return looseOption
|
|
}
|
|
|
|
return options
|
|
}
|
|
module.exports = parseOptions
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6102:
|
|
/***/ ((module, exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const {
|
|
MAX_SAFE_COMPONENT_LENGTH,
|
|
MAX_SAFE_BUILD_LENGTH,
|
|
MAX_LENGTH,
|
|
} = __nccwpck_require__(9962)
|
|
const debug = __nccwpck_require__(1736)
|
|
exports = module.exports = {}
|
|
|
|
// The actual regexps go on exports.re
|
|
const re = exports.re = []
|
|
const safeRe = exports.safeRe = []
|
|
const src = exports.src = []
|
|
const safeSrc = exports.safeSrc = []
|
|
const t = exports.t = {}
|
|
let R = 0
|
|
|
|
const LETTERDASHNUMBER = '[a-zA-Z0-9-]'
|
|
|
|
// Replace some greedy regex tokens to prevent regex dos issues. These regex are
|
|
// used internally via the safeRe object since all inputs in this library get
|
|
// normalized first to trim and collapse all extra whitespace. The original
|
|
// regexes are exported for userland consumption and lower level usage. A
|
|
// future breaking change could export the safer regex only with a note that
|
|
// all input should have extra whitespace removed.
|
|
const safeRegexReplacements = [
|
|
['\\s', 1],
|
|
['\\d', MAX_LENGTH],
|
|
[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
|
|
]
|
|
|
|
const makeSafeRegex = (value) => {
|
|
for (const [token, max] of safeRegexReplacements) {
|
|
value = value
|
|
.split(`${token}*`).join(`${token}{0,${max}}`)
|
|
.split(`${token}+`).join(`${token}{1,${max}}`)
|
|
}
|
|
return value
|
|
}
|
|
|
|
const createToken = (name, value, isGlobal) => {
|
|
const safe = makeSafeRegex(value)
|
|
const index = R++
|
|
debug(name, index, value)
|
|
t[name] = index
|
|
src[index] = value
|
|
safeSrc[index] = safe
|
|
re[index] = new RegExp(value, isGlobal ? 'g' : undefined)
|
|
safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined)
|
|
}
|
|
|
|
// The following Regular Expressions can be used for tokenizing,
|
|
// validating, and parsing SemVer version strings.
|
|
|
|
// ## Numeric Identifier
|
|
// A single `0`, or a non-zero digit followed by zero or more digits.
|
|
|
|
createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*')
|
|
createToken('NUMERICIDENTIFIERLOOSE', '\\d+')
|
|
|
|
// ## Non-numeric Identifier
|
|
// Zero or more digits, followed by a letter or hyphen, and then zero or
|
|
// more letters, digits, or hyphens.
|
|
|
|
createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`)
|
|
|
|
// ## Main Version
|
|
// Three dot-separated numeric identifiers.
|
|
|
|
createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
|
|
`(${src[t.NUMERICIDENTIFIER]})\\.` +
|
|
`(${src[t.NUMERICIDENTIFIER]})`)
|
|
|
|
createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
|
|
`(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
|
|
`(${src[t.NUMERICIDENTIFIERLOOSE]})`)
|
|
|
|
// ## Pre-release Version Identifier
|
|
// A numeric identifier, or a non-numeric identifier.
|
|
// Non-numeric identifiers include numeric identifiers but can be longer.
|
|
// Therefore non-numeric identifiers must go first.
|
|
|
|
createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NONNUMERICIDENTIFIER]
|
|
}|${src[t.NUMERICIDENTIFIER]})`)
|
|
|
|
createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NONNUMERICIDENTIFIER]
|
|
}|${src[t.NUMERICIDENTIFIERLOOSE]})`)
|
|
|
|
// ## Pre-release Version
|
|
// Hyphen, followed by one or more dot-separated pre-release version
|
|
// identifiers.
|
|
|
|
createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
|
|
}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`)
|
|
|
|
createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
|
|
}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)
|
|
|
|
// ## Build Metadata Identifier
|
|
// Any combination of digits, letters, or hyphens.
|
|
|
|
createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`)
|
|
|
|
// ## Build Metadata
|
|
// Plus sign, followed by one or more period-separated build metadata
|
|
// identifiers.
|
|
|
|
createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
|
|
}(?:\\.${src[t.BUILDIDENTIFIER]})*))`)
|
|
|
|
// ## Full Version String
|
|
// A main version, followed optionally by a pre-release version and
|
|
// build metadata.
|
|
|
|
// Note that the only major, minor, patch, and pre-release sections of
|
|
// the version string are capturing groups. The build metadata is not a
|
|
// capturing group, because it should not ever be used in version
|
|
// comparison.
|
|
|
|
createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
|
|
}${src[t.PRERELEASE]}?${
|
|
src[t.BUILD]}?`)
|
|
|
|
createToken('FULL', `^${src[t.FULLPLAIN]}$`)
|
|
|
|
// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
|
|
// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
|
|
// common in the npm registry.
|
|
createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
|
|
}${src[t.PRERELEASELOOSE]}?${
|
|
src[t.BUILD]}?`)
|
|
|
|
createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)
|
|
|
|
createToken('GTLT', '((?:<|>)?=?)')
|
|
|
|
// Something like "2.*" or "1.2.x".
|
|
// Note that "x.x" is a valid xRange identifier, meaning "any version"
|
|
// Only the first item is strictly required.
|
|
createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`)
|
|
createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`)
|
|
|
|
createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
|
|
`(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
|
|
`(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
|
|
`(?:${src[t.PRERELEASE]})?${
|
|
src[t.BUILD]}?` +
|
|
`)?)?`)
|
|
|
|
createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
|
|
`(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
|
|
`(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
|
|
`(?:${src[t.PRERELEASELOOSE]})?${
|
|
src[t.BUILD]}?` +
|
|
`)?)?`)
|
|
|
|
createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`)
|
|
createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`)
|
|
|
|
// Coercion.
|
|
// Extract anything that could conceivably be a part of a valid semver
|
|
createToken('COERCEPLAIN', `${'(^|[^\\d])' +
|
|
'(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
|
|
`(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
|
|
`(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`)
|
|
createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`)
|
|
createToken('COERCEFULL', src[t.COERCEPLAIN] +
|
|
`(?:${src[t.PRERELEASE]})?` +
|
|
`(?:${src[t.BUILD]})?` +
|
|
`(?:$|[^\\d])`)
|
|
createToken('COERCERTL', src[t.COERCE], true)
|
|
createToken('COERCERTLFULL', src[t.COERCEFULL], true)
|
|
|
|
// Tilde ranges.
|
|
// Meaning is "reasonably at or greater than"
|
|
createToken('LONETILDE', '(?:~>?)')
|
|
|
|
createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true)
|
|
exports.tildeTrimReplace = '$1~'
|
|
|
|
createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)
|
|
createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)
|
|
|
|
// Caret ranges.
|
|
// Meaning is "at least and backwards compatible with"
|
|
createToken('LONECARET', '(?:\\^)')
|
|
|
|
createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true)
|
|
exports.caretTrimReplace = '$1^'
|
|
|
|
createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)
|
|
createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)
|
|
|
|
// A simple gt/lt/eq thing, or just "" to indicate "any version"
|
|
createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`)
|
|
createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`)
|
|
|
|
// An expression to strip any whitespace between the gtlt and the thing
|
|
// it modifies, so that `> 1.2.3` ==> `>1.2.3`
|
|
createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
|
|
}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)
|
|
exports.comparatorTrimReplace = '$1$2$3'
|
|
|
|
// Something like `1.2.3 - 1.2.4`
|
|
// Note that these all use the loose form, because they'll be
|
|
// checked against either the strict or loose comparator form
|
|
// later.
|
|
createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
|
|
`\\s+-\\s+` +
|
|
`(${src[t.XRANGEPLAIN]})` +
|
|
`\\s*$`)
|
|
|
|
createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
|
|
`\\s+-\\s+` +
|
|
`(${src[t.XRANGEPLAINLOOSE]})` +
|
|
`\\s*$`)
|
|
|
|
// Star ranges basically just allow anything at all.
|
|
createToken('STAR', '(<|>)?=?\\s*\\*')
|
|
// >=0.0.0 is like a star
|
|
createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$')
|
|
createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$')
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2915:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
// Determine if version is greater than all the versions possible in the range.
|
|
const outside = __nccwpck_require__(9955)
|
|
const gtr = (version, range, options) => outside(version, range, '>', options)
|
|
module.exports = gtr
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7116:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const Range = __nccwpck_require__(4535)
|
|
const intersects = (r1, r2, options) => {
|
|
r1 = new Range(r1, options)
|
|
r2 = new Range(r2, options)
|
|
return r1.intersects(r2, options)
|
|
}
|
|
module.exports = intersects
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1102:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const outside = __nccwpck_require__(9955)
|
|
// Determine if version is less than all the versions possible in the range
|
|
const ltr = (version, range, options) => outside(version, range, '<', options)
|
|
module.exports = ltr
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3036:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const Range = __nccwpck_require__(4535)
|
|
|
|
const maxSatisfying = (versions, range, options) => {
|
|
let max = null
|
|
let maxSV = null
|
|
let rangeObj = null
|
|
try {
|
|
rangeObj = new Range(range, options)
|
|
} catch (er) {
|
|
return null
|
|
}
|
|
versions.forEach((v) => {
|
|
if (rangeObj.test(v)) {
|
|
// satisfies(v, range, options)
|
|
if (!max || maxSV.compare(v) === -1) {
|
|
// compare(max, v, true)
|
|
max = v
|
|
maxSV = new SemVer(max, options)
|
|
}
|
|
}
|
|
})
|
|
return max
|
|
}
|
|
module.exports = maxSatisfying
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7534:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const Range = __nccwpck_require__(4535)
|
|
const minSatisfying = (versions, range, options) => {
|
|
let min = null
|
|
let minSV = null
|
|
let rangeObj = null
|
|
try {
|
|
rangeObj = new Range(range, options)
|
|
} catch (er) {
|
|
return null
|
|
}
|
|
versions.forEach((v) => {
|
|
if (rangeObj.test(v)) {
|
|
// satisfies(v, range, options)
|
|
if (!min || minSV.compare(v) === 1) {
|
|
// compare(min, v, true)
|
|
min = v
|
|
minSV = new SemVer(min, options)
|
|
}
|
|
}
|
|
})
|
|
return min
|
|
}
|
|
module.exports = minSatisfying
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9725:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const Range = __nccwpck_require__(4535)
|
|
const gt = __nccwpck_require__(3740)
|
|
|
|
const minVersion = (range, loose) => {
|
|
range = new Range(range, loose)
|
|
|
|
let minver = new SemVer('0.0.0')
|
|
if (range.test(minver)) {
|
|
return minver
|
|
}
|
|
|
|
minver = new SemVer('0.0.0-0')
|
|
if (range.test(minver)) {
|
|
return minver
|
|
}
|
|
|
|
minver = null
|
|
for (let i = 0; i < range.set.length; ++i) {
|
|
const comparators = range.set[i]
|
|
|
|
let setMin = null
|
|
comparators.forEach((comparator) => {
|
|
// Clone to avoid manipulating the comparator's semver object.
|
|
const compver = new SemVer(comparator.semver.version)
|
|
switch (comparator.operator) {
|
|
case '>':
|
|
if (compver.prerelease.length === 0) {
|
|
compver.patch++
|
|
} else {
|
|
compver.prerelease.push(0)
|
|
}
|
|
compver.raw = compver.format()
|
|
/* fallthrough */
|
|
case '':
|
|
case '>=':
|
|
if (!setMin || gt(compver, setMin)) {
|
|
setMin = compver
|
|
}
|
|
break
|
|
case '<':
|
|
case '<=':
|
|
/* Ignore maximum versions */
|
|
break
|
|
/* istanbul ignore next */
|
|
default:
|
|
throw new Error(`Unexpected operation: ${comparator.operator}`)
|
|
}
|
|
})
|
|
if (setMin && (!minver || gt(minver, setMin))) {
|
|
minver = setMin
|
|
}
|
|
}
|
|
|
|
if (minver && range.test(minver)) {
|
|
return minver
|
|
}
|
|
|
|
return null
|
|
}
|
|
module.exports = minVersion
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9955:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const SemVer = __nccwpck_require__(6644)
|
|
const Comparator = __nccwpck_require__(7712)
|
|
const { ANY } = Comparator
|
|
const Range = __nccwpck_require__(4535)
|
|
const satisfies = __nccwpck_require__(6326)
|
|
const gt = __nccwpck_require__(3740)
|
|
const lt = __nccwpck_require__(2115)
|
|
const lte = __nccwpck_require__(9824)
|
|
const gte = __nccwpck_require__(6297)
|
|
|
|
const outside = (version, range, hilo, options) => {
|
|
version = new SemVer(version, options)
|
|
range = new Range(range, options)
|
|
|
|
let gtfn, ltefn, ltfn, comp, ecomp
|
|
switch (hilo) {
|
|
case '>':
|
|
gtfn = gt
|
|
ltefn = lte
|
|
ltfn = lt
|
|
comp = '>'
|
|
ecomp = '>='
|
|
break
|
|
case '<':
|
|
gtfn = lt
|
|
ltefn = gte
|
|
ltfn = gt
|
|
comp = '<'
|
|
ecomp = '<='
|
|
break
|
|
default:
|
|
throw new TypeError('Must provide a hilo val of "<" or ">"')
|
|
}
|
|
|
|
// If it satisfies the range it is not outside
|
|
if (satisfies(version, range, options)) {
|
|
return false
|
|
}
|
|
|
|
// From now on, variable terms are as if we're in "gtr" mode.
|
|
// but note that everything is flipped for the "ltr" function.
|
|
|
|
for (let i = 0; i < range.set.length; ++i) {
|
|
const comparators = range.set[i]
|
|
|
|
let high = null
|
|
let low = null
|
|
|
|
comparators.forEach((comparator) => {
|
|
if (comparator.semver === ANY) {
|
|
comparator = new Comparator('>=0.0.0')
|
|
}
|
|
high = high || comparator
|
|
low = low || comparator
|
|
if (gtfn(comparator.semver, high.semver, options)) {
|
|
high = comparator
|
|
} else if (ltfn(comparator.semver, low.semver, options)) {
|
|
low = comparator
|
|
}
|
|
})
|
|
|
|
// If the edge version comparator has a operator then our version
|
|
// isn't outside it
|
|
if (high.operator === comp || high.operator === ecomp) {
|
|
return false
|
|
}
|
|
|
|
// If the lowest version comparator has an operator and our version
|
|
// is less than it then it isn't higher than the range
|
|
if ((!low.operator || low.operator === comp) &&
|
|
ltefn(version, low.semver)) {
|
|
return false
|
|
} else if (low.operator === ecomp && ltfn(version, low.semver)) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
module.exports = outside
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6077:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
// given a set of versions and a range, create a "simplified" range
|
|
// that includes the same versions that the original range does
|
|
// If the original range is shorter than the simplified one, return that.
|
|
const satisfies = __nccwpck_require__(6326)
|
|
const compare = __nccwpck_require__(1136)
|
|
module.exports = (versions, range, options) => {
|
|
const set = []
|
|
let first = null
|
|
let prev = null
|
|
const v = versions.sort((a, b) => compare(a, b, options))
|
|
for (const version of v) {
|
|
const included = satisfies(version, range, options)
|
|
if (included) {
|
|
prev = version
|
|
if (!first) {
|
|
first = version
|
|
}
|
|
} else {
|
|
if (prev) {
|
|
set.push([first, prev])
|
|
}
|
|
prev = null
|
|
first = null
|
|
}
|
|
}
|
|
if (first) {
|
|
set.push([first, null])
|
|
}
|
|
|
|
const ranges = []
|
|
for (const [min, max] of set) {
|
|
if (min === max) {
|
|
ranges.push(min)
|
|
} else if (!max && min === v[0]) {
|
|
ranges.push('*')
|
|
} else if (!max) {
|
|
ranges.push(`>=${min}`)
|
|
} else if (min === v[0]) {
|
|
ranges.push(`<=${max}`)
|
|
} else {
|
|
ranges.push(`${min} - ${max}`)
|
|
}
|
|
}
|
|
const simplified = ranges.join(' || ')
|
|
const original = typeof range.raw === 'string' ? range.raw : String(range)
|
|
return simplified.length < original.length ? simplified : range
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1880:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const Range = __nccwpck_require__(4535)
|
|
const Comparator = __nccwpck_require__(7712)
|
|
const { ANY } = Comparator
|
|
const satisfies = __nccwpck_require__(6326)
|
|
const compare = __nccwpck_require__(1136)
|
|
|
|
// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
|
|
// - Every simple range `r1, r2, ...` is a null set, OR
|
|
// - Every simple range `r1, r2, ...` which is not a null set is a subset of
|
|
// some `R1, R2, ...`
|
|
//
|
|
// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
|
|
// - If c is only the ANY comparator
|
|
// - If C is only the ANY comparator, return true
|
|
// - Else if in prerelease mode, return false
|
|
// - else replace c with `[>=0.0.0]`
|
|
// - If C is only the ANY comparator
|
|
// - if in prerelease mode, return true
|
|
// - else replace C with `[>=0.0.0]`
|
|
// - Let EQ be the set of = comparators in c
|
|
// - If EQ is more than one, return true (null set)
|
|
// - Let GT be the highest > or >= comparator in c
|
|
// - Let LT be the lowest < or <= comparator in c
|
|
// - If GT and LT, and GT.semver > LT.semver, return true (null set)
|
|
// - If any C is a = range, and GT or LT are set, return false
|
|
// - If EQ
|
|
// - If GT, and EQ does not satisfy GT, return true (null set)
|
|
// - If LT, and EQ does not satisfy LT, return true (null set)
|
|
// - If EQ satisfies every C, return true
|
|
// - Else return false
|
|
// - If GT
|
|
// - If GT.semver is lower than any > or >= comp in C, return false
|
|
// - If GT is >=, and GT.semver does not satisfy every C, return false
|
|
// - If GT.semver has a prerelease, and not in prerelease mode
|
|
// - If no C has a prerelease and the GT.semver tuple, return false
|
|
// - If LT
|
|
// - If LT.semver is greater than any < or <= comp in C, return false
|
|
// - If LT is <=, and LT.semver does not satisfy every C, return false
|
|
// - If LT.semver has a prerelease, and not in prerelease mode
|
|
// - If no C has a prerelease and the LT.semver tuple, return false
|
|
// - Else return true
|
|
|
|
const subset = (sub, dom, options = {}) => {
|
|
if (sub === dom) {
|
|
return true
|
|
}
|
|
|
|
sub = new Range(sub, options)
|
|
dom = new Range(dom, options)
|
|
let sawNonNull = false
|
|
|
|
OUTER: for (const simpleSub of sub.set) {
|
|
for (const simpleDom of dom.set) {
|
|
const isSub = simpleSubset(simpleSub, simpleDom, options)
|
|
sawNonNull = sawNonNull || isSub !== null
|
|
if (isSub) {
|
|
continue OUTER
|
|
}
|
|
}
|
|
// the null set is a subset of everything, but null simple ranges in
|
|
// a complex range should be ignored. so if we saw a non-null range,
|
|
// then we know this isn't a subset, but if EVERY simple range was null,
|
|
// then it is a subset.
|
|
if (sawNonNull) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
const minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')]
|
|
const minimumVersion = [new Comparator('>=0.0.0')]
|
|
|
|
const simpleSubset = (sub, dom, options) => {
|
|
if (sub === dom) {
|
|
return true
|
|
}
|
|
|
|
if (sub.length === 1 && sub[0].semver === ANY) {
|
|
if (dom.length === 1 && dom[0].semver === ANY) {
|
|
return true
|
|
} else if (options.includePrerelease) {
|
|
sub = minimumVersionWithPreRelease
|
|
} else {
|
|
sub = minimumVersion
|
|
}
|
|
}
|
|
|
|
if (dom.length === 1 && dom[0].semver === ANY) {
|
|
if (options.includePrerelease) {
|
|
return true
|
|
} else {
|
|
dom = minimumVersion
|
|
}
|
|
}
|
|
|
|
const eqSet = new Set()
|
|
let gt, lt
|
|
for (const c of sub) {
|
|
if (c.operator === '>' || c.operator === '>=') {
|
|
gt = higherGT(gt, c, options)
|
|
} else if (c.operator === '<' || c.operator === '<=') {
|
|
lt = lowerLT(lt, c, options)
|
|
} else {
|
|
eqSet.add(c.semver)
|
|
}
|
|
}
|
|
|
|
if (eqSet.size > 1) {
|
|
return null
|
|
}
|
|
|
|
let gtltComp
|
|
if (gt && lt) {
|
|
gtltComp = compare(gt.semver, lt.semver, options)
|
|
if (gtltComp > 0) {
|
|
return null
|
|
} else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {
|
|
return null
|
|
}
|
|
}
|
|
|
|
// will iterate one or zero times
|
|
for (const eq of eqSet) {
|
|
if (gt && !satisfies(eq, String(gt), options)) {
|
|
return null
|
|
}
|
|
|
|
if (lt && !satisfies(eq, String(lt), options)) {
|
|
return null
|
|
}
|
|
|
|
for (const c of dom) {
|
|
if (!satisfies(eq, String(c), options)) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
let higher, lower
|
|
let hasDomLT, hasDomGT
|
|
// if the subset has a prerelease, we need a comparator in the superset
|
|
// with the same tuple and a prerelease, or it's not a subset
|
|
let needDomLTPre = lt &&
|
|
!options.includePrerelease &&
|
|
lt.semver.prerelease.length ? lt.semver : false
|
|
let needDomGTPre = gt &&
|
|
!options.includePrerelease &&
|
|
gt.semver.prerelease.length ? gt.semver : false
|
|
// exception: <1.2.3-0 is the same as <1.2.3
|
|
if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&
|
|
lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {
|
|
needDomLTPre = false
|
|
}
|
|
|
|
for (const c of dom) {
|
|
hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='
|
|
hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='
|
|
if (gt) {
|
|
if (needDomGTPre) {
|
|
if (c.semver.prerelease && c.semver.prerelease.length &&
|
|
c.semver.major === needDomGTPre.major &&
|
|
c.semver.minor === needDomGTPre.minor &&
|
|
c.semver.patch === needDomGTPre.patch) {
|
|
needDomGTPre = false
|
|
}
|
|
}
|
|
if (c.operator === '>' || c.operator === '>=') {
|
|
higher = higherGT(gt, c, options)
|
|
if (higher === c && higher !== gt) {
|
|
return false
|
|
}
|
|
} else if (gt.operator === '>=' && !c.test(gt.semver)) {
|
|
return false
|
|
}
|
|
}
|
|
if (lt) {
|
|
if (needDomLTPre) {
|
|
if (c.semver.prerelease && c.semver.prerelease.length &&
|
|
c.semver.major === needDomLTPre.major &&
|
|
c.semver.minor === needDomLTPre.minor &&
|
|
c.semver.patch === needDomLTPre.patch) {
|
|
needDomLTPre = false
|
|
}
|
|
}
|
|
if (c.operator === '<' || c.operator === '<=') {
|
|
lower = lowerLT(lt, c, options)
|
|
if (lower === c && lower !== lt) {
|
|
return false
|
|
}
|
|
} else if (lt.operator === '<=' && !c.test(lt.semver)) {
|
|
return false
|
|
}
|
|
}
|
|
if (!c.operator && (lt || gt) && gtltComp !== 0) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
// if there was a < or >, and nothing in the dom, then must be false
|
|
// UNLESS it was limited by another range in the other direction.
|
|
// Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
|
|
if (gt && hasDomLT && !lt && gtltComp !== 0) {
|
|
return false
|
|
}
|
|
|
|
if (lt && hasDomGT && !gt && gtltComp !== 0) {
|
|
return false
|
|
}
|
|
|
|
// we needed a prerelease range in a specific tuple, but didn't get one
|
|
// then this isn't a subset. eg >=1.2.3-pre is not a subset of >=1.0.0,
|
|
// because it includes prereleases in the 1.2.3 tuple
|
|
if (needDomGTPre || needDomLTPre) {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// >=1.2.3 is lower than >1.2.3
|
|
const higherGT = (a, b, options) => {
|
|
if (!a) {
|
|
return b
|
|
}
|
|
const comp = compare(a.semver, b.semver, options)
|
|
return comp > 0 ? a
|
|
: comp < 0 ? b
|
|
: b.operator === '>' && a.operator === '>=' ? b
|
|
: a
|
|
}
|
|
|
|
// <=1.2.3 is higher than <1.2.3
|
|
const lowerLT = (a, b, options) => {
|
|
if (!a) {
|
|
return b
|
|
}
|
|
const comp = compare(a.semver, b.semver, options)
|
|
return comp < 0 ? a
|
|
: comp > 0 ? b
|
|
: b.operator === '<' && a.operator === '<=' ? b
|
|
: a
|
|
}
|
|
|
|
module.exports = subset
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7583:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const Range = __nccwpck_require__(4535)
|
|
|
|
// Mostly just for testing and legacy API reasons
|
|
const toComparators = (range, options) =>
|
|
new Range(range, options).set
|
|
.map(comp => comp.map(c => c.value).join(' ').trim().split(' '))
|
|
|
|
module.exports = toComparators
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9282:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const Range = __nccwpck_require__(4535)
|
|
const validRange = (range, options) => {
|
|
try {
|
|
// Return '*' instead of '' so that truthiness works.
|
|
// This will throw if it's invalid anyway
|
|
return new Range(range, options).range || '*'
|
|
} catch (er) {
|
|
return null
|
|
}
|
|
}
|
|
module.exports = validRange
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 770:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
module.exports = __nccwpck_require__(218);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 218:
|
|
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
var net = __nccwpck_require__(9278);
|
|
var tls = __nccwpck_require__(4756);
|
|
var http = __nccwpck_require__(8611);
|
|
var https = __nccwpck_require__(5692);
|
|
var events = __nccwpck_require__(4434);
|
|
var assert = __nccwpck_require__(2613);
|
|
var util = __nccwpck_require__(9023);
|
|
|
|
|
|
exports.httpOverHttp = httpOverHttp;
|
|
exports.httpsOverHttp = httpsOverHttp;
|
|
exports.httpOverHttps = httpOverHttps;
|
|
exports.httpsOverHttps = httpsOverHttps;
|
|
|
|
|
|
function httpOverHttp(options) {
|
|
var agent = new TunnelingAgent(options);
|
|
agent.request = http.request;
|
|
return agent;
|
|
}
|
|
|
|
function httpsOverHttp(options) {
|
|
var agent = new TunnelingAgent(options);
|
|
agent.request = http.request;
|
|
agent.createSocket = createSecureSocket;
|
|
agent.defaultPort = 443;
|
|
return agent;
|
|
}
|
|
|
|
function httpOverHttps(options) {
|
|
var agent = new TunnelingAgent(options);
|
|
agent.request = https.request;
|
|
return agent;
|
|
}
|
|
|
|
function httpsOverHttps(options) {
|
|
var agent = new TunnelingAgent(options);
|
|
agent.request = https.request;
|
|
agent.createSocket = createSecureSocket;
|
|
agent.defaultPort = 443;
|
|
return agent;
|
|
}
|
|
|
|
|
|
function TunnelingAgent(options) {
|
|
var self = this;
|
|
self.options = options || {};
|
|
self.proxyOptions = self.options.proxy || {};
|
|
self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets;
|
|
self.requests = [];
|
|
self.sockets = [];
|
|
|
|
self.on('free', function onFree(socket, host, port, localAddress) {
|
|
var options = toOptions(host, port, localAddress);
|
|
for (var i = 0, len = self.requests.length; i < len; ++i) {
|
|
var pending = self.requests[i];
|
|
if (pending.host === options.host && pending.port === options.port) {
|
|
// Detect the request to connect same origin server,
|
|
// reuse the connection.
|
|
self.requests.splice(i, 1);
|
|
pending.request.onSocket(socket);
|
|
return;
|
|
}
|
|
}
|
|
socket.destroy();
|
|
self.removeSocket(socket);
|
|
});
|
|
}
|
|
util.inherits(TunnelingAgent, events.EventEmitter);
|
|
|
|
TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {
|
|
var self = this;
|
|
var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress));
|
|
|
|
if (self.sockets.length >= this.maxSockets) {
|
|
// We are over limit so we'll add it to the queue.
|
|
self.requests.push(options);
|
|
return;
|
|
}
|
|
|
|
// If we are under maxSockets create a new one.
|
|
self.createSocket(options, function(socket) {
|
|
socket.on('free', onFree);
|
|
socket.on('close', onCloseOrRemove);
|
|
socket.on('agentRemove', onCloseOrRemove);
|
|
req.onSocket(socket);
|
|
|
|
function onFree() {
|
|
self.emit('free', socket, options);
|
|
}
|
|
|
|
function onCloseOrRemove(err) {
|
|
self.removeSocket(socket);
|
|
socket.removeListener('free', onFree);
|
|
socket.removeListener('close', onCloseOrRemove);
|
|
socket.removeListener('agentRemove', onCloseOrRemove);
|
|
}
|
|
});
|
|
};
|
|
|
|
TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {
|
|
var self = this;
|
|
var placeholder = {};
|
|
self.sockets.push(placeholder);
|
|
|
|
var connectOptions = mergeOptions({}, self.proxyOptions, {
|
|
method: 'CONNECT',
|
|
path: options.host + ':' + options.port,
|
|
agent: false,
|
|
headers: {
|
|
host: options.host + ':' + options.port
|
|
}
|
|
});
|
|
if (options.localAddress) {
|
|
connectOptions.localAddress = options.localAddress;
|
|
}
|
|
if (connectOptions.proxyAuth) {
|
|
connectOptions.headers = connectOptions.headers || {};
|
|
connectOptions.headers['Proxy-Authorization'] = 'Basic ' +
|
|
new Buffer(connectOptions.proxyAuth).toString('base64');
|
|
}
|
|
|
|
debug('making CONNECT request');
|
|
var connectReq = self.request(connectOptions);
|
|
connectReq.useChunkedEncodingByDefault = false; // for v0.6
|
|
connectReq.once('response', onResponse); // for v0.6
|
|
connectReq.once('upgrade', onUpgrade); // for v0.6
|
|
connectReq.once('connect', onConnect); // for v0.7 or later
|
|
connectReq.once('error', onError);
|
|
connectReq.end();
|
|
|
|
function onResponse(res) {
|
|
// Very hacky. This is necessary to avoid http-parser leaks.
|
|
res.upgrade = true;
|
|
}
|
|
|
|
function onUpgrade(res, socket, head) {
|
|
// Hacky.
|
|
process.nextTick(function() {
|
|
onConnect(res, socket, head);
|
|
});
|
|
}
|
|
|
|
function onConnect(res, socket, head) {
|
|
connectReq.removeAllListeners();
|
|
socket.removeAllListeners();
|
|
|
|
if (res.statusCode !== 200) {
|
|
debug('tunneling socket could not be established, statusCode=%d',
|
|
res.statusCode);
|
|
socket.destroy();
|
|
var error = new Error('tunneling socket could not be established, ' +
|
|
'statusCode=' + res.statusCode);
|
|
error.code = 'ECONNRESET';
|
|
options.request.emit('error', error);
|
|
self.removeSocket(placeholder);
|
|
return;
|
|
}
|
|
if (head.length > 0) {
|
|
debug('got illegal response body from proxy');
|
|
socket.destroy();
|
|
var error = new Error('got illegal response body from proxy');
|
|
error.code = 'ECONNRESET';
|
|
options.request.emit('error', error);
|
|
self.removeSocket(placeholder);
|
|
return;
|
|
}
|
|
debug('tunneling connection has established');
|
|
self.sockets[self.sockets.indexOf(placeholder)] = socket;
|
|
return cb(socket);
|
|
}
|
|
|
|
function onError(cause) {
|
|
connectReq.removeAllListeners();
|
|
|
|
debug('tunneling socket could not be established, cause=%s\n',
|
|
cause.message, cause.stack);
|
|
var error = new Error('tunneling socket could not be established, ' +
|
|
'cause=' + cause.message);
|
|
error.code = 'ECONNRESET';
|
|
options.request.emit('error', error);
|
|
self.removeSocket(placeholder);
|
|
}
|
|
};
|
|
|
|
TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {
|
|
var pos = this.sockets.indexOf(socket)
|
|
if (pos === -1) {
|
|
return;
|
|
}
|
|
this.sockets.splice(pos, 1);
|
|
|
|
var pending = this.requests.shift();
|
|
if (pending) {
|
|
// If we have pending requests and a socket gets closed a new one
|
|
// needs to be created to take over in the pool for the one that closed.
|
|
this.createSocket(pending, function(socket) {
|
|
pending.request.onSocket(socket);
|
|
});
|
|
}
|
|
};
|
|
|
|
function createSecureSocket(options, cb) {
|
|
var self = this;
|
|
TunnelingAgent.prototype.createSocket.call(self, options, function(socket) {
|
|
var hostHeader = options.request.getHeader('host');
|
|
var tlsOptions = mergeOptions({}, self.options, {
|
|
socket: socket,
|
|
servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host
|
|
});
|
|
|
|
// 0 is dummy port for v0.6
|
|
var secureSocket = tls.connect(0, tlsOptions);
|
|
self.sockets[self.sockets.indexOf(socket)] = secureSocket;
|
|
cb(secureSocket);
|
|
});
|
|
}
|
|
|
|
|
|
function toOptions(host, port, localAddress) {
|
|
if (typeof host === 'string') { // since v0.10
|
|
return {
|
|
host: host,
|
|
port: port,
|
|
localAddress: localAddress
|
|
};
|
|
}
|
|
return host; // for v0.11 or later
|
|
}
|
|
|
|
function mergeOptions(target) {
|
|
for (var i = 1, len = arguments.length; i < len; ++i) {
|
|
var overrides = arguments[i];
|
|
if (typeof overrides === 'object') {
|
|
var keys = Object.keys(overrides);
|
|
for (var j = 0, keyLen = keys.length; j < keyLen; ++j) {
|
|
var k = keys[j];
|
|
if (overrides[k] !== undefined) {
|
|
target[k] = overrides[k];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
|
|
|
|
var debug;
|
|
if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) {
|
|
debug = function() {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
if (typeof args[0] === 'string') {
|
|
args[0] = 'TUNNEL: ' + args[0];
|
|
} else {
|
|
args.unshift('TUNNEL:');
|
|
}
|
|
console.error.apply(console, args);
|
|
}
|
|
} else {
|
|
debug = function() {};
|
|
}
|
|
exports.debug = debug; // for test
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6752:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const Client = __nccwpck_require__(3701)
|
|
const Dispatcher = __nccwpck_require__(883)
|
|
const Pool = __nccwpck_require__(628)
|
|
const BalancedPool = __nccwpck_require__(837)
|
|
const Agent = __nccwpck_require__(7405)
|
|
const ProxyAgent = __nccwpck_require__(6672)
|
|
const EnvHttpProxyAgent = __nccwpck_require__(3137)
|
|
const RetryAgent = __nccwpck_require__(50)
|
|
const errors = __nccwpck_require__(8707)
|
|
const util = __nccwpck_require__(3440)
|
|
const { InvalidArgumentError } = errors
|
|
const api = __nccwpck_require__(6615)
|
|
const buildConnector = __nccwpck_require__(9136)
|
|
const MockClient = __nccwpck_require__(7365)
|
|
const MockAgent = __nccwpck_require__(7501)
|
|
const MockPool = __nccwpck_require__(4004)
|
|
const mockErrors = __nccwpck_require__(2429)
|
|
const RetryHandler = __nccwpck_require__(7816)
|
|
const { getGlobalDispatcher, setGlobalDispatcher } = __nccwpck_require__(2581)
|
|
const DecoratorHandler = __nccwpck_require__(8155)
|
|
const RedirectHandler = __nccwpck_require__(8754)
|
|
const createRedirectInterceptor = __nccwpck_require__(5092)
|
|
|
|
Object.assign(Dispatcher.prototype, api)
|
|
|
|
module.exports.Dispatcher = Dispatcher
|
|
module.exports.Client = Client
|
|
module.exports.Pool = Pool
|
|
module.exports.BalancedPool = BalancedPool
|
|
module.exports.Agent = Agent
|
|
module.exports.ProxyAgent = ProxyAgent
|
|
module.exports.EnvHttpProxyAgent = EnvHttpProxyAgent
|
|
module.exports.RetryAgent = RetryAgent
|
|
module.exports.RetryHandler = RetryHandler
|
|
|
|
module.exports.DecoratorHandler = DecoratorHandler
|
|
module.exports.RedirectHandler = RedirectHandler
|
|
module.exports.createRedirectInterceptor = createRedirectInterceptor
|
|
module.exports.interceptors = {
|
|
redirect: __nccwpck_require__(1514),
|
|
retry: __nccwpck_require__(2026),
|
|
dump: __nccwpck_require__(8060),
|
|
dns: __nccwpck_require__(379)
|
|
}
|
|
|
|
module.exports.buildConnector = buildConnector
|
|
module.exports.errors = errors
|
|
module.exports.util = {
|
|
parseHeaders: util.parseHeaders,
|
|
headerNameToString: util.headerNameToString
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
|
|
module.exports.setGlobalDispatcher = setGlobalDispatcher
|
|
module.exports.getGlobalDispatcher = getGlobalDispatcher
|
|
|
|
const fetchImpl = (__nccwpck_require__(4398).fetch)
|
|
module.exports.fetch = async function fetch (init, options = undefined) {
|
|
try {
|
|
return await fetchImpl(init, options)
|
|
} catch (err) {
|
|
if (err && typeof err === 'object') {
|
|
Error.captureStackTrace(err)
|
|
}
|
|
|
|
throw err
|
|
}
|
|
}
|
|
module.exports.Headers = __nccwpck_require__(660).Headers
|
|
module.exports.Response = __nccwpck_require__(9051).Response
|
|
module.exports.Request = __nccwpck_require__(9967).Request
|
|
module.exports.FormData = __nccwpck_require__(5910).FormData
|
|
module.exports.File = globalThis.File ?? (__nccwpck_require__(4573).File)
|
|
module.exports.FileReader = __nccwpck_require__(8355).FileReader
|
|
|
|
const { setGlobalOrigin, getGlobalOrigin } = __nccwpck_require__(1059)
|
|
|
|
module.exports.setGlobalOrigin = setGlobalOrigin
|
|
module.exports.getGlobalOrigin = getGlobalOrigin
|
|
|
|
const { CacheStorage } = __nccwpck_require__(3245)
|
|
const { kConstruct } = __nccwpck_require__(109)
|
|
|
|
// Cache & CacheStorage are tightly coupled with fetch. Even if it may run
|
|
// in an older version of Node, it doesn't have any use without fetch.
|
|
module.exports.caches = new CacheStorage(kConstruct)
|
|
|
|
const { deleteCookie, getCookies, getSetCookies, setCookie } = __nccwpck_require__(9061)
|
|
|
|
module.exports.deleteCookie = deleteCookie
|
|
module.exports.getCookies = getCookies
|
|
module.exports.getSetCookies = getSetCookies
|
|
module.exports.setCookie = setCookie
|
|
|
|
const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(1900)
|
|
|
|
module.exports.parseMIMEType = parseMIMEType
|
|
module.exports.serializeAMimeType = serializeAMimeType
|
|
|
|
const { CloseEvent, ErrorEvent, MessageEvent } = __nccwpck_require__(5188)
|
|
module.exports.WebSocket = __nccwpck_require__(3726).WebSocket
|
|
module.exports.CloseEvent = CloseEvent
|
|
module.exports.ErrorEvent = ErrorEvent
|
|
module.exports.MessageEvent = MessageEvent
|
|
|
|
module.exports.request = makeDispatcher(api.request)
|
|
module.exports.stream = makeDispatcher(api.stream)
|
|
module.exports.pipeline = makeDispatcher(api.pipeline)
|
|
module.exports.connect = makeDispatcher(api.connect)
|
|
module.exports.upgrade = makeDispatcher(api.upgrade)
|
|
|
|
module.exports.MockClient = MockClient
|
|
module.exports.MockPool = MockPool
|
|
module.exports.MockAgent = MockAgent
|
|
module.exports.mockErrors = mockErrors
|
|
|
|
const { EventSource } = __nccwpck_require__(1238)
|
|
|
|
module.exports.EventSource = EventSource
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 158:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
const { addAbortListener } = __nccwpck_require__(3440)
|
|
const { RequestAbortedError } = __nccwpck_require__(8707)
|
|
|
|
const kListener = Symbol('kListener')
|
|
const kSignal = Symbol('kSignal')
|
|
|
|
function abort (self) {
|
|
if (self.abort) {
|
|
self.abort(self[kSignal]?.reason)
|
|
} else {
|
|
self.reason = self[kSignal]?.reason ?? new RequestAbortedError()
|
|
}
|
|
removeSignal(self)
|
|
}
|
|
|
|
function addSignal (self, signal) {
|
|
self.reason = null
|
|
|
|
self[kSignal] = null
|
|
self[kListener] = null
|
|
|
|
if (!signal) {
|
|
return
|
|
}
|
|
|
|
if (signal.aborted) {
|
|
abort(self)
|
|
return
|
|
}
|
|
|
|
self[kSignal] = signal
|
|
self[kListener] = () => {
|
|
abort(self)
|
|
}
|
|
|
|
addAbortListener(self[kSignal], 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
|
|
}
|
|
|
|
module.exports = {
|
|
addSignal,
|
|
removeSignal
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2279:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const assert = __nccwpck_require__(4589)
|
|
const { AsyncResource } = __nccwpck_require__(6698)
|
|
const { InvalidArgumentError, SocketError } = __nccwpck_require__(8707)
|
|
const util = __nccwpck_require__(3440)
|
|
const { addSignal, removeSignal } = __nccwpck_require__(158)
|
|
|
|
class ConnectHandler 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.reason) {
|
|
abort(this.reason)
|
|
return
|
|
}
|
|
|
|
assert(this.callback)
|
|
|
|
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
|
|
|
|
let headers = rawHeaders
|
|
// Indicates is an HTTP2Session
|
|
if (headers != null) {
|
|
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 === undefined) {
|
|
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?.opaque
|
|
queueMicrotask(() => callback(err, { opaque }))
|
|
}
|
|
}
|
|
|
|
module.exports = connect
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6862:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const {
|
|
Readable,
|
|
Duplex,
|
|
PassThrough
|
|
} = __nccwpck_require__(7075)
|
|
const {
|
|
InvalidArgumentError,
|
|
InvalidReturnValueError,
|
|
RequestAbortedError
|
|
} = __nccwpck_require__(8707)
|
|
const util = __nccwpck_require__(3440)
|
|
const { AsyncResource } = __nccwpck_require__(6698)
|
|
const { addSignal, removeSignal } = __nccwpck_require__(158)
|
|
const assert = __nccwpck_require__(4589)
|
|
|
|
const kResume = Symbol('resume')
|
|
|
|
class PipelineRequest 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)
|
|
}
|
|
}
|
|
|
|
class PipelineResponse 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)
|
|
}
|
|
}
|
|
|
|
class PipelineHandler 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?.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
|
|
|
|
// Node < 15 does not call _final in same tick.
|
|
req.push(null)
|
|
})
|
|
|
|
this.res = null
|
|
|
|
addSignal(this, signal)
|
|
}
|
|
|
|
onConnect (abort, context) {
|
|
const { ret, res } = this
|
|
|
|
if (this.reason) {
|
|
abort(this.reason)
|
|
return
|
|
}
|
|
|
|
assert(!res, 'pipeline cannot be retried')
|
|
assert(!ret.destroyed)
|
|
|
|
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 } = this
|
|
|
|
if (!ret.push(chunk) && body.pause) {
|
|
body.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)
|
|
}
|
|
}
|
|
|
|
module.exports = pipeline
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4043:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const assert = __nccwpck_require__(4589)
|
|
const { Readable } = __nccwpck_require__(9927)
|
|
const { InvalidArgumentError, RequestAbortedError } = __nccwpck_require__(8707)
|
|
const util = __nccwpck_require__(3440)
|
|
const { getResolveErrorBodyCallback } = __nccwpck_require__(7655)
|
|
const { AsyncResource } = __nccwpck_require__(6698)
|
|
|
|
class RequestHandler extends AsyncResource {
|
|
constructor (opts, callback) {
|
|
if (!opts || typeof opts !== 'object') {
|
|
throw new InvalidArgumentError('invalid opts')
|
|
}
|
|
|
|
const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts
|
|
|
|
try {
|
|
if (typeof callback !== 'function') {
|
|
throw new InvalidArgumentError('invalid callback')
|
|
}
|
|
|
|
if (highWaterMark && (typeof highWaterMark !== 'number' || highWaterMark < 0)) {
|
|
throw new InvalidArgumentError('invalid highWaterMark')
|
|
}
|
|
|
|
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.method = method
|
|
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
|
|
this.highWaterMark = highWaterMark
|
|
this.signal = signal
|
|
this.reason = null
|
|
this.removeAbortListener = null
|
|
|
|
if (util.isStream(body)) {
|
|
body.on('error', (err) => {
|
|
this.onError(err)
|
|
})
|
|
}
|
|
|
|
if (this.signal) {
|
|
if (this.signal.aborted) {
|
|
this.reason = this.signal.reason ?? new RequestAbortedError()
|
|
} else {
|
|
this.removeAbortListener = util.addAbortListener(this.signal, () => {
|
|
this.reason = this.signal.reason ?? new RequestAbortedError()
|
|
if (this.res) {
|
|
util.destroy(this.res.on('error', util.nop), this.reason)
|
|
} else if (this.abort) {
|
|
this.abort(this.reason)
|
|
}
|
|
|
|
if (this.removeAbortListener) {
|
|
this.res?.off('close', this.removeAbortListener)
|
|
this.removeAbortListener()
|
|
this.removeAbortListener = null
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
onConnect (abort, context) {
|
|
if (this.reason) {
|
|
abort(this.reason)
|
|
return
|
|
}
|
|
|
|
assert(this.callback)
|
|
|
|
this.abort = abort
|
|
this.context = context
|
|
}
|
|
|
|
onHeaders (statusCode, rawHeaders, resume, statusMessage) {
|
|
const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this
|
|
|
|
const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
|
|
|
|
if (statusCode < 200) {
|
|
if (this.onInfo) {
|
|
this.onInfo({ statusCode, headers })
|
|
}
|
|
return
|
|
}
|
|
|
|
const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers
|
|
const contentType = parsedHeaders['content-type']
|
|
const contentLength = parsedHeaders['content-length']
|
|
const res = new Readable({
|
|
resume,
|
|
abort,
|
|
contentType,
|
|
contentLength: this.method !== 'HEAD' && contentLength
|
|
? Number(contentLength)
|
|
: null,
|
|
highWaterMark
|
|
})
|
|
|
|
if (this.removeAbortListener) {
|
|
res.on('close', this.removeAbortListener)
|
|
}
|
|
|
|
this.callback = null
|
|
this.res = res
|
|
if (callback !== null) {
|
|
if (this.throwOnError && statusCode >= 400) {
|
|
this.runInAsyncScope(getResolveErrorBodyCallback, null,
|
|
{ callback, body: res, contentType, statusCode, statusMessage, headers }
|
|
)
|
|
} else {
|
|
this.runInAsyncScope(callback, null, null, {
|
|
statusCode,
|
|
headers,
|
|
trailers: this.trailers,
|
|
opaque,
|
|
body: res,
|
|
context
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
onData (chunk) {
|
|
return this.res.push(chunk)
|
|
}
|
|
|
|
onComplete (trailers) {
|
|
util.parseHeaders(trailers, this.trailers)
|
|
this.res.push(null)
|
|
}
|
|
|
|
onError (err) {
|
|
const { res, callback, body, opaque } = this
|
|
|
|
if (callback) {
|
|
// TODO: Does this need queueMicrotask?
|
|
this.callback = null
|
|
queueMicrotask(() => {
|
|
this.runInAsyncScope(callback, null, err, { opaque })
|
|
})
|
|
}
|
|
|
|
if (res) {
|
|
this.res = null
|
|
// Ensure all queued handlers are invoked before destroying res.
|
|
queueMicrotask(() => {
|
|
util.destroy(res, err)
|
|
})
|
|
}
|
|
|
|
if (body) {
|
|
this.body = null
|
|
util.destroy(body, err)
|
|
}
|
|
|
|
if (this.removeAbortListener) {
|
|
res?.off('close', this.removeAbortListener)
|
|
this.removeAbortListener()
|
|
this.removeAbortListener = null
|
|
}
|
|
}
|
|
}
|
|
|
|
function request (opts, callback) {
|
|
if (callback === undefined) {
|
|
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?.opaque
|
|
queueMicrotask(() => callback(err, { opaque }))
|
|
}
|
|
}
|
|
|
|
module.exports = request
|
|
module.exports.RequestHandler = RequestHandler
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3560:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const assert = __nccwpck_require__(4589)
|
|
const { finished, PassThrough } = __nccwpck_require__(7075)
|
|
const { InvalidArgumentError, InvalidReturnValueError } = __nccwpck_require__(8707)
|
|
const util = __nccwpck_require__(3440)
|
|
const { getResolveErrorBodyCallback } = __nccwpck_require__(7655)
|
|
const { AsyncResource } = __nccwpck_require__(6698)
|
|
const { addSignal, removeSignal } = __nccwpck_require__(158)
|
|
|
|
class StreamHandler extends AsyncResource {
|
|
constructor (opts, factory, 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 (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
|
|
this.throwOnError = throwOnError || false
|
|
|
|
if (util.isStream(body)) {
|
|
body.on('error', (err) => {
|
|
this.onError(err)
|
|
})
|
|
}
|
|
|
|
addSignal(this, signal)
|
|
}
|
|
|
|
onConnect (abort, context) {
|
|
if (this.reason) {
|
|
abort(this.reason)
|
|
return
|
|
}
|
|
|
|
assert(this.callback)
|
|
|
|
this.abort = abort
|
|
this.context = context
|
|
}
|
|
|
|
onHeaders (statusCode, rawHeaders, resume, statusMessage) {
|
|
const { factory, opaque, context, callback, responseHeaders } = this
|
|
|
|
const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
|
|
|
|
if (statusCode < 200) {
|
|
if (this.onInfo) {
|
|
this.onInfo({ statusCode, headers })
|
|
}
|
|
return
|
|
}
|
|
|
|
this.factory = null
|
|
|
|
let res
|
|
|
|
if (this.throwOnError && statusCode >= 400) {
|
|
const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers
|
|
const contentType = parsedHeaders['content-type']
|
|
res = new PassThrough()
|
|
|
|
this.callback = null
|
|
this.runInAsyncScope(getResolveErrorBodyCallback, null,
|
|
{ callback, body: res, contentType, statusCode, statusMessage, headers }
|
|
)
|
|
} else {
|
|
if (factory === null) {
|
|
return
|
|
}
|
|
|
|
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')
|
|
}
|
|
|
|
// TODO: Avoid finished. It registers an unnecessary amount of listeners.
|
|
finished(res, { readable: false }, (err) => {
|
|
const { callback, res, opaque, trailers, abort } = this
|
|
|
|
this.res = null
|
|
if (err || !res.readable) {
|
|
util.destroy(res, err)
|
|
}
|
|
|
|
this.callback = null
|
|
this.runInAsyncScope(callback, null, err || null, { opaque, trailers })
|
|
|
|
if (err) {
|
|
abort()
|
|
}
|
|
})
|
|
}
|
|
|
|
res.on('drain', resume)
|
|
|
|
this.res = res
|
|
|
|
const needDrain = res.writableNeedDrain !== undefined
|
|
? res.writableNeedDrain
|
|
: res._writableState?.needDrain
|
|
|
|
return needDrain !== true
|
|
}
|
|
|
|
onData (chunk) {
|
|
const { res } = this
|
|
|
|
return res ? res.write(chunk) : true
|
|
}
|
|
|
|
onComplete (trailers) {
|
|
const { res } = this
|
|
|
|
removeSignal(this)
|
|
|
|
if (!res) {
|
|
return
|
|
}
|
|
|
|
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 === undefined) {
|
|
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?.opaque
|
|
queueMicrotask(() => callback(err, { opaque }))
|
|
}
|
|
}
|
|
|
|
module.exports = stream
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1882:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { InvalidArgumentError, SocketError } = __nccwpck_require__(8707)
|
|
const { AsyncResource } = __nccwpck_require__(6698)
|
|
const util = __nccwpck_require__(3440)
|
|
const { addSignal, removeSignal } = __nccwpck_require__(158)
|
|
const assert = __nccwpck_require__(4589)
|
|
|
|
class UpgradeHandler 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.reason) {
|
|
abort(this.reason)
|
|
return
|
|
}
|
|
|
|
assert(this.callback)
|
|
|
|
this.abort = abort
|
|
this.context = null
|
|
}
|
|
|
|
onHeaders () {
|
|
throw new SocketError('bad upgrade', null)
|
|
}
|
|
|
|
onUpgrade (statusCode, rawHeaders, socket) {
|
|
assert(statusCode === 101)
|
|
|
|
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, {
|
|
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 === undefined) {
|
|
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?.opaque
|
|
queueMicrotask(() => callback(err, { opaque }))
|
|
}
|
|
}
|
|
|
|
module.exports = upgrade
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6615:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
module.exports.request = __nccwpck_require__(4043)
|
|
module.exports.stream = __nccwpck_require__(3560)
|
|
module.exports.pipeline = __nccwpck_require__(6862)
|
|
module.exports.upgrade = __nccwpck_require__(1882)
|
|
module.exports.connect = __nccwpck_require__(2279)
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9927:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
// Ported from https://github.com/nodejs/undici/pull/907
|
|
|
|
|
|
|
|
const assert = __nccwpck_require__(4589)
|
|
const { Readable } = __nccwpck_require__(7075)
|
|
const { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = __nccwpck_require__(8707)
|
|
const util = __nccwpck_require__(3440)
|
|
const { ReadableStreamFrom } = __nccwpck_require__(3440)
|
|
|
|
const kConsume = Symbol('kConsume')
|
|
const kReading = Symbol('kReading')
|
|
const kBody = Symbol('kBody')
|
|
const kAbort = Symbol('kAbort')
|
|
const kContentType = Symbol('kContentType')
|
|
const kContentLength = Symbol('kContentLength')
|
|
|
|
const noop = () => {}
|
|
|
|
class BodyReadable extends Readable {
|
|
constructor ({
|
|
resume,
|
|
abort,
|
|
contentType = '',
|
|
contentLength,
|
|
highWaterMark = 64 * 1024 // Same as nodejs fs streams.
|
|
}) {
|
|
super({
|
|
autoDestroy: true,
|
|
read: resume,
|
|
highWaterMark
|
|
})
|
|
|
|
this._readableState.dataEmitted = false
|
|
|
|
this[kAbort] = abort
|
|
this[kConsume] = null
|
|
this[kBody] = null
|
|
this[kContentType] = contentType
|
|
this[kContentLength] = contentLength
|
|
|
|
// Is stream being consumed through Readable API?
|
|
// This is an optimization so that we avoid checking
|
|
// for 'data' and 'readable' listeners in the hot path
|
|
// inside push().
|
|
this[kReading] = false
|
|
}
|
|
|
|
destroy (err) {
|
|
if (!err && !this._readableState.endEmitted) {
|
|
err = new RequestAbortedError()
|
|
}
|
|
|
|
if (err) {
|
|
this[kAbort]()
|
|
}
|
|
|
|
return super.destroy(err)
|
|
}
|
|
|
|
_destroy (err, callback) {
|
|
// Workaround for Node "bug". If the stream is destroyed in same
|
|
// tick as it is created, then a user who is waiting for a
|
|
// promise (i.e micro tick) for installing a 'error' listener will
|
|
// never get a chance and will always encounter an unhandled exception.
|
|
if (!this[kReading]) {
|
|
setImmediate(() => {
|
|
callback(err)
|
|
})
|
|
} else {
|
|
callback(err)
|
|
}
|
|
}
|
|
|
|
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) {
|
|
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-bytes
|
|
async bytes () {
|
|
return consume(this, 'bytes')
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#dom-body-arraybuffer
|
|
async arrayBuffer () {
|
|
return consume(this, 'arrayBuffer')
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#dom-body-formdata
|
|
async formData () {
|
|
// TODO: Implement.
|
|
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]) {
|
|
// TODO: Is this the best way to force a lock?
|
|
this[kBody].getReader() // Ensure stream is locked.
|
|
assert(this[kBody].locked)
|
|
}
|
|
}
|
|
return this[kBody]
|
|
}
|
|
|
|
async dump (opts) {
|
|
let limit = Number.isFinite(opts?.limit) ? opts.limit : 128 * 1024
|
|
const signal = opts?.signal
|
|
|
|
if (signal != null && (typeof signal !== 'object' || !('aborted' in signal))) {
|
|
throw new InvalidArgumentError('signal must be an AbortSignal')
|
|
}
|
|
|
|
signal?.throwIfAborted()
|
|
|
|
if (this._readableState.closeEmitted) {
|
|
return null
|
|
}
|
|
|
|
return await new Promise((resolve, reject) => {
|
|
if (this[kContentLength] > limit) {
|
|
this.destroy(new AbortError())
|
|
}
|
|
|
|
const onAbort = () => {
|
|
this.destroy(signal.reason ?? new AbortError())
|
|
}
|
|
signal?.addEventListener('abort', onAbort)
|
|
|
|
this
|
|
.on('close', function () {
|
|
signal?.removeEventListener('abort', onAbort)
|
|
if (signal?.aborted) {
|
|
reject(signal.reason ?? new AbortError())
|
|
} else {
|
|
resolve(null)
|
|
}
|
|
})
|
|
.on('error', noop)
|
|
.on('data', function (chunk) {
|
|
limit -= chunk.length
|
|
if (limit <= 0) {
|
|
this.destroy()
|
|
}
|
|
})
|
|
.resume()
|
|
})
|
|
}
|
|
}
|
|
|
|
// https://streams.spec.whatwg.org/#readablestream-locked
|
|
function isLocked (self) {
|
|
// Consume is an implicit lock.
|
|
return (self[kBody] && self[kBody].locked === true) || self[kConsume]
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#body-unusable
|
|
function isUnusable (self) {
|
|
return util.isDisturbed(self) || isLocked(self)
|
|
}
|
|
|
|
async function consume (stream, type) {
|
|
assert(!stream[kConsume])
|
|
|
|
return new Promise((resolve, reject) => {
|
|
if (isUnusable(stream)) {
|
|
const rState = stream._readableState
|
|
if (rState.destroyed && rState.closeEmitted === false) {
|
|
stream
|
|
.on('error', err => {
|
|
reject(err)
|
|
})
|
|
.on('close', () => {
|
|
reject(new TypeError('unusable'))
|
|
})
|
|
} else {
|
|
reject(rState.errored ?? new TypeError('unusable'))
|
|
}
|
|
} else {
|
|
queueMicrotask(() => {
|
|
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())
|
|
}
|
|
})
|
|
|
|
consumeStart(stream[kConsume])
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
function consumeStart (consume) {
|
|
if (consume.body === null) {
|
|
return
|
|
}
|
|
|
|
const { _readableState: state } = consume.stream
|
|
|
|
if (state.bufferIndex) {
|
|
const start = state.bufferIndex
|
|
const end = state.buffer.length
|
|
for (let n = start; n < end; n++) {
|
|
consumePush(consume, state.buffer[n])
|
|
}
|
|
} else {
|
|
for (const chunk of state.buffer) {
|
|
consumePush(consume, chunk)
|
|
}
|
|
}
|
|
|
|
if (state.endEmitted) {
|
|
consumeEnd(this[kConsume])
|
|
} else {
|
|
consume.stream.on('end', function () {
|
|
consumeEnd(this[kConsume])
|
|
})
|
|
}
|
|
|
|
consume.stream.resume()
|
|
|
|
while (consume.stream.read() != null) {
|
|
// Loop
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Buffer[]} chunks
|
|
* @param {number} length
|
|
*/
|
|
function chunksDecode (chunks, length) {
|
|
if (chunks.length === 0 || length === 0) {
|
|
return ''
|
|
}
|
|
const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, length)
|
|
const bufferLength = buffer.length
|
|
|
|
// Skip BOM.
|
|
const start =
|
|
bufferLength > 2 &&
|
|
buffer[0] === 0xef &&
|
|
buffer[1] === 0xbb &&
|
|
buffer[2] === 0xbf
|
|
? 3
|
|
: 0
|
|
return buffer.utf8Slice(start, bufferLength)
|
|
}
|
|
|
|
/**
|
|
* @param {Buffer[]} chunks
|
|
* @param {number} length
|
|
* @returns {Uint8Array}
|
|
*/
|
|
function chunksConcat (chunks, length) {
|
|
if (chunks.length === 0 || length === 0) {
|
|
return new Uint8Array(0)
|
|
}
|
|
if (chunks.length === 1) {
|
|
// fast-path
|
|
return new Uint8Array(chunks[0])
|
|
}
|
|
const buffer = new Uint8Array(Buffer.allocUnsafeSlow(length).buffer)
|
|
|
|
let offset = 0
|
|
for (let i = 0; i < chunks.length; ++i) {
|
|
const chunk = chunks[i]
|
|
buffer.set(chunk, offset)
|
|
offset += chunk.length
|
|
}
|
|
|
|
return buffer
|
|
}
|
|
|
|
function consumeEnd (consume) {
|
|
const { type, body, resolve, stream, length } = consume
|
|
|
|
try {
|
|
if (type === 'text') {
|
|
resolve(chunksDecode(body, length))
|
|
} else if (type === 'json') {
|
|
resolve(JSON.parse(chunksDecode(body, length)))
|
|
} else if (type === 'arrayBuffer') {
|
|
resolve(chunksConcat(body, length).buffer)
|
|
} else if (type === 'blob') {
|
|
resolve(new Blob(body, { type: stream[kContentType] }))
|
|
} else if (type === 'bytes') {
|
|
resolve(chunksConcat(body, length))
|
|
}
|
|
|
|
consumeFinish(consume)
|
|
} catch (err) {
|
|
stream.destroy(err)
|
|
}
|
|
}
|
|
|
|
function consumePush (consume, chunk) {
|
|
consume.length += chunk.length
|
|
consume.body.push(chunk)
|
|
}
|
|
|
|
function consumeFinish (consume, err) {
|
|
if (consume.body === null) {
|
|
return
|
|
}
|
|
|
|
if (err) {
|
|
consume.reject(err)
|
|
} else {
|
|
consume.resolve()
|
|
}
|
|
|
|
consume.type = null
|
|
consume.stream = null
|
|
consume.resolve = null
|
|
consume.reject = null
|
|
consume.length = 0
|
|
consume.body = null
|
|
}
|
|
|
|
module.exports = { Readable: BodyReadable, chunksDecode }
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7655:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
const assert = __nccwpck_require__(4589)
|
|
const {
|
|
ResponseStatusCodeError
|
|
} = __nccwpck_require__(8707)
|
|
|
|
const { chunksDecode } = __nccwpck_require__(9927)
|
|
const CHUNK_LIMIT = 128 * 1024
|
|
|
|
async function getResolveErrorBodyCallback ({ callback, body, contentType, statusCode, statusMessage, headers }) {
|
|
assert(body)
|
|
|
|
let chunks = []
|
|
let length = 0
|
|
|
|
try {
|
|
for await (const chunk of body) {
|
|
chunks.push(chunk)
|
|
length += chunk.length
|
|
if (length > CHUNK_LIMIT) {
|
|
chunks = []
|
|
length = 0
|
|
break
|
|
}
|
|
}
|
|
} catch {
|
|
chunks = []
|
|
length = 0
|
|
// Do nothing....
|
|
}
|
|
|
|
const message = `Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`
|
|
|
|
if (statusCode === 204 || !contentType || !length) {
|
|
queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers)))
|
|
return
|
|
}
|
|
|
|
const stackTraceLimit = Error.stackTraceLimit
|
|
Error.stackTraceLimit = 0
|
|
let payload
|
|
|
|
try {
|
|
if (isContentTypeApplicationJson(contentType)) {
|
|
payload = JSON.parse(chunksDecode(chunks, length))
|
|
} else if (isContentTypeText(contentType)) {
|
|
payload = chunksDecode(chunks, length)
|
|
}
|
|
} catch {
|
|
// process in a callback to avoid throwing in the microtask queue
|
|
} finally {
|
|
Error.stackTraceLimit = stackTraceLimit
|
|
}
|
|
queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers, payload)))
|
|
}
|
|
|
|
const isContentTypeApplicationJson = (contentType) => {
|
|
return (
|
|
contentType.length > 15 &&
|
|
contentType[11] === '/' &&
|
|
contentType[0] === 'a' &&
|
|
contentType[1] === 'p' &&
|
|
contentType[2] === 'p' &&
|
|
contentType[3] === 'l' &&
|
|
contentType[4] === 'i' &&
|
|
contentType[5] === 'c' &&
|
|
contentType[6] === 'a' &&
|
|
contentType[7] === 't' &&
|
|
contentType[8] === 'i' &&
|
|
contentType[9] === 'o' &&
|
|
contentType[10] === 'n' &&
|
|
contentType[12] === 'j' &&
|
|
contentType[13] === 's' &&
|
|
contentType[14] === 'o' &&
|
|
contentType[15] === 'n'
|
|
)
|
|
}
|
|
|
|
const isContentTypeText = (contentType) => {
|
|
return (
|
|
contentType.length > 4 &&
|
|
contentType[4] === '/' &&
|
|
contentType[0] === 't' &&
|
|
contentType[1] === 'e' &&
|
|
contentType[2] === 'x' &&
|
|
contentType[3] === 't'
|
|
)
|
|
}
|
|
|
|
module.exports = {
|
|
getResolveErrorBodyCallback,
|
|
isContentTypeApplicationJson,
|
|
isContentTypeText
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9136:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const net = __nccwpck_require__(7030)
|
|
const assert = __nccwpck_require__(4589)
|
|
const util = __nccwpck_require__(3440)
|
|
const { InvalidArgumentError, ConnectTimeoutError } = __nccwpck_require__(8707)
|
|
const timers = __nccwpck_require__(6603)
|
|
|
|
function noop () {}
|
|
|
|
let tls // include tls conditionally since it is not always available
|
|
|
|
// TODO: session re-use does not wait for the first
|
|
// connection to resolve the session and might therefore
|
|
// resolve the same servername multiple times even when
|
|
// re-use is enabled.
|
|
|
|
let SessionCache
|
|
// FIXME: remove workaround when the Node bug is fixed
|
|
// https://github.com/nodejs/node/issues/49344#issuecomment-1741776308
|
|
if (global.FinalizationRegistry && !(process.env.NODE_V8_COVERAGE || process.env.UNDICI_NO_FG)) {
|
|
SessionCache = class WeakSessionCache {
|
|
constructor (maxCachedSessions) {
|
|
this._maxCachedSessions = maxCachedSessions
|
|
this._sessionCache = new Map()
|
|
this._sessionRegistry = new global.FinalizationRegistry((key) => {
|
|
if (this._sessionCache.size < this._maxCachedSessions) {
|
|
return
|
|
}
|
|
|
|
const ref = this._sessionCache.get(key)
|
|
if (ref !== undefined && ref.deref() === undefined) {
|
|
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 = new Map()
|
|
}
|
|
|
|
get (sessionKey) {
|
|
return this._sessionCache.get(sessionKey)
|
|
}
|
|
|
|
set (sessionKey, session) {
|
|
if (this._maxCachedSessions === 0) {
|
|
return
|
|
}
|
|
|
|
if (this._sessionCache.size >= this._maxCachedSessions) {
|
|
// remove the oldest session
|
|
const { value: oldestKey } = this._sessionCache.keys().next()
|
|
this._sessionCache.delete(oldestKey)
|
|
}
|
|
|
|
this._sessionCache.set(sessionKey, session)
|
|
}
|
|
}
|
|
}
|
|
|
|
function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
|
|
if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
|
|
throw new InvalidArgumentError('maxCachedSessions must be a positive integer or zero')
|
|
}
|
|
|
|
const options = { path: socketPath, ...opts }
|
|
const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions)
|
|
timeout = timeout == null ? 10e3 : timeout
|
|
allowH2 = allowH2 != null ? allowH2 : false
|
|
return function connect ({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
|
|
let socket
|
|
if (protocol === 'https:') {
|
|
if (!tls) {
|
|
tls = __nccwpck_require__(1692)
|
|
}
|
|
servername = servername || options.servername || util.getServerName(host) || null
|
|
|
|
const sessionKey = servername || hostname
|
|
assert(sessionKey)
|
|
|
|
const session = customSession || sessionCache.get(sessionKey) || null
|
|
|
|
port = port || 443
|
|
|
|
socket = tls.connect({
|
|
highWaterMark: 16384, // TLS in node can't have bigger HWM anyway...
|
|
...options,
|
|
servername,
|
|
session,
|
|
localAddress,
|
|
// TODO(HTTP/2): Add support for h2c
|
|
ALPNProtocols: allowH2 ? ['http/1.1', 'h2'] : ['http/1.1'],
|
|
socket: httpSocket, // upgrade socket connection
|
|
port,
|
|
host: hostname
|
|
})
|
|
|
|
socket
|
|
.on('session', function (session) {
|
|
// TODO (fix): Can a session become invalid once established? Don't think so?
|
|
sessionCache.set(sessionKey, session)
|
|
})
|
|
} else {
|
|
assert(!httpSocket, 'httpSocket can only be sent on TLS update')
|
|
|
|
port = port || 80
|
|
|
|
socket = net.connect({
|
|
highWaterMark: 64 * 1024, // Same as nodejs fs streams.
|
|
...options,
|
|
localAddress,
|
|
port,
|
|
host: hostname
|
|
})
|
|
}
|
|
|
|
// Set TCP keep alive options on the socket here instead of in connect() for the case of assigning the socket
|
|
if (options.keepAlive == null || options.keepAlive) {
|
|
const keepAliveInitialDelay = options.keepAliveInitialDelay === undefined ? 60e3 : options.keepAliveInitialDelay
|
|
socket.setKeepAlive(true, keepAliveInitialDelay)
|
|
}
|
|
|
|
const clearConnectTimeout = setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port })
|
|
|
|
socket
|
|
.setNoDelay(true)
|
|
.once(protocol === 'https:' ? 'secureConnect' : 'connect', function () {
|
|
queueMicrotask(clearConnectTimeout)
|
|
|
|
if (callback) {
|
|
const cb = callback
|
|
callback = null
|
|
cb(null, this)
|
|
}
|
|
})
|
|
.on('error', function (err) {
|
|
queueMicrotask(clearConnectTimeout)
|
|
|
|
if (callback) {
|
|
const cb = callback
|
|
callback = null
|
|
cb(err)
|
|
}
|
|
})
|
|
|
|
return socket
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {WeakRef<net.Socket>} socketWeakRef
|
|
* @param {object} opts
|
|
* @param {number} opts.timeout
|
|
* @param {string} opts.hostname
|
|
* @param {number} opts.port
|
|
* @returns {() => void}
|
|
*/
|
|
const setupConnectTimeout = process.platform === 'win32'
|
|
? (socketWeakRef, opts) => {
|
|
if (!opts.timeout) {
|
|
return noop
|
|
}
|
|
|
|
let s1 = null
|
|
let s2 = null
|
|
const fastTimer = timers.setFastTimeout(() => {
|
|
// setImmediate is added to make sure that we prioritize socket error events over timeouts
|
|
s1 = setImmediate(() => {
|
|
// Windows needs an extra setImmediate probably due to implementation differences in the socket logic
|
|
s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts))
|
|
})
|
|
}, opts.timeout)
|
|
return () => {
|
|
timers.clearFastTimeout(fastTimer)
|
|
clearImmediate(s1)
|
|
clearImmediate(s2)
|
|
}
|
|
}
|
|
: (socketWeakRef, opts) => {
|
|
if (!opts.timeout) {
|
|
return noop
|
|
}
|
|
|
|
let s1 = null
|
|
const fastTimer = timers.setFastTimeout(() => {
|
|
// setImmediate is added to make sure that we prioritize socket error events over timeouts
|
|
s1 = setImmediate(() => {
|
|
onConnectTimeout(socketWeakRef.deref(), opts)
|
|
})
|
|
}, opts.timeout)
|
|
return () => {
|
|
timers.clearFastTimeout(fastTimer)
|
|
clearImmediate(s1)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {net.Socket} socket
|
|
* @param {object} opts
|
|
* @param {number} opts.timeout
|
|
* @param {string} opts.hostname
|
|
* @param {number} opts.port
|
|
*/
|
|
function onConnectTimeout (socket, opts) {
|
|
// The socket could be already garbage collected
|
|
if (socket == null) {
|
|
return
|
|
}
|
|
|
|
let message = 'Connect Timeout Error'
|
|
if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
|
|
message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(', ')},`
|
|
} else {
|
|
message += ` (attempted address: ${opts.hostname}:${opts.port},`
|
|
}
|
|
|
|
message += ` timeout: ${opts.timeout}ms)`
|
|
|
|
util.destroy(socket, new ConnectTimeoutError(message))
|
|
}
|
|
|
|
module.exports = buildConnector
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 735:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
/** @type {Record<string, string | undefined>} */
|
|
const headerNameLowerCasedRecord = {}
|
|
|
|
// https://developer.mozilla.org/docs/Web/HTTP/Headers
|
|
const wellknownHeaderNames = [
|
|
'Accept',
|
|
'Accept-Encoding',
|
|
'Accept-Language',
|
|
'Accept-Ranges',
|
|
'Access-Control-Allow-Credentials',
|
|
'Access-Control-Allow-Headers',
|
|
'Access-Control-Allow-Methods',
|
|
'Access-Control-Allow-Origin',
|
|
'Access-Control-Expose-Headers',
|
|
'Access-Control-Max-Age',
|
|
'Access-Control-Request-Headers',
|
|
'Access-Control-Request-Method',
|
|
'Age',
|
|
'Allow',
|
|
'Alt-Svc',
|
|
'Alt-Used',
|
|
'Authorization',
|
|
'Cache-Control',
|
|
'Clear-Site-Data',
|
|
'Connection',
|
|
'Content-Disposition',
|
|
'Content-Encoding',
|
|
'Content-Language',
|
|
'Content-Length',
|
|
'Content-Location',
|
|
'Content-Range',
|
|
'Content-Security-Policy',
|
|
'Content-Security-Policy-Report-Only',
|
|
'Content-Type',
|
|
'Cookie',
|
|
'Cross-Origin-Embedder-Policy',
|
|
'Cross-Origin-Opener-Policy',
|
|
'Cross-Origin-Resource-Policy',
|
|
'Date',
|
|
'Device-Memory',
|
|
'Downlink',
|
|
'ECT',
|
|
'ETag',
|
|
'Expect',
|
|
'Expect-CT',
|
|
'Expires',
|
|
'Forwarded',
|
|
'From',
|
|
'Host',
|
|
'If-Match',
|
|
'If-Modified-Since',
|
|
'If-None-Match',
|
|
'If-Range',
|
|
'If-Unmodified-Since',
|
|
'Keep-Alive',
|
|
'Last-Modified',
|
|
'Link',
|
|
'Location',
|
|
'Max-Forwards',
|
|
'Origin',
|
|
'Permissions-Policy',
|
|
'Pragma',
|
|
'Proxy-Authenticate',
|
|
'Proxy-Authorization',
|
|
'RTT',
|
|
'Range',
|
|
'Referer',
|
|
'Referrer-Policy',
|
|
'Refresh',
|
|
'Retry-After',
|
|
'Sec-WebSocket-Accept',
|
|
'Sec-WebSocket-Extensions',
|
|
'Sec-WebSocket-Key',
|
|
'Sec-WebSocket-Protocol',
|
|
'Sec-WebSocket-Version',
|
|
'Server',
|
|
'Server-Timing',
|
|
'Service-Worker-Allowed',
|
|
'Service-Worker-Navigation-Preload',
|
|
'Set-Cookie',
|
|
'SourceMap',
|
|
'Strict-Transport-Security',
|
|
'Supports-Loading-Mode',
|
|
'TE',
|
|
'Timing-Allow-Origin',
|
|
'Trailer',
|
|
'Transfer-Encoding',
|
|
'Upgrade',
|
|
'Upgrade-Insecure-Requests',
|
|
'User-Agent',
|
|
'Vary',
|
|
'Via',
|
|
'WWW-Authenticate',
|
|
'X-Content-Type-Options',
|
|
'X-DNS-Prefetch-Control',
|
|
'X-Frame-Options',
|
|
'X-Permitted-Cross-Domain-Policies',
|
|
'X-Powered-By',
|
|
'X-Requested-With',
|
|
'X-XSS-Protection'
|
|
]
|
|
|
|
for (let i = 0; i < wellknownHeaderNames.length; ++i) {
|
|
const key = wellknownHeaderNames[i]
|
|
const lowerCasedKey = key.toLowerCase()
|
|
headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] =
|
|
lowerCasedKey
|
|
}
|
|
|
|
// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
|
|
Object.setPrototypeOf(headerNameLowerCasedRecord, null)
|
|
|
|
module.exports = {
|
|
wellknownHeaderNames,
|
|
headerNameLowerCasedRecord
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2414:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
const diagnosticsChannel = __nccwpck_require__(3053)
|
|
const util = __nccwpck_require__(7975)
|
|
|
|
const undiciDebugLog = util.debuglog('undici')
|
|
const fetchDebuglog = util.debuglog('fetch')
|
|
const websocketDebuglog = util.debuglog('websocket')
|
|
let isClientSet = false
|
|
const channels = {
|
|
// Client
|
|
beforeConnect: diagnosticsChannel.channel('undici:client:beforeConnect'),
|
|
connected: diagnosticsChannel.channel('undici:client:connected'),
|
|
connectError: diagnosticsChannel.channel('undici:client:connectError'),
|
|
sendHeaders: diagnosticsChannel.channel('undici:client:sendHeaders'),
|
|
// Request
|
|
create: diagnosticsChannel.channel('undici:request:create'),
|
|
bodySent: diagnosticsChannel.channel('undici:request:bodySent'),
|
|
headers: diagnosticsChannel.channel('undici:request:headers'),
|
|
trailers: diagnosticsChannel.channel('undici:request:trailers'),
|
|
error: diagnosticsChannel.channel('undici:request:error'),
|
|
// WebSocket
|
|
open: diagnosticsChannel.channel('undici:websocket:open'),
|
|
close: diagnosticsChannel.channel('undici:websocket:close'),
|
|
socketError: diagnosticsChannel.channel('undici:websocket:socket_error'),
|
|
ping: diagnosticsChannel.channel('undici:websocket:ping'),
|
|
pong: diagnosticsChannel.channel('undici:websocket:pong')
|
|
}
|
|
|
|
if (undiciDebugLog.enabled || fetchDebuglog.enabled) {
|
|
const debuglog = fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog
|
|
|
|
// Track all Client events
|
|
diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(evt => {
|
|
const {
|
|
connectParams: { version, protocol, port, host }
|
|
} = evt
|
|
debuglog(
|
|
'connecting to %s using %s%s',
|
|
`${host}${port ? `:${port}` : ''}`,
|
|
protocol,
|
|
version
|
|
)
|
|
})
|
|
|
|
diagnosticsChannel.channel('undici:client:connected').subscribe(evt => {
|
|
const {
|
|
connectParams: { version, protocol, port, host }
|
|
} = evt
|
|
debuglog(
|
|
'connected to %s using %s%s',
|
|
`${host}${port ? `:${port}` : ''}`,
|
|
protocol,
|
|
version
|
|
)
|
|
})
|
|
|
|
diagnosticsChannel.channel('undici:client:connectError').subscribe(evt => {
|
|
const {
|
|
connectParams: { version, protocol, port, host },
|
|
error
|
|
} = evt
|
|
debuglog(
|
|
'connection to %s using %s%s errored - %s',
|
|
`${host}${port ? `:${port}` : ''}`,
|
|
protocol,
|
|
version,
|
|
error.message
|
|
)
|
|
})
|
|
|
|
diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(evt => {
|
|
const {
|
|
request: { method, path, origin }
|
|
} = evt
|
|
debuglog('sending request to %s %s/%s', method, origin, path)
|
|
})
|
|
|
|
// Track Request events
|
|
diagnosticsChannel.channel('undici:request:headers').subscribe(evt => {
|
|
const {
|
|
request: { method, path, origin },
|
|
response: { statusCode }
|
|
} = evt
|
|
debuglog(
|
|
'received response to %s %s/%s - HTTP %d',
|
|
method,
|
|
origin,
|
|
path,
|
|
statusCode
|
|
)
|
|
})
|
|
|
|
diagnosticsChannel.channel('undici:request:trailers').subscribe(evt => {
|
|
const {
|
|
request: { method, path, origin }
|
|
} = evt
|
|
debuglog('trailers received from %s %s/%s', method, origin, path)
|
|
})
|
|
|
|
diagnosticsChannel.channel('undici:request:error').subscribe(evt => {
|
|
const {
|
|
request: { method, path, origin },
|
|
error
|
|
} = evt
|
|
debuglog(
|
|
'request to %s %s/%s errored - %s',
|
|
method,
|
|
origin,
|
|
path,
|
|
error.message
|
|
)
|
|
})
|
|
|
|
isClientSet = true
|
|
}
|
|
|
|
if (websocketDebuglog.enabled) {
|
|
if (!isClientSet) {
|
|
const debuglog = undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog
|
|
diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(evt => {
|
|
const {
|
|
connectParams: { version, protocol, port, host }
|
|
} = evt
|
|
debuglog(
|
|
'connecting to %s%s using %s%s',
|
|
host,
|
|
port ? `:${port}` : '',
|
|
protocol,
|
|
version
|
|
)
|
|
})
|
|
|
|
diagnosticsChannel.channel('undici:client:connected').subscribe(evt => {
|
|
const {
|
|
connectParams: { version, protocol, port, host }
|
|
} = evt
|
|
debuglog(
|
|
'connected to %s%s using %s%s',
|
|
host,
|
|
port ? `:${port}` : '',
|
|
protocol,
|
|
version
|
|
)
|
|
})
|
|
|
|
diagnosticsChannel.channel('undici:client:connectError').subscribe(evt => {
|
|
const {
|
|
connectParams: { version, protocol, port, host },
|
|
error
|
|
} = evt
|
|
debuglog(
|
|
'connection to %s%s using %s%s errored - %s',
|
|
host,
|
|
port ? `:${port}` : '',
|
|
protocol,
|
|
version,
|
|
error.message
|
|
)
|
|
})
|
|
|
|
diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(evt => {
|
|
const {
|
|
request: { method, path, origin }
|
|
} = evt
|
|
debuglog('sending request to %s %s/%s', method, origin, path)
|
|
})
|
|
}
|
|
|
|
// Track all WebSocket events
|
|
diagnosticsChannel.channel('undici:websocket:open').subscribe(evt => {
|
|
const {
|
|
address: { address, port }
|
|
} = evt
|
|
websocketDebuglog('connection opened %s%s', address, port ? `:${port}` : '')
|
|
})
|
|
|
|
diagnosticsChannel.channel('undici:websocket:close').subscribe(evt => {
|
|
const { websocket, code, reason } = evt
|
|
websocketDebuglog(
|
|
'closed connection to %s - %s %s',
|
|
websocket.url,
|
|
code,
|
|
reason
|
|
)
|
|
})
|
|
|
|
diagnosticsChannel.channel('undici:websocket:socket_error').subscribe(err => {
|
|
websocketDebuglog('connection errored - %s', err.message)
|
|
})
|
|
|
|
diagnosticsChannel.channel('undici:websocket:ping').subscribe(evt => {
|
|
websocketDebuglog('ping received')
|
|
})
|
|
|
|
diagnosticsChannel.channel('undici:websocket:pong').subscribe(evt => {
|
|
websocketDebuglog('pong received')
|
|
})
|
|
}
|
|
|
|
module.exports = {
|
|
channels
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8707:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
const kUndiciError = Symbol.for('undici.error.UND_ERR')
|
|
class UndiciError extends Error {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'UndiciError'
|
|
this.code = 'UND_ERR'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kUndiciError] === true
|
|
}
|
|
|
|
[kUndiciError] = true
|
|
}
|
|
|
|
const kConnectTimeoutError = Symbol.for('undici.error.UND_ERR_CONNECT_TIMEOUT')
|
|
class ConnectTimeoutError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'ConnectTimeoutError'
|
|
this.message = message || 'Connect Timeout Error'
|
|
this.code = 'UND_ERR_CONNECT_TIMEOUT'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kConnectTimeoutError] === true
|
|
}
|
|
|
|
[kConnectTimeoutError] = true
|
|
}
|
|
|
|
const kHeadersTimeoutError = Symbol.for('undici.error.UND_ERR_HEADERS_TIMEOUT')
|
|
class HeadersTimeoutError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'HeadersTimeoutError'
|
|
this.message = message || 'Headers Timeout Error'
|
|
this.code = 'UND_ERR_HEADERS_TIMEOUT'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kHeadersTimeoutError] === true
|
|
}
|
|
|
|
[kHeadersTimeoutError] = true
|
|
}
|
|
|
|
const kHeadersOverflowError = Symbol.for('undici.error.UND_ERR_HEADERS_OVERFLOW')
|
|
class HeadersOverflowError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'HeadersOverflowError'
|
|
this.message = message || 'Headers Overflow Error'
|
|
this.code = 'UND_ERR_HEADERS_OVERFLOW'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kHeadersOverflowError] === true
|
|
}
|
|
|
|
[kHeadersOverflowError] = true
|
|
}
|
|
|
|
const kBodyTimeoutError = Symbol.for('undici.error.UND_ERR_BODY_TIMEOUT')
|
|
class BodyTimeoutError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'BodyTimeoutError'
|
|
this.message = message || 'Body Timeout Error'
|
|
this.code = 'UND_ERR_BODY_TIMEOUT'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kBodyTimeoutError] === true
|
|
}
|
|
|
|
[kBodyTimeoutError] = true
|
|
}
|
|
|
|
const kResponseStatusCodeError = Symbol.for('undici.error.UND_ERR_RESPONSE_STATUS_CODE')
|
|
class ResponseStatusCodeError extends UndiciError {
|
|
constructor (message, statusCode, headers, body) {
|
|
super(message)
|
|
this.name = 'ResponseStatusCodeError'
|
|
this.message = message || 'Response Status Code Error'
|
|
this.code = 'UND_ERR_RESPONSE_STATUS_CODE'
|
|
this.body = body
|
|
this.status = statusCode
|
|
this.statusCode = statusCode
|
|
this.headers = headers
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kResponseStatusCodeError] === true
|
|
}
|
|
|
|
[kResponseStatusCodeError] = true
|
|
}
|
|
|
|
const kInvalidArgumentError = Symbol.for('undici.error.UND_ERR_INVALID_ARG')
|
|
class InvalidArgumentError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'InvalidArgumentError'
|
|
this.message = message || 'Invalid Argument Error'
|
|
this.code = 'UND_ERR_INVALID_ARG'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kInvalidArgumentError] === true
|
|
}
|
|
|
|
[kInvalidArgumentError] = true
|
|
}
|
|
|
|
const kInvalidReturnValueError = Symbol.for('undici.error.UND_ERR_INVALID_RETURN_VALUE')
|
|
class InvalidReturnValueError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'InvalidReturnValueError'
|
|
this.message = message || 'Invalid Return Value Error'
|
|
this.code = 'UND_ERR_INVALID_RETURN_VALUE'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kInvalidReturnValueError] === true
|
|
}
|
|
|
|
[kInvalidReturnValueError] = true
|
|
}
|
|
|
|
const kAbortError = Symbol.for('undici.error.UND_ERR_ABORT')
|
|
class AbortError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'AbortError'
|
|
this.message = message || 'The operation was aborted'
|
|
this.code = 'UND_ERR_ABORT'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kAbortError] === true
|
|
}
|
|
|
|
[kAbortError] = true
|
|
}
|
|
|
|
const kRequestAbortedError = Symbol.for('undici.error.UND_ERR_ABORTED')
|
|
class RequestAbortedError extends AbortError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'AbortError'
|
|
this.message = message || 'Request aborted'
|
|
this.code = 'UND_ERR_ABORTED'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kRequestAbortedError] === true
|
|
}
|
|
|
|
[kRequestAbortedError] = true
|
|
}
|
|
|
|
const kInformationalError = Symbol.for('undici.error.UND_ERR_INFO')
|
|
class InformationalError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'InformationalError'
|
|
this.message = message || 'Request information'
|
|
this.code = 'UND_ERR_INFO'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kInformationalError] === true
|
|
}
|
|
|
|
[kInformationalError] = true
|
|
}
|
|
|
|
const kRequestContentLengthMismatchError = Symbol.for('undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH')
|
|
class RequestContentLengthMismatchError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'RequestContentLengthMismatchError'
|
|
this.message = message || 'Request body length does not match content-length header'
|
|
this.code = 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kRequestContentLengthMismatchError] === true
|
|
}
|
|
|
|
[kRequestContentLengthMismatchError] = true
|
|
}
|
|
|
|
const kResponseContentLengthMismatchError = Symbol.for('undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH')
|
|
class ResponseContentLengthMismatchError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'ResponseContentLengthMismatchError'
|
|
this.message = message || 'Response body length does not match content-length header'
|
|
this.code = 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kResponseContentLengthMismatchError] === true
|
|
}
|
|
|
|
[kResponseContentLengthMismatchError] = true
|
|
}
|
|
|
|
const kClientDestroyedError = Symbol.for('undici.error.UND_ERR_DESTROYED')
|
|
class ClientDestroyedError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'ClientDestroyedError'
|
|
this.message = message || 'The client is destroyed'
|
|
this.code = 'UND_ERR_DESTROYED'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kClientDestroyedError] === true
|
|
}
|
|
|
|
[kClientDestroyedError] = true
|
|
}
|
|
|
|
const kClientClosedError = Symbol.for('undici.error.UND_ERR_CLOSED')
|
|
class ClientClosedError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'ClientClosedError'
|
|
this.message = message || 'The client is closed'
|
|
this.code = 'UND_ERR_CLOSED'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kClientClosedError] === true
|
|
}
|
|
|
|
[kClientClosedError] = true
|
|
}
|
|
|
|
const kSocketError = Symbol.for('undici.error.UND_ERR_SOCKET')
|
|
class SocketError extends UndiciError {
|
|
constructor (message, socket) {
|
|
super(message)
|
|
this.name = 'SocketError'
|
|
this.message = message || 'Socket error'
|
|
this.code = 'UND_ERR_SOCKET'
|
|
this.socket = socket
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kSocketError] === true
|
|
}
|
|
|
|
[kSocketError] = true
|
|
}
|
|
|
|
const kNotSupportedError = Symbol.for('undici.error.UND_ERR_NOT_SUPPORTED')
|
|
class NotSupportedError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'NotSupportedError'
|
|
this.message = message || 'Not supported error'
|
|
this.code = 'UND_ERR_NOT_SUPPORTED'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kNotSupportedError] === true
|
|
}
|
|
|
|
[kNotSupportedError] = true
|
|
}
|
|
|
|
const kBalancedPoolMissingUpstreamError = Symbol.for('undici.error.UND_ERR_BPL_MISSING_UPSTREAM')
|
|
class BalancedPoolMissingUpstreamError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'MissingUpstreamError'
|
|
this.message = message || 'No upstream has been added to the BalancedPool'
|
|
this.code = 'UND_ERR_BPL_MISSING_UPSTREAM'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kBalancedPoolMissingUpstreamError] === true
|
|
}
|
|
|
|
[kBalancedPoolMissingUpstreamError] = true
|
|
}
|
|
|
|
const kHTTPParserError = Symbol.for('undici.error.UND_ERR_HTTP_PARSER')
|
|
class HTTPParserError extends Error {
|
|
constructor (message, code, data) {
|
|
super(message)
|
|
this.name = 'HTTPParserError'
|
|
this.code = code ? `HPE_${code}` : undefined
|
|
this.data = data ? data.toString() : undefined
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kHTTPParserError] === true
|
|
}
|
|
|
|
[kHTTPParserError] = true
|
|
}
|
|
|
|
const kResponseExceededMaxSizeError = Symbol.for('undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE')
|
|
class ResponseExceededMaxSizeError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'ResponseExceededMaxSizeError'
|
|
this.message = message || 'Response content exceeded max size'
|
|
this.code = 'UND_ERR_RES_EXCEEDED_MAX_SIZE'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kResponseExceededMaxSizeError] === true
|
|
}
|
|
|
|
[kResponseExceededMaxSizeError] = true
|
|
}
|
|
|
|
const kRequestRetryError = Symbol.for('undici.error.UND_ERR_REQ_RETRY')
|
|
class RequestRetryError extends UndiciError {
|
|
constructor (message, code, { headers, data }) {
|
|
super(message)
|
|
this.name = 'RequestRetryError'
|
|
this.message = message || 'Request retry error'
|
|
this.code = 'UND_ERR_REQ_RETRY'
|
|
this.statusCode = code
|
|
this.data = data
|
|
this.headers = headers
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kRequestRetryError] === true
|
|
}
|
|
|
|
[kRequestRetryError] = true
|
|
}
|
|
|
|
const kResponseError = Symbol.for('undici.error.UND_ERR_RESPONSE')
|
|
class ResponseError extends UndiciError {
|
|
constructor (message, code, { headers, data }) {
|
|
super(message)
|
|
this.name = 'ResponseError'
|
|
this.message = message || 'Response error'
|
|
this.code = 'UND_ERR_RESPONSE'
|
|
this.statusCode = code
|
|
this.data = data
|
|
this.headers = headers
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kResponseError] === true
|
|
}
|
|
|
|
[kResponseError] = true
|
|
}
|
|
|
|
const kSecureProxyConnectionError = Symbol.for('undici.error.UND_ERR_PRX_TLS')
|
|
class SecureProxyConnectionError extends UndiciError {
|
|
constructor (cause, message, options) {
|
|
super(message, { cause, ...(options ?? {}) })
|
|
this.name = 'SecureProxyConnectionError'
|
|
this.message = message || 'Secure Proxy Connection failed'
|
|
this.code = 'UND_ERR_PRX_TLS'
|
|
this.cause = cause
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kSecureProxyConnectionError] === true
|
|
}
|
|
|
|
[kSecureProxyConnectionError] = true
|
|
}
|
|
|
|
const kMessageSizeExceededError = Symbol.for('undici.error.UND_ERR_WS_MESSAGE_SIZE_EXCEEDED')
|
|
class MessageSizeExceededError extends UndiciError {
|
|
constructor (message) {
|
|
super(message)
|
|
this.name = 'MessageSizeExceededError'
|
|
this.message = message || 'Max decompressed message size exceeded'
|
|
this.code = 'UND_ERR_WS_MESSAGE_SIZE_EXCEEDED'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kMessageSizeExceededError] === true
|
|
}
|
|
|
|
get [kMessageSizeExceededError] () {
|
|
return true
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
AbortError,
|
|
HTTPParserError,
|
|
UndiciError,
|
|
HeadersTimeoutError,
|
|
HeadersOverflowError,
|
|
BodyTimeoutError,
|
|
RequestContentLengthMismatchError,
|
|
ConnectTimeoutError,
|
|
ResponseStatusCodeError,
|
|
InvalidArgumentError,
|
|
InvalidReturnValueError,
|
|
RequestAbortedError,
|
|
ClientDestroyedError,
|
|
ClientClosedError,
|
|
InformationalError,
|
|
SocketError,
|
|
NotSupportedError,
|
|
ResponseContentLengthMismatchError,
|
|
BalancedPoolMissingUpstreamError,
|
|
ResponseExceededMaxSizeError,
|
|
RequestRetryError,
|
|
ResponseError,
|
|
SecureProxyConnectionError,
|
|
MessageSizeExceededError
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4655:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const {
|
|
InvalidArgumentError,
|
|
NotSupportedError
|
|
} = __nccwpck_require__(8707)
|
|
const assert = __nccwpck_require__(4589)
|
|
const {
|
|
isValidHTTPToken,
|
|
isValidHeaderValue,
|
|
isStream,
|
|
destroy,
|
|
isBuffer,
|
|
isFormDataLike,
|
|
isIterable,
|
|
isBlobLike,
|
|
buildURL,
|
|
validateHandler,
|
|
getServerName,
|
|
normalizedMethodRecords
|
|
} = __nccwpck_require__(3440)
|
|
const { channels } = __nccwpck_require__(2414)
|
|
const { headerNameLowerCasedRecord } = __nccwpck_require__(735)
|
|
|
|
// Verifies that a given path is valid does not contain control chars \x00 to \x20
|
|
const invalidPathRegex = /[^\u0021-\u00ff]/
|
|
|
|
const kHandler = Symbol('handler')
|
|
|
|
class Request {
|
|
constructor (origin, {
|
|
path,
|
|
method,
|
|
body,
|
|
headers,
|
|
query,
|
|
idempotent,
|
|
blocking,
|
|
upgrade,
|
|
headersTimeout,
|
|
bodyTimeout,
|
|
reset,
|
|
throwOnError,
|
|
expectContinue,
|
|
servername
|
|
}, handler) {
|
|
if (typeof path !== 'string') {
|
|
throw new InvalidArgumentError('path must be a string')
|
|
} else if (
|
|
path[0] !== '/' &&
|
|
!(path.startsWith('http://') || path.startsWith('https://')) &&
|
|
method !== 'CONNECT'
|
|
) {
|
|
throw new InvalidArgumentError('path must be an absolute URL or start with a slash')
|
|
} else if (invalidPathRegex.test(path)) {
|
|
throw new InvalidArgumentError('invalid request path')
|
|
}
|
|
|
|
if (typeof method !== 'string') {
|
|
throw new InvalidArgumentError('method must be a string')
|
|
} else if (normalizedMethodRecords[method] === undefined && !isValidHTTPToken(method)) {
|
|
throw new InvalidArgumentError('invalid request method')
|
|
}
|
|
|
|
if (upgrade && typeof upgrade !== 'string') {
|
|
throw new InvalidArgumentError('upgrade must be a string')
|
|
}
|
|
|
|
if (upgrade && !isValidHeaderValue(upgrade)) {
|
|
throw new InvalidArgumentError('invalid upgrade header')
|
|
}
|
|
|
|
if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
|
|
throw new InvalidArgumentError('invalid headersTimeout')
|
|
}
|
|
|
|
if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
|
|
throw new InvalidArgumentError('invalid bodyTimeout')
|
|
}
|
|
|
|
if (reset != null && typeof reset !== 'boolean') {
|
|
throw new InvalidArgumentError('invalid reset')
|
|
}
|
|
|
|
if (expectContinue != null && typeof expectContinue !== 'boolean') {
|
|
throw new InvalidArgumentError('invalid expectContinue')
|
|
}
|
|
|
|
this.headersTimeout = headersTimeout
|
|
|
|
this.bodyTimeout = bodyTimeout
|
|
|
|
this.throwOnError = throwOnError === true
|
|
|
|
this.method = method
|
|
|
|
this.abort = null
|
|
|
|
if (body == null) {
|
|
this.body = null
|
|
} else if (isStream(body)) {
|
|
this.body = body
|
|
|
|
const rState = this.body._readableState
|
|
if (!rState || !rState.autoDestroy) {
|
|
this.endHandler = function autoDestroy () {
|
|
destroy(this)
|
|
}
|
|
this.body.on('end', this.endHandler)
|
|
}
|
|
|
|
this.errorHandler = err => {
|
|
if (this.abort) {
|
|
this.abort(err)
|
|
} else {
|
|
this.error = err
|
|
}
|
|
}
|
|
this.body.on('error', this.errorHandler)
|
|
} else if (isBuffer(body)) {
|
|
this.body = body.byteLength ? body : null
|
|
} else if (ArrayBuffer.isView(body)) {
|
|
this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null
|
|
} else if (body instanceof ArrayBuffer) {
|
|
this.body = body.byteLength ? Buffer.from(body) : null
|
|
} else if (typeof body === 'string') {
|
|
this.body = body.length ? Buffer.from(body) : null
|
|
} else if (isFormDataLike(body) || isIterable(body) || isBlobLike(body)) {
|
|
this.body = body
|
|
} else {
|
|
throw new InvalidArgumentError('body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable')
|
|
}
|
|
|
|
this.completed = false
|
|
|
|
this.aborted = false
|
|
|
|
this.upgrade = upgrade || null
|
|
|
|
this.path = query ? buildURL(path, query) : path
|
|
|
|
this.origin = origin
|
|
|
|
this.idempotent = idempotent == null
|
|
? method === 'HEAD' || method === 'GET'
|
|
: idempotent
|
|
|
|
this.blocking = blocking == null ? false : blocking
|
|
|
|
this.reset = reset == null ? null : reset
|
|
|
|
this.host = null
|
|
|
|
this.contentLength = null
|
|
|
|
this.contentType = null
|
|
|
|
this.headers = []
|
|
|
|
// Only for H2
|
|
this.expectContinue = expectContinue != null ? expectContinue : false
|
|
|
|
if (Array.isArray(headers)) {
|
|
if (headers.length % 2 !== 0) {
|
|
throw new InvalidArgumentError('headers array must be even')
|
|
}
|
|
for (let i = 0; i < headers.length; i += 2) {
|
|
processHeader(this, headers[i], headers[i + 1])
|
|
}
|
|
} else if (headers && typeof headers === 'object') {
|
|
if (headers[Symbol.iterator]) {
|
|
for (const header of headers) {
|
|
if (!Array.isArray(header) || header.length !== 2) {
|
|
throw new InvalidArgumentError('headers must be in key-value pair format')
|
|
}
|
|
processHeader(this, header[0], header[1])
|
|
}
|
|
} else {
|
|
const keys = Object.keys(headers)
|
|
for (let i = 0; i < keys.length; ++i) {
|
|
processHeader(this, keys[i], headers[keys[i]])
|
|
}
|
|
}
|
|
} else if (headers != null) {
|
|
throw new InvalidArgumentError('headers must be an object or an array')
|
|
}
|
|
|
|
validateHandler(handler, method, upgrade)
|
|
|
|
this.servername = servername || getServerName(this.host)
|
|
|
|
this[kHandler] = handler
|
|
|
|
if (channels.create.hasSubscribers) {
|
|
channels.create.publish({ request: this })
|
|
}
|
|
}
|
|
|
|
onBodySent (chunk) {
|
|
if (this[kHandler].onBodySent) {
|
|
try {
|
|
return this[kHandler].onBodySent(chunk)
|
|
} catch (err) {
|
|
this.abort(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
onRequestSent () {
|
|
if (channels.bodySent.hasSubscribers) {
|
|
channels.bodySent.publish({ request: this })
|
|
}
|
|
|
|
if (this[kHandler].onRequestSent) {
|
|
try {
|
|
return this[kHandler].onRequestSent()
|
|
} catch (err) {
|
|
this.abort(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
onConnect (abort) {
|
|
assert(!this.aborted)
|
|
assert(!this.completed)
|
|
|
|
if (this.error) {
|
|
abort(this.error)
|
|
} else {
|
|
this.abort = abort
|
|
return this[kHandler].onConnect(abort)
|
|
}
|
|
}
|
|
|
|
onResponseStarted () {
|
|
return this[kHandler].onResponseStarted?.()
|
|
}
|
|
|
|
onHeaders (statusCode, headers, resume, statusText) {
|
|
assert(!this.aborted)
|
|
assert(!this.completed)
|
|
|
|
if (channels.headers.hasSubscribers) {
|
|
channels.headers.publish({ request: this, response: { statusCode, headers, statusText } })
|
|
}
|
|
|
|
try {
|
|
return this[kHandler].onHeaders(statusCode, headers, resume, statusText)
|
|
} catch (err) {
|
|
this.abort(err)
|
|
}
|
|
}
|
|
|
|
onData (chunk) {
|
|
assert(!this.aborted)
|
|
assert(!this.completed)
|
|
|
|
try {
|
|
return this[kHandler].onData(chunk)
|
|
} catch (err) {
|
|
this.abort(err)
|
|
return false
|
|
}
|
|
}
|
|
|
|
onUpgrade (statusCode, headers, socket) {
|
|
assert(!this.aborted)
|
|
assert(!this.completed)
|
|
|
|
return this[kHandler].onUpgrade(statusCode, headers, socket)
|
|
}
|
|
|
|
onComplete (trailers) {
|
|
this.onFinally()
|
|
|
|
assert(!this.aborted)
|
|
|
|
this.completed = true
|
|
if (channels.trailers.hasSubscribers) {
|
|
channels.trailers.publish({ request: this, trailers })
|
|
}
|
|
|
|
try {
|
|
return this[kHandler].onComplete(trailers)
|
|
} catch (err) {
|
|
// TODO (fix): This might be a bad idea?
|
|
this.onError(err)
|
|
}
|
|
}
|
|
|
|
onError (error) {
|
|
this.onFinally()
|
|
|
|
if (channels.error.hasSubscribers) {
|
|
channels.error.publish({ request: this, error })
|
|
}
|
|
|
|
if (this.aborted) {
|
|
return
|
|
}
|
|
this.aborted = true
|
|
|
|
return this[kHandler].onError(error)
|
|
}
|
|
|
|
onFinally () {
|
|
if (this.errorHandler) {
|
|
this.body.off('error', this.errorHandler)
|
|
this.errorHandler = null
|
|
}
|
|
|
|
if (this.endHandler) {
|
|
this.body.off('end', this.endHandler)
|
|
this.endHandler = null
|
|
}
|
|
}
|
|
|
|
addHeader (key, value) {
|
|
processHeader(this, key, value)
|
|
return this
|
|
}
|
|
}
|
|
|
|
function processHeader (request, key, val) {
|
|
if (val && (typeof val === 'object' && !Array.isArray(val))) {
|
|
throw new InvalidArgumentError(`invalid ${key} header`)
|
|
} else if (val === undefined) {
|
|
return
|
|
}
|
|
|
|
let headerName = headerNameLowerCasedRecord[key]
|
|
|
|
if (headerName === undefined) {
|
|
headerName = key.toLowerCase()
|
|
if (headerNameLowerCasedRecord[headerName] === undefined && !isValidHTTPToken(headerName)) {
|
|
throw new InvalidArgumentError('invalid header key')
|
|
}
|
|
}
|
|
|
|
if (Array.isArray(val)) {
|
|
const arr = []
|
|
for (let i = 0; i < val.length; i++) {
|
|
if (typeof val[i] === 'string') {
|
|
if (!isValidHeaderValue(val[i])) {
|
|
throw new InvalidArgumentError(`invalid ${key} header`)
|
|
}
|
|
arr.push(val[i])
|
|
} else if (val[i] === null) {
|
|
arr.push('')
|
|
} else if (typeof val[i] === 'object') {
|
|
throw new InvalidArgumentError(`invalid ${key} header`)
|
|
} else {
|
|
arr.push(`${val[i]}`)
|
|
}
|
|
}
|
|
val = arr
|
|
} else if (typeof val === 'string') {
|
|
if (!isValidHeaderValue(val)) {
|
|
throw new InvalidArgumentError(`invalid ${key} header`)
|
|
}
|
|
} else if (val === null) {
|
|
val = ''
|
|
} else {
|
|
val = `${val}`
|
|
}
|
|
|
|
if (headerName === 'host') {
|
|
if (request.host !== null) {
|
|
throw new InvalidArgumentError('duplicate host header')
|
|
}
|
|
if (typeof val !== 'string') {
|
|
throw new InvalidArgumentError('invalid host header')
|
|
}
|
|
// Consumed by Client
|
|
request.host = val
|
|
} else if (headerName === 'content-length') {
|
|
if (request.contentLength !== null) {
|
|
throw new InvalidArgumentError('duplicate content-length header')
|
|
}
|
|
request.contentLength = parseInt(val, 10)
|
|
if (!Number.isFinite(request.contentLength)) {
|
|
throw new InvalidArgumentError('invalid content-length header')
|
|
}
|
|
} else if (request.contentType === null && headerName === 'content-type') {
|
|
request.contentType = val
|
|
request.headers.push(key, val)
|
|
} else if (headerName === 'transfer-encoding' || headerName === 'keep-alive' || headerName === 'upgrade') {
|
|
throw new InvalidArgumentError(`invalid ${headerName} header`)
|
|
} else if (headerName === 'connection') {
|
|
const value = typeof val === 'string' ? val.toLowerCase() : null
|
|
if (value !== 'close' && value !== 'keep-alive') {
|
|
throw new InvalidArgumentError('invalid connection header')
|
|
}
|
|
|
|
if (value === 'close') {
|
|
request.reset = true
|
|
}
|
|
} else if (headerName === 'expect') {
|
|
throw new NotSupportedError('expect header not supported')
|
|
} else {
|
|
request.headers.push(key, val)
|
|
}
|
|
}
|
|
|
|
module.exports = Request
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6443:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = {
|
|
kClose: Symbol('close'),
|
|
kDestroy: Symbol('destroy'),
|
|
kDispatch: Symbol('dispatch'),
|
|
kUrl: Symbol('url'),
|
|
kWriting: Symbol('writing'),
|
|
kResuming: Symbol('resuming'),
|
|
kQueue: Symbol('queue'),
|
|
kConnect: Symbol('connect'),
|
|
kConnecting: Symbol('connecting'),
|
|
kKeepAliveDefaultTimeout: Symbol('default keep alive timeout'),
|
|
kKeepAliveMaxTimeout: Symbol('max keep alive timeout'),
|
|
kKeepAliveTimeoutThreshold: Symbol('keep alive timeout threshold'),
|
|
kKeepAliveTimeoutValue: Symbol('keep alive timeout'),
|
|
kKeepAlive: Symbol('keep alive'),
|
|
kHeadersTimeout: Symbol('headers timeout'),
|
|
kBodyTimeout: Symbol('body timeout'),
|
|
kServerName: Symbol('server name'),
|
|
kLocalAddress: Symbol('local address'),
|
|
kHost: Symbol('host'),
|
|
kNoRef: Symbol('no ref'),
|
|
kBodyUsed: Symbol('used'),
|
|
kBody: Symbol('abstracted request body'),
|
|
kRunning: Symbol('running'),
|
|
kBlocking: Symbol('blocking'),
|
|
kPending: Symbol('pending'),
|
|
kSize: Symbol('size'),
|
|
kBusy: Symbol('busy'),
|
|
kQueued: Symbol('queued'),
|
|
kFree: Symbol('free'),
|
|
kConnected: Symbol('connected'),
|
|
kClosed: Symbol('closed'),
|
|
kNeedDrain: Symbol('need drain'),
|
|
kReset: Symbol('reset'),
|
|
kDestroyed: Symbol.for('nodejs.stream.destroyed'),
|
|
kResume: Symbol('resume'),
|
|
kOnError: Symbol('on error'),
|
|
kMaxHeadersSize: Symbol('max headers size'),
|
|
kRunningIdx: Symbol('running index'),
|
|
kPendingIdx: Symbol('pending index'),
|
|
kError: Symbol('error'),
|
|
kClients: Symbol('clients'),
|
|
kClient: Symbol('client'),
|
|
kParser: Symbol('parser'),
|
|
kOnDestroyed: Symbol('destroy callbacks'),
|
|
kPipelining: Symbol('pipelining'),
|
|
kSocket: Symbol('socket'),
|
|
kHostHeader: Symbol('host header'),
|
|
kConnector: Symbol('connector'),
|
|
kStrictContentLength: Symbol('strict content length'),
|
|
kMaxRedirections: Symbol('maxRedirections'),
|
|
kMaxRequests: Symbol('maxRequestsPerClient'),
|
|
kProxy: Symbol('proxy agent options'),
|
|
kCounter: Symbol('socket request counter'),
|
|
kInterceptors: Symbol('dispatch interceptors'),
|
|
kMaxResponseSize: Symbol('max response size'),
|
|
kHTTP2Session: Symbol('http2Session'),
|
|
kHTTP2SessionState: Symbol('http2Session state'),
|
|
kRetryHandlerDefaultRetry: Symbol('retry agent default retry'),
|
|
kConstruct: Symbol('constructable'),
|
|
kListeners: Symbol('listeners'),
|
|
kHTTPContext: Symbol('http context'),
|
|
kMaxConcurrentStreams: Symbol('max concurrent streams'),
|
|
kNoProxyAgent: Symbol('no proxy agent'),
|
|
kHttpProxyAgent: Symbol('http proxy agent'),
|
|
kHttpsProxyAgent: Symbol('https proxy agent')
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7752:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const {
|
|
wellknownHeaderNames,
|
|
headerNameLowerCasedRecord
|
|
} = __nccwpck_require__(735)
|
|
|
|
class TstNode {
|
|
/** @type {any} */
|
|
value = null
|
|
/** @type {null | TstNode} */
|
|
left = null
|
|
/** @type {null | TstNode} */
|
|
middle = null
|
|
/** @type {null | TstNode} */
|
|
right = null
|
|
/** @type {number} */
|
|
code
|
|
/**
|
|
* @param {string} key
|
|
* @param {any} value
|
|
* @param {number} index
|
|
*/
|
|
constructor (key, value, index) {
|
|
if (index === undefined || index >= key.length) {
|
|
throw new TypeError('Unreachable')
|
|
}
|
|
const code = this.code = key.charCodeAt(index)
|
|
// check code is ascii string
|
|
if (code > 0x7F) {
|
|
throw new TypeError('key must be ascii string')
|
|
}
|
|
if (key.length !== ++index) {
|
|
this.middle = new TstNode(key, value, index)
|
|
} else {
|
|
this.value = value
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {string} key
|
|
* @param {any} value
|
|
*/
|
|
add (key, value) {
|
|
const length = key.length
|
|
if (length === 0) {
|
|
throw new TypeError('Unreachable')
|
|
}
|
|
let index = 0
|
|
let node = this
|
|
while (true) {
|
|
const code = key.charCodeAt(index)
|
|
// check code is ascii string
|
|
if (code > 0x7F) {
|
|
throw new TypeError('key must be ascii string')
|
|
}
|
|
if (node.code === code) {
|
|
if (length === ++index) {
|
|
node.value = value
|
|
break
|
|
} else if (node.middle !== null) {
|
|
node = node.middle
|
|
} else {
|
|
node.middle = new TstNode(key, value, index)
|
|
break
|
|
}
|
|
} else if (node.code < code) {
|
|
if (node.left !== null) {
|
|
node = node.left
|
|
} else {
|
|
node.left = new TstNode(key, value, index)
|
|
break
|
|
}
|
|
} else if (node.right !== null) {
|
|
node = node.right
|
|
} else {
|
|
node.right = new TstNode(key, value, index)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Uint8Array} key
|
|
* @return {TstNode | null}
|
|
*/
|
|
search (key) {
|
|
const keylength = key.length
|
|
let index = 0
|
|
let node = this
|
|
while (node !== null && index < keylength) {
|
|
let code = key[index]
|
|
// A-Z
|
|
// First check if it is bigger than 0x5a.
|
|
// Lowercase letters have higher char codes than uppercase ones.
|
|
// Also we assume that headers will mostly contain lowercase characters.
|
|
if (code <= 0x5a && code >= 0x41) {
|
|
// Lowercase for uppercase.
|
|
code |= 32
|
|
}
|
|
while (node !== null) {
|
|
if (code === node.code) {
|
|
if (keylength === ++index) {
|
|
// Returns Node since it is the last key.
|
|
return node
|
|
}
|
|
node = node.middle
|
|
break
|
|
}
|
|
node = node.code < code ? node.left : node.right
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
}
|
|
|
|
class TernarySearchTree {
|
|
/** @type {TstNode | null} */
|
|
node = null
|
|
|
|
/**
|
|
* @param {string} key
|
|
* @param {any} value
|
|
* */
|
|
insert (key, value) {
|
|
if (this.node === null) {
|
|
this.node = new TstNode(key, value, 0)
|
|
} else {
|
|
this.node.add(key, value)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Uint8Array} key
|
|
* @return {any}
|
|
*/
|
|
lookup (key) {
|
|
return this.node?.search(key)?.value ?? null
|
|
}
|
|
}
|
|
|
|
const tree = new TernarySearchTree()
|
|
|
|
for (let i = 0; i < wellknownHeaderNames.length; ++i) {
|
|
const key = headerNameLowerCasedRecord[wellknownHeaderNames[i]]
|
|
tree.insert(key, key)
|
|
}
|
|
|
|
module.exports = {
|
|
TernarySearchTree,
|
|
tree
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3440:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const assert = __nccwpck_require__(4589)
|
|
const { kDestroyed, kBodyUsed, kListeners, kBody } = __nccwpck_require__(6443)
|
|
const { IncomingMessage } = __nccwpck_require__(7067)
|
|
const stream = __nccwpck_require__(7075)
|
|
const net = __nccwpck_require__(7030)
|
|
const { Blob } = __nccwpck_require__(4573)
|
|
const nodeUtil = __nccwpck_require__(7975)
|
|
const { stringify } = __nccwpck_require__(1792)
|
|
const { EventEmitter: EE } = __nccwpck_require__(8474)
|
|
const { InvalidArgumentError } = __nccwpck_require__(8707)
|
|
const { headerNameLowerCasedRecord } = __nccwpck_require__(735)
|
|
const { tree } = __nccwpck_require__(7752)
|
|
|
|
const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(v => Number(v))
|
|
|
|
class BodyAsyncIterable {
|
|
constructor (body) {
|
|
this[kBody] = body
|
|
this[kBodyUsed] = false
|
|
}
|
|
|
|
async * [Symbol.asyncIterator] () {
|
|
assert(!this[kBodyUsed], 'disturbed')
|
|
this[kBodyUsed] = true
|
|
yield * this[kBody]
|
|
}
|
|
}
|
|
|
|
function wrapRequestBody (body) {
|
|
if (isStream(body)) {
|
|
// TODO (fix): Provide some way for the user to cache the file to e.g. /tmp
|
|
// so that it can be dispatched again?
|
|
// TODO (fix): Do we need 100-expect support to provide a way to do this properly?
|
|
if (bodyLength(body) === 0) {
|
|
body
|
|
.on('data', function () {
|
|
assert(false)
|
|
})
|
|
}
|
|
|
|
if (typeof body.readableDidRead !== 'boolean') {
|
|
body[kBodyUsed] = false
|
|
EE.prototype.on.call(body, 'data', function () {
|
|
this[kBodyUsed] = true
|
|
})
|
|
}
|
|
|
|
return body
|
|
} else if (body && typeof body.pipeTo === 'function') {
|
|
// TODO (fix): We can't access ReadableStream internal state
|
|
// to determine whether or not it has been disturbed. This is just
|
|
// a workaround.
|
|
return new BodyAsyncIterable(body)
|
|
} else if (
|
|
body &&
|
|
typeof body !== 'string' &&
|
|
!ArrayBuffer.isView(body) &&
|
|
isIterable(body)
|
|
) {
|
|
// TODO: Should we allow re-using iterable if !this.opts.idempotent
|
|
// or through some other flag?
|
|
return new BodyAsyncIterable(body)
|
|
} else {
|
|
return body
|
|
}
|
|
}
|
|
|
|
function nop () {}
|
|
|
|
function isStream (obj) {
|
|
return obj && typeof obj === 'object' && typeof obj.pipe === 'function' && typeof obj.on === 'function'
|
|
}
|
|
|
|
// based on https://github.com/node-fetch/fetch-blob/blob/8ab587d34080de94140b54f07168451e7d0b655e/index.js#L229-L241 (MIT License)
|
|
function isBlobLike (object) {
|
|
if (object === null) {
|
|
return false
|
|
} else if (object instanceof Blob) {
|
|
return true
|
|
} else if (typeof object !== 'object') {
|
|
return false
|
|
} else {
|
|
const sTag = object[Symbol.toStringTag]
|
|
|
|
return (sTag === 'Blob' || sTag === 'File') && (
|
|
('stream' in object && typeof object.stream === 'function') ||
|
|
('arrayBuffer' in object && typeof object.arrayBuffer === 'function')
|
|
)
|
|
}
|
|
}
|
|
|
|
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 isValidPort (port) {
|
|
const value = parseInt(port, 10)
|
|
return (
|
|
value === Number(port) &&
|
|
value >= 0 &&
|
|
value <= 65535
|
|
)
|
|
}
|
|
|
|
function isHttpOrHttpsPrefixed (value) {
|
|
return (
|
|
value != null &&
|
|
value[0] === 'h' &&
|
|
value[1] === 't' &&
|
|
value[2] === 't' &&
|
|
value[3] === 'p' &&
|
|
(
|
|
value[4] === ':' ||
|
|
(
|
|
value[4] === 's' &&
|
|
value[5] === ':'
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
function parseURL (url) {
|
|
if (typeof url === 'string') {
|
|
url = new URL(url)
|
|
|
|
if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
|
|
throw new InvalidArgumentError('Invalid URL protocol: the URL must start with `http:` or `https:`.')
|
|
}
|
|
|
|
return url
|
|
}
|
|
|
|
if (!url || typeof url !== 'object') {
|
|
throw new InvalidArgumentError('Invalid URL: The URL argument must be a non-null object.')
|
|
}
|
|
|
|
if (!(url instanceof URL)) {
|
|
if (url.port != null && url.port !== '' && isValidPort(url.port) === false) {
|
|
throw new InvalidArgumentError('Invalid URL: port must be a valid integer or a string representation of an integer.')
|
|
}
|
|
|
|
if (url.path != null && typeof url.path !== 'string') {
|
|
throw new InvalidArgumentError('Invalid URL path: the path must be a string or null/undefined.')
|
|
}
|
|
|
|
if (url.pathname != null && typeof url.pathname !== 'string') {
|
|
throw new InvalidArgumentError('Invalid URL pathname: the pathname must be a string or null/undefined.')
|
|
}
|
|
|
|
if (url.hostname != null && typeof url.hostname !== 'string') {
|
|
throw new InvalidArgumentError('Invalid URL hostname: the hostname must be a string or null/undefined.')
|
|
}
|
|
|
|
if (url.origin != null && typeof url.origin !== 'string') {
|
|
throw new InvalidArgumentError('Invalid URL origin: the origin must be a string or null/undefined.')
|
|
}
|
|
|
|
if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
|
|
throw new InvalidArgumentError('Invalid URL protocol: the URL must start with `http:` or `https:`.')
|
|
}
|
|
|
|
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[origin.length - 1] === '/') {
|
|
origin = origin.slice(0, origin.length - 1)
|
|
}
|
|
|
|
if (path && path[0] !== '/') {
|
|
path = `/${path}`
|
|
}
|
|
// new URL(path, origin) is unsafe when `path` contains an absolute URL
|
|
// From https://developer.mozilla.org/en-US/docs/Web/API/URL/URL:
|
|
// If first parameter is a relative URL, second param is required, and will be used as the base URL.
|
|
// If first parameter is an absolute URL, a given second param will be ignored.
|
|
return new URL(`${origin}${path}`)
|
|
}
|
|
|
|
if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
|
|
throw new InvalidArgumentError('Invalid URL protocol: the URL must start with `http:` or `https:`.')
|
|
}
|
|
|
|
return url
|
|
}
|
|
|
|
function parseOrigin (url) {
|
|
url = parseURL(url)
|
|
|
|
if (url.pathname !== '/' || url.search || url.hash) {
|
|
throw new InvalidArgumentError('invalid url')
|
|
}
|
|
|
|
return url
|
|
}
|
|
|
|
function getHostname (host) {
|
|
if (host[0] === '[') {
|
|
const idx = host.indexOf(']')
|
|
|
|
assert(idx !== -1)
|
|
return host.substring(1, idx)
|
|
}
|
|
|
|
const idx = host.indexOf(':')
|
|
if (idx === -1) return host
|
|
|
|
return host.substring(0, idx)
|
|
}
|
|
|
|
// IP addresses are not valid server names per RFC6066
|
|
// > Currently, the only server names supported are DNS hostnames
|
|
function getServerName (host) {
|
|
if (!host) {
|
|
return null
|
|
}
|
|
|
|
assert(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.objectMode === false && state.ended === true && Number.isFinite(state.length)
|
|
? state.length
|
|
: null
|
|
} else if (isBlobLike(body)) {
|
|
return body.size != null ? body.size : null
|
|
} else if (isBuffer(body)) {
|
|
return body.byteLength
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
function isDestroyed (body) {
|
|
return body && !!(body.destroyed || body[kDestroyed] || (stream.isDestroyed?.(body)))
|
|
}
|
|
|
|
function destroy (stream, err) {
|
|
if (stream == null || !isStream(stream) || isDestroyed(stream)) {
|
|
return
|
|
}
|
|
|
|
if (typeof stream.destroy === 'function') {
|
|
if (Object.getPrototypeOf(stream).constructor === IncomingMessage) {
|
|
// See: https://github.com/nodejs/node/pull/38505/files
|
|
stream.socket = null
|
|
}
|
|
|
|
stream.destroy(err)
|
|
} else if (err) {
|
|
queueMicrotask(() => {
|
|
stream.emit('error', err)
|
|
})
|
|
}
|
|
|
|
if (stream.destroyed !== true) {
|
|
stream[kDestroyed] = true
|
|
}
|
|
}
|
|
|
|
const KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/
|
|
function parseKeepAliveTimeout (val) {
|
|
const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR)
|
|
return m ? parseInt(m[1], 10) * 1000 : null
|
|
}
|
|
|
|
/**
|
|
* Retrieves a header name and returns its lowercase value.
|
|
* @param {string | Buffer} value Header name
|
|
* @returns {string}
|
|
*/
|
|
function headerNameToString (value) {
|
|
return typeof value === 'string'
|
|
? headerNameLowerCasedRecord[value] ?? value.toLowerCase()
|
|
: tree.lookup(value) ?? value.toString('latin1').toLowerCase()
|
|
}
|
|
|
|
/**
|
|
* Receive the buffer as a string and return its lowercase value.
|
|
* @param {Buffer} value Header name
|
|
* @returns {string}
|
|
*/
|
|
function bufferToLowerCasedHeaderName (value) {
|
|
return tree.lookup(value) ?? value.toString('latin1').toLowerCase()
|
|
}
|
|
|
|
/**
|
|
* @param {Record<string, string | string[]> | (Buffer | string | (Buffer | string)[])[]} headers
|
|
* @param {Record<string, string | string[]>} [obj]
|
|
* @returns {Record<string, string | string[]>}
|
|
*/
|
|
function parseHeaders (headers, obj) {
|
|
if (obj === undefined) obj = {}
|
|
for (let i = 0; i < headers.length; i += 2) {
|
|
const key = headerNameToString(headers[i])
|
|
let val = obj[key]
|
|
|
|
if (val) {
|
|
if (typeof val === 'string') {
|
|
val = [val]
|
|
obj[key] = val
|
|
}
|
|
val.push(headers[i + 1].toString('utf8'))
|
|
} else {
|
|
const headersValue = headers[i + 1]
|
|
if (typeof headersValue === 'string') {
|
|
obj[key] = headersValue
|
|
} else {
|
|
obj[key] = Array.isArray(headersValue) ? headersValue.map(x => x.toString('utf8')) : headersValue.toString('utf8')
|
|
}
|
|
}
|
|
}
|
|
|
|
// See https://github.com/nodejs/node/pull/46528
|
|
if ('content-length' in obj && 'content-disposition' in obj) {
|
|
obj['content-disposition'] = Buffer.from(obj['content-disposition']).toString('latin1')
|
|
}
|
|
|
|
return obj
|
|
}
|
|
|
|
function parseRawHeaders (headers) {
|
|
const len = headers.length
|
|
const ret = new Array(len)
|
|
|
|
let hasContentLength = false
|
|
let contentDispositionIdx = -1
|
|
let key
|
|
let val
|
|
let kLen = 0
|
|
|
|
for (let n = 0; n < headers.length; n += 2) {
|
|
key = headers[n]
|
|
val = headers[n + 1]
|
|
|
|
typeof key !== 'string' && (key = key.toString())
|
|
typeof val !== 'string' && (val = val.toString('utf8'))
|
|
|
|
kLen = key.length
|
|
if (kLen === 14 && key[7] === '-' && (key === 'content-length' || key.toLowerCase() === 'content-length')) {
|
|
hasContentLength = true
|
|
} else if (kLen === 19 && key[7] === '-' && (key === 'content-disposition' || key.toLowerCase() === 'content-disposition')) {
|
|
contentDispositionIdx = n + 1
|
|
}
|
|
ret[n] = key
|
|
ret[n + 1] = val
|
|
}
|
|
|
|
// See https://github.com/nodejs/node/pull/46528
|
|
if (hasContentLength && contentDispositionIdx !== -1) {
|
|
ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString('latin1')
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
function isBuffer (buffer) {
|
|
// See, https://github.com/mcollina/undici/pull/319
|
|
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 !== undefined) {
|
|
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')
|
|
}
|
|
}
|
|
}
|
|
|
|
// A body is disturbed if it has been read from and it cannot
|
|
// be re-used without losing state or data.
|
|
function isDisturbed (body) {
|
|
// TODO (fix): Why is body[kBodyUsed] needed?
|
|
return !!(body && (stream.isDisturbed(body) || body[kBodyUsed]))
|
|
}
|
|
|
|
function isErrored (body) {
|
|
return !!(body && stream.isErrored(body))
|
|
}
|
|
|
|
function isReadable (body) {
|
|
return !!(body && stream.isReadable(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
|
|
}
|
|
}
|
|
|
|
/** @type {globalThis['ReadableStream']} */
|
|
function ReadableStreamFrom (iterable) {
|
|
// We cannot use ReadableStream.from here because it does not return a byte stream.
|
|
|
|
let iterator
|
|
return new ReadableStream(
|
|
{
|
|
async start () {
|
|
iterator = iterable[Symbol.asyncIterator]()
|
|
},
|
|
async pull (controller) {
|
|
const { done, value } = await iterator.next()
|
|
if (done) {
|
|
queueMicrotask(() => {
|
|
controller.close()
|
|
controller.byobRequest?.respond(0)
|
|
})
|
|
} else {
|
|
const buf = Buffer.isBuffer(value) ? value : Buffer.from(value)
|
|
if (buf.byteLength) {
|
|
controller.enqueue(new Uint8Array(buf))
|
|
}
|
|
}
|
|
return controller.desiredSize > 0
|
|
},
|
|
async cancel (reason) {
|
|
await iterator.return()
|
|
},
|
|
type: 'bytes'
|
|
}
|
|
)
|
|
}
|
|
|
|
// The chunk should be a FormData instance and contains
|
|
// all the required methods.
|
|
function isFormDataLike (object) {
|
|
return (
|
|
object &&
|
|
typeof object === 'object' &&
|
|
typeof object.append === 'function' &&
|
|
typeof object.delete === 'function' &&
|
|
typeof object.get === 'function' &&
|
|
typeof object.getAll === 'function' &&
|
|
typeof object.has === 'function' &&
|
|
typeof object.set === 'function' &&
|
|
object[Symbol.toStringTag] === 'FormData'
|
|
)
|
|
}
|
|
|
|
function addAbortListener (signal, listener) {
|
|
if ('addEventListener' in signal) {
|
|
signal.addEventListener('abort', listener, { once: true })
|
|
return () => signal.removeEventListener('abort', listener)
|
|
}
|
|
signal.addListener('abort', listener)
|
|
return () => signal.removeListener('abort', listener)
|
|
}
|
|
|
|
const hasToWellFormed = typeof String.prototype.toWellFormed === 'function'
|
|
const hasIsWellFormed = typeof String.prototype.isWellFormed === 'function'
|
|
|
|
/**
|
|
* @param {string} val
|
|
*/
|
|
function toUSVString (val) {
|
|
return hasToWellFormed ? `${val}`.toWellFormed() : nodeUtil.toUSVString(val)
|
|
}
|
|
|
|
/**
|
|
* @param {string} val
|
|
*/
|
|
// TODO: move this to webidl
|
|
function isUSVString (val) {
|
|
return hasIsWellFormed ? `${val}`.isWellFormed() : toUSVString(val) === `${val}`
|
|
}
|
|
|
|
/**
|
|
* @see https://tools.ietf.org/html/rfc7230#section-3.2.6
|
|
* @param {number} c
|
|
*/
|
|
function isTokenCharCode (c) {
|
|
switch (c) {
|
|
case 0x22:
|
|
case 0x28:
|
|
case 0x29:
|
|
case 0x2c:
|
|
case 0x2f:
|
|
case 0x3a:
|
|
case 0x3b:
|
|
case 0x3c:
|
|
case 0x3d:
|
|
case 0x3e:
|
|
case 0x3f:
|
|
case 0x40:
|
|
case 0x5b:
|
|
case 0x5c:
|
|
case 0x5d:
|
|
case 0x7b:
|
|
case 0x7d:
|
|
// DQUOTE and "(),/:;<=>?@[\]{}"
|
|
return false
|
|
default:
|
|
// VCHAR %x21-7E
|
|
return c >= 0x21 && c <= 0x7e
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {string} characters
|
|
*/
|
|
function isValidHTTPToken (characters) {
|
|
if (characters.length === 0) {
|
|
return false
|
|
}
|
|
for (let i = 0; i < characters.length; ++i) {
|
|
if (!isTokenCharCode(characters.charCodeAt(i))) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// headerCharRegex have been lifted from
|
|
// https://github.com/nodejs/node/blob/main/lib/_http_common.js
|
|
|
|
/**
|
|
* Matches if val contains an invalid field-vchar
|
|
* field-value = *( field-content / obs-fold )
|
|
* field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
|
|
* field-vchar = VCHAR / obs-text
|
|
*/
|
|
const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/
|
|
|
|
/**
|
|
* @param {string} characters
|
|
*/
|
|
function isValidHeaderValue (characters) {
|
|
return !headerCharRegex.test(characters)
|
|
}
|
|
|
|
// Parsed accordingly to RFC 9110
|
|
// https://www.rfc-editor.org/rfc/rfc9110#field.content-range
|
|
function parseRangeHeader (range) {
|
|
if (range == null || range === '') return { start: 0, end: null, size: null }
|
|
|
|
const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null
|
|
return m
|
|
? {
|
|
start: parseInt(m[1]),
|
|
end: m[2] ? parseInt(m[2]) : null,
|
|
size: m[3] ? parseInt(m[3]) : null
|
|
}
|
|
: null
|
|
}
|
|
|
|
function addListener (obj, name, listener) {
|
|
const listeners = (obj[kListeners] ??= [])
|
|
listeners.push([name, listener])
|
|
obj.on(name, listener)
|
|
return obj
|
|
}
|
|
|
|
function removeAllListeners (obj) {
|
|
for (const [name, listener] of obj[kListeners] ?? []) {
|
|
obj.removeListener(name, listener)
|
|
}
|
|
obj[kListeners] = null
|
|
}
|
|
|
|
function errorRequest (client, request, err) {
|
|
try {
|
|
request.onError(err)
|
|
assert(request.aborted)
|
|
} catch (err) {
|
|
client.emit('error', err)
|
|
}
|
|
}
|
|
|
|
const kEnumerableProperty = Object.create(null)
|
|
kEnumerableProperty.enumerable = true
|
|
|
|
const normalizedMethodRecordsBase = {
|
|
delete: 'DELETE',
|
|
DELETE: 'DELETE',
|
|
get: 'GET',
|
|
GET: 'GET',
|
|
head: 'HEAD',
|
|
HEAD: 'HEAD',
|
|
options: 'OPTIONS',
|
|
OPTIONS: 'OPTIONS',
|
|
post: 'POST',
|
|
POST: 'POST',
|
|
put: 'PUT',
|
|
PUT: 'PUT'
|
|
}
|
|
|
|
const normalizedMethodRecords = {
|
|
...normalizedMethodRecordsBase,
|
|
patch: 'patch',
|
|
PATCH: 'PATCH'
|
|
}
|
|
|
|
// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
|
|
Object.setPrototypeOf(normalizedMethodRecordsBase, null)
|
|
Object.setPrototypeOf(normalizedMethodRecords, null)
|
|
|
|
module.exports = {
|
|
kEnumerableProperty,
|
|
nop,
|
|
isDisturbed,
|
|
isErrored,
|
|
isReadable,
|
|
toUSVString,
|
|
isUSVString,
|
|
isBlobLike,
|
|
parseOrigin,
|
|
parseURL,
|
|
getServerName,
|
|
isStream,
|
|
isIterable,
|
|
isAsyncIterable,
|
|
isDestroyed,
|
|
headerNameToString,
|
|
bufferToLowerCasedHeaderName,
|
|
addListener,
|
|
removeAllListeners,
|
|
errorRequest,
|
|
parseRawHeaders,
|
|
parseHeaders,
|
|
parseKeepAliveTimeout,
|
|
destroy,
|
|
bodyLength,
|
|
deepClone,
|
|
ReadableStreamFrom,
|
|
isBuffer,
|
|
validateHandler,
|
|
getSocketInfo,
|
|
isFormDataLike,
|
|
buildURL,
|
|
addAbortListener,
|
|
isValidHTTPToken,
|
|
isValidHeaderValue,
|
|
isTokenCharCode,
|
|
parseRangeHeader,
|
|
normalizedMethodRecordsBase,
|
|
normalizedMethodRecords,
|
|
isValidPort,
|
|
isHttpOrHttpsPrefixed,
|
|
nodeMajor,
|
|
nodeMinor,
|
|
safeHTTPMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
|
|
wrapRequestBody
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7405:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { InvalidArgumentError } = __nccwpck_require__(8707)
|
|
const { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = __nccwpck_require__(6443)
|
|
const DispatcherBase = __nccwpck_require__(1841)
|
|
const Pool = __nccwpck_require__(628)
|
|
const Client = __nccwpck_require__(3701)
|
|
const util = __nccwpck_require__(3440)
|
|
const createRedirectInterceptor = __nccwpck_require__(5092)
|
|
|
|
const kOnConnect = Symbol('onConnect')
|
|
const kOnDisconnect = Symbol('onDisconnect')
|
|
const kOnConnectionError = Symbol('onConnectionError')
|
|
const kMaxRedirections = Symbol('maxRedirections')
|
|
const kOnDrain = Symbol('onDrain')
|
|
const kFactory = Symbol('factory')
|
|
const kOptions = Symbol('options')
|
|
|
|
function defaultFactory (origin, opts) {
|
|
return opts && opts.connections === 1
|
|
? new Client(origin, opts)
|
|
: new Pool(origin, opts)
|
|
}
|
|
|
|
class Agent extends DispatcherBase {
|
|
constructor ({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) {
|
|
if (typeof factory !== 'function') {
|
|
throw new InvalidArgumentError('factory must be a function.')
|
|
}
|
|
|
|
if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
|
|
throw new InvalidArgumentError('connect must be a function or an object')
|
|
}
|
|
|
|
if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
|
|
throw new InvalidArgumentError('maxRedirections must be a positive number')
|
|
}
|
|
|
|
super(options)
|
|
|
|
if (connect && typeof connect !== 'function') {
|
|
connect = { ...connect }
|
|
}
|
|
|
|
this[kInterceptors] = options.interceptors?.Agent && Array.isArray(options.interceptors.Agent)
|
|
? options.interceptors.Agent
|
|
: [createRedirectInterceptor({ maxRedirections })]
|
|
|
|
this[kOptions] = { ...util.deepClone(options), connect }
|
|
this[kOptions].interceptors = options.interceptors
|
|
? { ...options.interceptors }
|
|
: undefined
|
|
this[kMaxRedirections] = maxRedirections
|
|
this[kFactory] = factory
|
|
this[kClients] = new Map()
|
|
|
|
this[kOnDrain] = (origin, targets) => {
|
|
this.emit('drain', origin, [this, ...targets])
|
|
}
|
|
|
|
this[kOnConnect] = (origin, targets) => {
|
|
this.emit('connect', origin, [this, ...targets])
|
|
}
|
|
|
|
this[kOnDisconnect] = (origin, targets, err) => {
|
|
this.emit('disconnect', origin, [this, ...targets], err)
|
|
}
|
|
|
|
this[kOnConnectionError] = (origin, targets, err) => {
|
|
this.emit('connectionError', origin, [this, ...targets], err)
|
|
}
|
|
}
|
|
|
|
get [kRunning] () {
|
|
let ret = 0
|
|
for (const client of this[kClients].values()) {
|
|
ret += client[kRunning]
|
|
}
|
|
return ret
|
|
}
|
|
|
|
[kDispatch] (opts, handler) {
|
|
let key
|
|
if (opts.origin && (typeof opts.origin === 'string' || opts.origin instanceof URL)) {
|
|
key = String(opts.origin)
|
|
} else {
|
|
throw new InvalidArgumentError('opts.origin must be a non-empty string or URL.')
|
|
}
|
|
|
|
let dispatcher = this[kClients].get(key)
|
|
|
|
if (!dispatcher) {
|
|
dispatcher = this[kFactory](opts.origin, this[kOptions])
|
|
.on('drain', this[kOnDrain])
|
|
.on('connect', this[kOnConnect])
|
|
.on('disconnect', this[kOnDisconnect])
|
|
.on('connectionError', this[kOnConnectionError])
|
|
|
|
// This introduces a tiny memory leak, as dispatchers are never removed from the map.
|
|
// TODO(mcollina): remove te timer when the client/pool do not have any more
|
|
// active connections.
|
|
this[kClients].set(key, dispatcher)
|
|
}
|
|
|
|
return dispatcher.dispatch(opts, handler)
|
|
}
|
|
|
|
async [kClose] () {
|
|
const closePromises = []
|
|
for (const client of this[kClients].values()) {
|
|
closePromises.push(client.close())
|
|
}
|
|
this[kClients].clear()
|
|
|
|
await Promise.all(closePromises)
|
|
}
|
|
|
|
async [kDestroy] (err) {
|
|
const destroyPromises = []
|
|
for (const client of this[kClients].values()) {
|
|
destroyPromises.push(client.destroy(err))
|
|
}
|
|
this[kClients].clear()
|
|
|
|
await Promise.all(destroyPromises)
|
|
}
|
|
}
|
|
|
|
module.exports = Agent
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 837:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const {
|
|
BalancedPoolMissingUpstreamError,
|
|
InvalidArgumentError
|
|
} = __nccwpck_require__(8707)
|
|
const {
|
|
PoolBase,
|
|
kClients,
|
|
kNeedDrain,
|
|
kAddClient,
|
|
kRemoveClient,
|
|
kGetDispatcher
|
|
} = __nccwpck_require__(2128)
|
|
const Pool = __nccwpck_require__(628)
|
|
const { kUrl, kInterceptors } = __nccwpck_require__(6443)
|
|
const { parseOrigin } = __nccwpck_require__(3440)
|
|
const kFactory = Symbol('factory')
|
|
|
|
const kOptions = Symbol('options')
|
|
const kGreatestCommonDivisor = Symbol('kGreatestCommonDivisor')
|
|
const kCurrentWeight = Symbol('kCurrentWeight')
|
|
const kIndex = Symbol('kIndex')
|
|
const kWeight = Symbol('kWeight')
|
|
const kMaxWeightPerServer = Symbol('kMaxWeightPerServer')
|
|
const kErrorPenalty = Symbol('kErrorPenalty')
|
|
|
|
/**
|
|
* Calculate the greatest common divisor of two numbers by
|
|
* using the Euclidean algorithm.
|
|
*
|
|
* @param {number} a
|
|
* @param {number} b
|
|
* @returns {number}
|
|
*/
|
|
function getGreatestCommonDivisor (a, b) {
|
|
if (a === 0) return b
|
|
|
|
while (b !== 0) {
|
|
const t = b
|
|
b = a % b
|
|
a = t
|
|
}
|
|
return a
|
|
}
|
|
|
|
function defaultFactory (origin, opts) {
|
|
return new Pool(origin, opts)
|
|
}
|
|
|
|
class BalancedPool 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?.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((pool) => (
|
|
pool[kUrl].origin === upstreamOrigin &&
|
|
pool.closed !== true &&
|
|
pool.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') {
|
|
// decrease the weight of the pool.
|
|
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 () {
|
|
let result = 0
|
|
for (let i = 0; i < this[kClients].length; i++) {
|
|
result = getGreatestCommonDivisor(this[kClients][i][kWeight], result)
|
|
}
|
|
|
|
this[kGreatestCommonDivisor] = result
|
|
}
|
|
|
|
removeUpstream (upstream) {
|
|
const upstreamOrigin = parseOrigin(upstream).origin
|
|
|
|
const pool = this[kClients].find((pool) => (
|
|
pool[kUrl].origin === upstreamOrigin &&
|
|
pool.closed !== true &&
|
|
pool.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] () {
|
|
// We validate that pools is greater than 0,
|
|
// otherwise we would have to wait until an upstream
|
|
// is added, which might never happen.
|
|
if (this[kClients].length === 0) {
|
|
throw new BalancedPoolMissingUpstreamError()
|
|
}
|
|
|
|
const dispatcher = this[kClients].find(dispatcher => (
|
|
!dispatcher[kNeedDrain] &&
|
|
dispatcher.closed !== true &&
|
|
dispatcher.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]]
|
|
|
|
// find pool index with the largest weight
|
|
if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) {
|
|
maxWeightIndex = this[kIndex]
|
|
}
|
|
|
|
// decrease the current weight every `this[kClients].length`.
|
|
if (this[kIndex] === 0) {
|
|
// Set the current weight to the next lower weight.
|
|
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]
|
|
}
|
|
}
|
|
|
|
module.exports = BalancedPool
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 637:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
/* global WebAssembly */
|
|
|
|
const assert = __nccwpck_require__(4589)
|
|
const util = __nccwpck_require__(3440)
|
|
const { channels } = __nccwpck_require__(2414)
|
|
const timers = __nccwpck_require__(6603)
|
|
const {
|
|
RequestContentLengthMismatchError,
|
|
ResponseContentLengthMismatchError,
|
|
RequestAbortedError,
|
|
HeadersTimeoutError,
|
|
HeadersOverflowError,
|
|
SocketError,
|
|
InformationalError,
|
|
BodyTimeoutError,
|
|
HTTPParserError,
|
|
ResponseExceededMaxSizeError
|
|
} = __nccwpck_require__(8707)
|
|
const {
|
|
kUrl,
|
|
kReset,
|
|
kClient,
|
|
kParser,
|
|
kBlocking,
|
|
kRunning,
|
|
kPending,
|
|
kSize,
|
|
kWriting,
|
|
kQueue,
|
|
kNoRef,
|
|
kKeepAliveDefaultTimeout,
|
|
kHostHeader,
|
|
kPendingIdx,
|
|
kRunningIdx,
|
|
kError,
|
|
kPipelining,
|
|
kSocket,
|
|
kKeepAliveTimeoutValue,
|
|
kMaxHeadersSize,
|
|
kKeepAliveMaxTimeout,
|
|
kKeepAliveTimeoutThreshold,
|
|
kHeadersTimeout,
|
|
kBodyTimeout,
|
|
kStrictContentLength,
|
|
kMaxRequests,
|
|
kCounter,
|
|
kMaxResponseSize,
|
|
kOnError,
|
|
kResume,
|
|
kHTTPContext
|
|
} = __nccwpck_require__(6443)
|
|
|
|
const constants = __nccwpck_require__(2824)
|
|
const EMPTY_BUF = Buffer.alloc(0)
|
|
const FastBuffer = Buffer[Symbol.species]
|
|
const addListener = util.addListener
|
|
const removeAllListeners = util.removeAllListeners
|
|
const kIdleSocketValidation = Symbol('kIdleSocketValidation')
|
|
const kIdleSocketValidationTimeout = Symbol('kIdleSocketValidationTimeout')
|
|
const kSocketUsed = Symbol('kSocketUsed')
|
|
|
|
let extractBody
|
|
|
|
async function lazyllhttp () {
|
|
const llhttpWasmData = process.env.JEST_WORKER_ID ? __nccwpck_require__(3870) : undefined
|
|
|
|
let mod
|
|
try {
|
|
mod = await WebAssembly.compile(__nccwpck_require__(3434))
|
|
} catch (e) {
|
|
/* istanbul ignore next */
|
|
|
|
// We could check if the error was caused by the simd option not
|
|
// being enabled, but the occurring of this other error
|
|
// * https://github.com/emscripten-core/emscripten/issues/11495
|
|
// got me to remove that check to avoid breaking Node 12.
|
|
mod = await WebAssembly.compile(llhttpWasmData || __nccwpck_require__(3870))
|
|
}
|
|
|
|
return await WebAssembly.instantiate(mod, {
|
|
env: {
|
|
/* eslint-disable camelcase */
|
|
|
|
wasm_on_url: (p, at, len) => {
|
|
/* istanbul ignore next */
|
|
return 0
|
|
},
|
|
wasm_on_status: (p, at, len) => {
|
|
assert(currentParser.ptr === p)
|
|
const start = at - currentBufferPtr + currentBufferRef.byteOffset
|
|
return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
|
|
},
|
|
wasm_on_message_begin: (p) => {
|
|
assert(currentParser.ptr === p)
|
|
return currentParser.onMessageBegin() || 0
|
|
},
|
|
wasm_on_header_field: (p, at, len) => {
|
|
assert(currentParser.ptr === p)
|
|
const start = at - currentBufferPtr + currentBufferRef.byteOffset
|
|
return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
|
|
},
|
|
wasm_on_header_value: (p, at, len) => {
|
|
assert(currentParser.ptr === p)
|
|
const start = at - currentBufferPtr + currentBufferRef.byteOffset
|
|
return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
|
|
},
|
|
wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
|
|
assert(currentParser.ptr === p)
|
|
return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0
|
|
},
|
|
wasm_on_body: (p, at, len) => {
|
|
assert(currentParser.ptr === p)
|
|
const start = at - currentBufferPtr + currentBufferRef.byteOffset
|
|
return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
|
|
},
|
|
wasm_on_message_complete: (p) => {
|
|
assert(currentParser.ptr === p)
|
|
return currentParser.onMessageComplete() || 0
|
|
}
|
|
|
|
/* eslint-enable camelcase */
|
|
}
|
|
})
|
|
}
|
|
|
|
let llhttpInstance = null
|
|
let llhttpPromise = lazyllhttp()
|
|
llhttpPromise.catch()
|
|
|
|
let currentParser = null
|
|
let currentBufferRef = null
|
|
let currentBufferSize = 0
|
|
let currentBufferPtr = null
|
|
|
|
const USE_NATIVE_TIMER = 0
|
|
const USE_FAST_TIMER = 1
|
|
|
|
// Use fast timers for headers and body to take eventual event loop
|
|
// latency into account.
|
|
const TIMEOUT_HEADERS = 2 | USE_FAST_TIMER
|
|
const TIMEOUT_BODY = 4 | USE_FAST_TIMER
|
|
|
|
// Use native timers to ignore event loop latency for keep-alive
|
|
// handling.
|
|
const TIMEOUT_KEEP_ALIVE = 8 | USE_NATIVE_TIMER
|
|
|
|
class Parser {
|
|
constructor (client, socket, { exports }) {
|
|
assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0)
|
|
|
|
this.llhttp = exports
|
|
this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE)
|
|
this.client = client
|
|
this.socket = socket
|
|
this.timeout = null
|
|
this.timeoutValue = null
|
|
this.timeoutType = null
|
|
this.statusCode = null
|
|
this.statusText = ''
|
|
this.upgrade = false
|
|
this.headers = []
|
|
this.headersSize = 0
|
|
this.headersMaxSize = client[kMaxHeadersSize]
|
|
this.shouldKeepAlive = false
|
|
this.paused = false
|
|
this.resume = this.resume.bind(this)
|
|
|
|
this.bytesRead = 0
|
|
|
|
this.keepAlive = ''
|
|
this.contentLength = ''
|
|
this.connection = ''
|
|
this.maxResponseSize = client[kMaxResponseSize]
|
|
}
|
|
|
|
setTimeout (delay, type) {
|
|
// If the existing timer and the new timer are of different timer type
|
|
// (fast or native) or have different delay, we need to clear the existing
|
|
// timer and set a new one.
|
|
if (
|
|
delay !== this.timeoutValue ||
|
|
(type & USE_FAST_TIMER) ^ (this.timeoutType & USE_FAST_TIMER)
|
|
) {
|
|
// If a timeout is already set, clear it with clearTimeout of the fast
|
|
// timer implementation, as it can clear fast and native timers.
|
|
if (this.timeout) {
|
|
timers.clearTimeout(this.timeout)
|
|
this.timeout = null
|
|
}
|
|
|
|
if (delay) {
|
|
if (type & USE_FAST_TIMER) {
|
|
this.timeout = timers.setFastTimeout(onParserTimeout, delay, new WeakRef(this))
|
|
} else {
|
|
this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this))
|
|
this.timeout.unref()
|
|
}
|
|
}
|
|
|
|
this.timeoutValue = delay
|
|
} else if (this.timeout) {
|
|
// istanbul ignore else: only for jest
|
|
if (this.timeout.refresh) {
|
|
this.timeout.refresh()
|
|
}
|
|
}
|
|
|
|
this.timeoutType = type
|
|
}
|
|
|
|
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) {
|
|
// istanbul ignore else: only for jest
|
|
if (this.timeout.refresh) {
|
|
this.timeout.refresh()
|
|
}
|
|
}
|
|
|
|
this.paused = false
|
|
this.execute(this.socket.read() || EMPTY_BUF) // Flush parser.
|
|
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)
|
|
|
|
// Call `execute` on the wasm parser.
|
|
// We pass the `llhttp_parser` pointer address, the pointer address of buffer view data,
|
|
// and finally the length of bytes to parse.
|
|
// The return value is an error code or `constants.ERROR.OK`.
|
|
try {
|
|
let ret
|
|
|
|
try {
|
|
currentBufferRef = data
|
|
currentParser = this
|
|
ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length)
|
|
/* eslint-disable-next-line no-useless-catch */
|
|
} catch (err) {
|
|
/* istanbul ignore next: difficult to make a test case for */
|
|
throw err
|
|
} finally {
|
|
currentParser = null
|
|
currentBufferRef = null
|
|
}
|
|
|
|
const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr
|
|
|
|
if (ret !== constants.ERROR.OK) {
|
|
const body = data.subarray(offset)
|
|
|
|
if (ret === constants.ERROR.PAUSED_UPGRADE) {
|
|
this.onUpgrade(body)
|
|
} else if (ret === constants.ERROR.PAUSED) {
|
|
this.paused = true
|
|
socket.unshift(body)
|
|
} else {
|
|
throw this.createError(ret, body)
|
|
}
|
|
}
|
|
} catch (err) {
|
|
util.destroy(socket, err)
|
|
}
|
|
}
|
|
|
|
finish () {
|
|
assert(currentParser === null)
|
|
assert(this.ptr != null)
|
|
assert(!this.paused)
|
|
|
|
const { llhttp } = this
|
|
|
|
let ret
|
|
|
|
try {
|
|
currentParser = this
|
|
ret = llhttp.llhttp_finish(this.ptr)
|
|
} finally {
|
|
currentParser = null
|
|
}
|
|
|
|
if (ret === constants.ERROR.OK) {
|
|
return null
|
|
}
|
|
|
|
if (ret === constants.ERROR.PAUSED || ret === constants.ERROR.PAUSED_UPGRADE) {
|
|
this.paused = true
|
|
return null
|
|
}
|
|
|
|
return this.createError(ret, EMPTY_BUF)
|
|
}
|
|
|
|
createError (ret, data) {
|
|
const { llhttp, contentLength, bytesRead } = this
|
|
|
|
if (contentLength && bytesRead !== parseInt(contentLength, 10)) {
|
|
return new ResponseContentLengthMismatchError()
|
|
}
|
|
|
|
const ptr = llhttp.llhttp_get_error_reason(this.ptr)
|
|
let message = ''
|
|
if (ptr) {
|
|
const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0)
|
|
message =
|
|
'Response does not match the HTTP/1.1 protocol (' +
|
|
Buffer.from(llhttp.memory.buffer, ptr, len).toString() +
|
|
')'
|
|
}
|
|
|
|
return new HTTPParserError(message, constants.ERROR[ret], data)
|
|
}
|
|
|
|
destroy () {
|
|
assert(this.ptr != null)
|
|
assert(currentParser == null)
|
|
|
|
this.llhttp.llhttp_free(this.ptr)
|
|
this.ptr = null
|
|
|
|
this.timeout && timers.clearTimeout(this.timeout)
|
|
this.timeout = null
|
|
this.timeoutValue = null
|
|
this.timeoutType = null
|
|
|
|
this.paused = false
|
|
}
|
|
|
|
onStatus (buf) {
|
|
this.statusText = buf.toString()
|
|
}
|
|
|
|
onMessageBegin () {
|
|
const { socket, client } = this
|
|
|
|
/* istanbul ignore next: difficult to make a test case for */
|
|
if (socket.destroyed) {
|
|
return -1
|
|
}
|
|
|
|
if (client[kRunning] === 0) {
|
|
util.destroy(socket, new SocketError('bad response', util.getSocketInfo(socket)))
|
|
return -1
|
|
}
|
|
|
|
const request = client[kQueue][client[kRunningIdx]]
|
|
if (!request) {
|
|
return -1
|
|
}
|
|
request.onResponseStarted()
|
|
}
|
|
|
|
onHeaderField (buf) {
|
|
const len = this.headers.length
|
|
|
|
if ((len & 1) === 0) {
|
|
this.headers.push(buf)
|
|
} else {
|
|
this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf])
|
|
}
|
|
|
|
this.trackHeader(buf.length)
|
|
}
|
|
|
|
onHeaderValue (buf) {
|
|
let len = this.headers.length
|
|
|
|
if ((len & 1) === 1) {
|
|
this.headers.push(buf)
|
|
len += 1
|
|
} else {
|
|
this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf])
|
|
}
|
|
|
|
const key = this.headers[len - 2]
|
|
if (key.length === 10) {
|
|
const headerName = util.bufferToLowerCasedHeaderName(key)
|
|
if (headerName === 'keep-alive') {
|
|
this.keepAlive += buf.toString()
|
|
} else if (headerName === 'connection') {
|
|
this.connection += buf.toString()
|
|
}
|
|
} else if (key.length === 14 && util.bufferToLowerCasedHeaderName(key) === 'content-length') {
|
|
this.contentLength += buf.toString()
|
|
}
|
|
|
|
this.trackHeader(buf.length)
|
|
}
|
|
|
|
trackHeader (len) {
|
|
this.headersSize += len
|
|
if (this.headersSize >= this.headersMaxSize) {
|
|
util.destroy(this.socket, new HeadersOverflowError())
|
|
}
|
|
}
|
|
|
|
onUpgrade (head) {
|
|
const { upgrade, client, socket, headers, statusCode } = this
|
|
|
|
assert(upgrade)
|
|
assert(client[kSocket] === socket)
|
|
assert(!socket.destroyed)
|
|
assert(!this.paused)
|
|
assert((headers.length & 1) === 0)
|
|
|
|
const request = client[kQueue][client[kRunningIdx]]
|
|
assert(request)
|
|
assert(request.upgrade || request.method === 'CONNECT')
|
|
|
|
this.statusCode = null
|
|
this.statusText = ''
|
|
this.shouldKeepAlive = null
|
|
|
|
this.headers = []
|
|
this.headersSize = 0
|
|
|
|
socket.unshift(head)
|
|
|
|
socket[kParser].destroy()
|
|
socket[kParser] = null
|
|
|
|
socket[kClient] = null
|
|
socket[kError] = null
|
|
|
|
removeAllListeners(socket)
|
|
|
|
client[kSocket] = null
|
|
client[kHTTPContext] = null // TODO (fix): This is hacky...
|
|
client[kQueue][client[kRunningIdx]++] = null
|
|
client.emit('disconnect', client[kUrl], [client], new InformationalError('upgrade'))
|
|
|
|
try {
|
|
request.onUpgrade(statusCode, headers, socket)
|
|
} catch (err) {
|
|
util.destroy(socket, err)
|
|
}
|
|
|
|
client[kResume]()
|
|
}
|
|
|
|
onHeadersComplete (statusCode, upgrade, shouldKeepAlive) {
|
|
const { client, socket, headers, statusText } = this
|
|
|
|
/* istanbul ignore next: difficult to make a test case for */
|
|
if (socket.destroyed) {
|
|
return -1
|
|
}
|
|
|
|
if (client[kRunning] === 0) {
|
|
util.destroy(socket, new SocketError('bad response', util.getSocketInfo(socket)))
|
|
return -1
|
|
}
|
|
|
|
const request = client[kQueue][client[kRunningIdx]]
|
|
|
|
/* istanbul ignore next: difficult to make a test case for */
|
|
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
|
|
}
|
|
|
|
/* this can only happen if server is misbehaving */
|
|
if (upgrade && !request.upgrade) {
|
|
util.destroy(socket, new SocketError('bad upgrade', util.getSocketInfo(socket)))
|
|
return -1
|
|
}
|
|
|
|
assert(this.timeoutType === TIMEOUT_HEADERS)
|
|
|
|
this.statusCode = statusCode
|
|
this.shouldKeepAlive = (
|
|
shouldKeepAlive ||
|
|
// Override llhttp value which does not allow keepAlive for HEAD.
|
|
(request.method === 'HEAD' && !socket[kReset] && this.connection.toLowerCase() === 'keep-alive')
|
|
)
|
|
|
|
if (this.statusCode >= 200) {
|
|
const bodyTimeout = request.bodyTimeout != null
|
|
? request.bodyTimeout
|
|
: client[kBodyTimeout]
|
|
this.setTimeout(bodyTimeout, TIMEOUT_BODY)
|
|
} else if (this.timeout) {
|
|
// istanbul ignore else: only for jest
|
|
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 & 1) === 0)
|
|
this.headers = []
|
|
this.headersSize = 0
|
|
|
|
if (this.shouldKeepAlive && client[kPipelining]) {
|
|
const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null
|
|
|
|
if (keepAliveTimeout != null) {
|
|
const timeout = Math.min(
|
|
keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
|
|
client[kKeepAliveMaxTimeout]
|
|
)
|
|
if (timeout <= 0) {
|
|
socket[kReset] = true
|
|
} else {
|
|
client[kKeepAliveTimeoutValue] = timeout
|
|
}
|
|
} else {
|
|
client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout]
|
|
}
|
|
} else {
|
|
// Stop more requests from being dispatched.
|
|
socket[kReset] = true
|
|
}
|
|
|
|
const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false
|
|
|
|
if (request.aborted) {
|
|
return -1
|
|
}
|
|
|
|
if (request.method === 'HEAD') {
|
|
return 1
|
|
}
|
|
|
|
if (statusCode < 200) {
|
|
return 1
|
|
}
|
|
|
|
if (socket[kBlocking]) {
|
|
socket[kBlocking] = false
|
|
client[kResume]()
|
|
}
|
|
|
|
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(this.timeoutType === TIMEOUT_BODY)
|
|
if (this.timeout) {
|
|
// istanbul ignore else: only for jest
|
|
if (this.timeout.refresh) {
|
|
this.timeout.refresh()
|
|
}
|
|
}
|
|
|
|
assert(statusCode >= 200)
|
|
|
|
if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
|
|
util.destroy(socket, new ResponseExceededMaxSizeError())
|
|
return -1
|
|
}
|
|
|
|
this.bytesRead += buf.length
|
|
|
|
if (request.onData(buf) === false) {
|
|
return constants.ERROR.PAUSED
|
|
}
|
|
}
|
|
|
|
onMessageComplete () {
|
|
const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this
|
|
|
|
if (socket.destroyed && (!statusCode || shouldKeepAlive)) {
|
|
return -1
|
|
}
|
|
|
|
if (upgrade) {
|
|
return
|
|
}
|
|
|
|
assert(statusCode >= 100)
|
|
assert((this.headers.length & 1) === 0)
|
|
|
|
const request = client[kQueue][client[kRunningIdx]]
|
|
assert(request)
|
|
|
|
this.statusCode = null
|
|
this.statusText = ''
|
|
this.bytesRead = 0
|
|
this.contentLength = ''
|
|
this.keepAlive = ''
|
|
this.connection = ''
|
|
|
|
this.headers = []
|
|
this.headersSize = 0
|
|
|
|
if (statusCode < 200) {
|
|
return
|
|
}
|
|
|
|
/* istanbul ignore next: should be handled by llhttp? */
|
|
if (request.method !== 'HEAD' && contentLength && bytesRead !== parseInt(contentLength, 10)) {
|
|
util.destroy(socket, new ResponseContentLengthMismatchError())
|
|
return -1
|
|
}
|
|
|
|
request.onComplete(headers)
|
|
|
|
client[kQueue][client[kRunningIdx]++] = null
|
|
socket[kSocketUsed] = true
|
|
|
|
if (socket[kWriting]) {
|
|
assert(client[kRunning] === 0)
|
|
// Response completed before request.
|
|
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) {
|
|
// Destroy socket once all requests have completed.
|
|
// The request at the tail of the pipeline is the one
|
|
// that requested reset and no further requests should
|
|
// have been queued since then.
|
|
util.destroy(socket, new InformationalError('reset'))
|
|
return constants.ERROR.PAUSED
|
|
} else if (client[kPipelining] == null || client[kPipelining] === 1) {
|
|
// We must wait a full event loop cycle to reuse this socket to make sure
|
|
// that non-spec compliant servers are not closing the connection even if they
|
|
// said they won't.
|
|
setImmediate(() => client[kResume]())
|
|
} else {
|
|
client[kResume]()
|
|
}
|
|
}
|
|
}
|
|
|
|
function onParserTimeout (parser) {
|
|
const { socket, timeoutType, client, paused } = parser.deref()
|
|
|
|
/* istanbul ignore else */
|
|
if (timeoutType === TIMEOUT_HEADERS) {
|
|
if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
|
|
assert(!paused, 'cannot be paused while waiting for headers')
|
|
util.destroy(socket, new HeadersTimeoutError())
|
|
}
|
|
} else if (timeoutType === TIMEOUT_BODY) {
|
|
if (!paused) {
|
|
util.destroy(socket, new BodyTimeoutError())
|
|
}
|
|
} else if (timeoutType === TIMEOUT_KEEP_ALIVE) {
|
|
assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue])
|
|
util.destroy(socket, new InformationalError('socket idle timeout'))
|
|
}
|
|
}
|
|
|
|
async function connectH1 (client, socket) {
|
|
client[kSocket] = socket
|
|
|
|
if (!llhttpInstance) {
|
|
llhttpInstance = await llhttpPromise
|
|
llhttpPromise = null
|
|
}
|
|
|
|
socket[kNoRef] = false
|
|
socket[kWriting] = false
|
|
socket[kReset] = false
|
|
socket[kBlocking] = false
|
|
socket[kIdleSocketValidation] = 0
|
|
socket[kIdleSocketValidationTimeout] = null
|
|
socket[kSocketUsed] = false
|
|
socket[kParser] = new Parser(client, socket, llhttpInstance)
|
|
|
|
addListener(socket, 'error', function (err) {
|
|
assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
|
|
|
|
const parser = this[kParser]
|
|
|
|
// On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded
|
|
// to the user.
|
|
if (err.code === 'ECONNRESET' && parser.statusCode && !parser.shouldKeepAlive) {
|
|
const parserErr = parser.finish()
|
|
if (parserErr) {
|
|
this[kError] = parserErr
|
|
this[kClient][kOnError](parserErr)
|
|
}
|
|
return
|
|
}
|
|
|
|
this[kError] = err
|
|
|
|
this[kClient][kOnError](err)
|
|
})
|
|
addListener(socket, 'readable', function () {
|
|
const parser = this[kParser]
|
|
|
|
if (parser) {
|
|
parser.readMore()
|
|
}
|
|
})
|
|
addListener(socket, 'end', function () {
|
|
const parser = this[kParser]
|
|
|
|
if (parser.statusCode && !parser.shouldKeepAlive) {
|
|
const parserErr = parser.finish()
|
|
if (parserErr) {
|
|
util.destroy(this, parserErr)
|
|
}
|
|
return
|
|
}
|
|
|
|
util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
|
|
})
|
|
addListener(socket, 'close', function () {
|
|
const client = this[kClient]
|
|
const parser = this[kParser]
|
|
|
|
clearIdleSocketValidation(this)
|
|
|
|
if (parser) {
|
|
if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
|
|
this[kError] = parser.finish() || this[kError]
|
|
}
|
|
|
|
this[kParser].destroy()
|
|
this[kParser] = null
|
|
}
|
|
|
|
const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
|
|
|
|
client[kSocket] = null
|
|
client[kHTTPContext] = null // TODO (fix): This is hacky...
|
|
|
|
if (client.destroyed) {
|
|
assert(client[kPending] === 0)
|
|
|
|
// Fail entire queue.
|
|
const requests = client[kQueue].splice(client[kRunningIdx])
|
|
for (let i = 0; i < requests.length; i++) {
|
|
const request = requests[i]
|
|
util.errorRequest(client, request, err)
|
|
}
|
|
} else if (client[kRunning] > 0 && err.code !== 'UND_ERR_INFO') {
|
|
// Fail head of pipeline.
|
|
const request = client[kQueue][client[kRunningIdx]]
|
|
client[kQueue][client[kRunningIdx]++] = null
|
|
|
|
util.errorRequest(client, request, err)
|
|
}
|
|
|
|
client[kPendingIdx] = client[kRunningIdx]
|
|
|
|
assert(client[kRunning] === 0)
|
|
|
|
client.emit('disconnect', client[kUrl], [client], err)
|
|
|
|
client[kResume]()
|
|
})
|
|
|
|
let closed = false
|
|
socket.on('close', () => {
|
|
closed = true
|
|
})
|
|
|
|
return {
|
|
version: 'h1',
|
|
defaultPipelining: 1,
|
|
write (...args) {
|
|
return writeH1(client, ...args)
|
|
},
|
|
resume () {
|
|
resumeH1(client)
|
|
},
|
|
destroy (err, callback) {
|
|
if (closed) {
|
|
queueMicrotask(callback)
|
|
} else {
|
|
socket.destroy(err).on('close', callback)
|
|
}
|
|
},
|
|
get destroyed () {
|
|
return socket.destroyed
|
|
},
|
|
busy (request) {
|
|
if (socket[kWriting] || socket[kReset] || socket[kBlocking] || socket[kIdleSocketValidation] === 1) {
|
|
return true
|
|
}
|
|
|
|
if (request) {
|
|
if (client[kRunning] > 0 && !request.idempotent) {
|
|
// Non-idempotent request cannot be retried.
|
|
// Ensure that no other requests are inflight and
|
|
// could cause failure.
|
|
return true
|
|
}
|
|
|
|
if (client[kRunning] > 0 && (request.upgrade || request.method === 'CONNECT')) {
|
|
// Don't dispatch an upgrade until all preceding requests have completed.
|
|
// A misbehaving server might upgrade the connection before all pipelined
|
|
// request has completed.
|
|
return true
|
|
}
|
|
|
|
if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 &&
|
|
(util.isStream(request.body) || util.isAsyncIterable(request.body) || util.isFormDataLike(request.body))) {
|
|
// Request with stream or iterator body can error while other requests
|
|
// are inflight and indirectly error those as well.
|
|
// Ensure this doesn't happen by waiting for inflight
|
|
// to complete before dispatching.
|
|
|
|
// Request with stream or iterator body cannot be retried.
|
|
// Ensure that no other requests are inflight and
|
|
// could cause failure.
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
function clearIdleSocketValidation (socket) {
|
|
if (socket[kIdleSocketValidationTimeout]) {
|
|
clearTimeout(socket[kIdleSocketValidationTimeout])
|
|
socket[kIdleSocketValidationTimeout] = null
|
|
}
|
|
|
|
socket[kIdleSocketValidation] = 0
|
|
}
|
|
|
|
function scheduleIdleSocketValidation (client, socket) {
|
|
socket[kIdleSocketValidation] = 1
|
|
socket[kIdleSocketValidationTimeout] = setTimeout(() => {
|
|
socket[kIdleSocketValidationTimeout] = null
|
|
socket[kIdleSocketValidation] = 2
|
|
|
|
if (client[kSocket] === socket && !socket.destroyed) {
|
|
client[kResume]()
|
|
}
|
|
}, 0)
|
|
socket[kIdleSocketValidationTimeout].unref?.()
|
|
}
|
|
|
|
/**
|
|
* @param {import('./client.js')} client
|
|
*/
|
|
function resumeH1 (client) {
|
|
const socket = client[kSocket]
|
|
|
|
if (socket && !socket.destroyed) {
|
|
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[kRunning] === 0 && client[kPending] > 0 && socket[kSocketUsed]) {
|
|
if (socket[kIdleSocketValidation] === 0) {
|
|
scheduleIdleSocketValidation(client, socket)
|
|
socket[kParser].readMore()
|
|
if (socket.destroyed) {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
if (socket[kIdleSocketValidation] === 1) {
|
|
socket[kParser].readMore()
|
|
if (socket.destroyed) {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
}
|
|
|
|
if (client[kRunning] === 0) {
|
|
socket[kParser].readMore()
|
|
if (socket.destroyed) {
|
|
return
|
|
}
|
|
}
|
|
|
|
if (client[kSize] === 0) {
|
|
if (socket[kParser].timeoutType !== TIMEOUT_KEEP_ALIVE) {
|
|
socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_KEEP_ALIVE)
|
|
}
|
|
} else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
|
|
if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
|
|
const request = client[kQueue][client[kRunningIdx]]
|
|
const headersTimeout = request.headersTimeout != null
|
|
? request.headersTimeout
|
|
: client[kHeadersTimeout]
|
|
socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// https://www.rfc-editor.org/rfc/rfc7230#section-3.3.2
|
|
function shouldSendContentLength (method) {
|
|
return method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS' && method !== 'TRACE' && method !== 'CONNECT'
|
|
}
|
|
|
|
function writeH1 (client, request) {
|
|
const { method, path, host, upgrade, blocking, reset } = request
|
|
|
|
let { body, headers, contentLength } = request
|
|
|
|
// https://tools.ietf.org/html/rfc7231#section-4.3.1
|
|
// https://tools.ietf.org/html/rfc7231#section-4.3.2
|
|
// https://tools.ietf.org/html/rfc7231#section-4.3.5
|
|
|
|
// Sending a payload body on a request that does not
|
|
// expect it can cause undefined behavior on some
|
|
// servers and corrupt connection state. Do not
|
|
// re-use the connection for further requests.
|
|
|
|
const expectsPayload = (
|
|
method === 'PUT' ||
|
|
method === 'POST' ||
|
|
method === 'PATCH' ||
|
|
method === 'QUERY' ||
|
|
method === 'PROPFIND' ||
|
|
method === 'PROPPATCH'
|
|
)
|
|
|
|
if (util.isFormDataLike(body)) {
|
|
if (!extractBody) {
|
|
extractBody = (__nccwpck_require__(4492).extractBody)
|
|
}
|
|
|
|
const [bodyStream, contentType] = extractBody(body)
|
|
if (request.contentType == null) {
|
|
headers.push('content-type', contentType)
|
|
}
|
|
body = bodyStream.stream
|
|
contentLength = bodyStream.length
|
|
} else if (util.isBlobLike(body) && request.contentType == null && body.type) {
|
|
headers.push('content-type', body.type)
|
|
}
|
|
|
|
if (body && typeof body.read === 'function') {
|
|
// Try to read EOF in order to get length.
|
|
body.read(0)
|
|
}
|
|
|
|
const bodyLength = util.bodyLength(body)
|
|
|
|
contentLength = bodyLength ?? contentLength
|
|
|
|
if (contentLength === null) {
|
|
contentLength = request.contentLength
|
|
}
|
|
|
|
if (contentLength === 0 && !expectsPayload) {
|
|
// https://tools.ietf.org/html/rfc7230#section-3.3.2
|
|
// A user agent SHOULD NOT send a Content-Length header field when
|
|
// the request message does not contain a payload body and the method
|
|
// semantics do not anticipate such a body.
|
|
|
|
contentLength = null
|
|
}
|
|
|
|
// https://github.com/nodejs/undici/issues/2046
|
|
// A user agent may send a Content-Length header with 0 value, this should be allowed.
|
|
if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) {
|
|
if (client[kStrictContentLength]) {
|
|
util.errorRequest(client, request, new RequestContentLengthMismatchError())
|
|
return false
|
|
}
|
|
|
|
process.emitWarning(new RequestContentLengthMismatchError())
|
|
}
|
|
|
|
const socket = client[kSocket]
|
|
clearIdleSocketValidation(socket)
|
|
|
|
const abort = (err) => {
|
|
if (request.aborted || request.completed) {
|
|
return
|
|
}
|
|
|
|
util.errorRequest(client, request, err || new RequestAbortedError())
|
|
|
|
util.destroy(body)
|
|
util.destroy(socket, new InformationalError('aborted'))
|
|
}
|
|
|
|
try {
|
|
request.onConnect(abort)
|
|
} catch (err) {
|
|
util.errorRequest(client, request, err)
|
|
}
|
|
|
|
if (request.aborted) {
|
|
return false
|
|
}
|
|
|
|
if (method === 'HEAD') {
|
|
// https://github.com/mcollina/undici/issues/258
|
|
// Close after a HEAD request to interop with misbehaving servers
|
|
// that may send a body in the response.
|
|
|
|
socket[kReset] = true
|
|
}
|
|
|
|
if (upgrade || method === 'CONNECT') {
|
|
// On CONNECT or upgrade, block pipeline from dispatching further
|
|
// requests on this connection.
|
|
|
|
socket[kReset] = true
|
|
}
|
|
|
|
if (reset != null) {
|
|
socket[kReset] = reset
|
|
}
|
|
|
|
if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) {
|
|
socket[kReset] = true
|
|
}
|
|
|
|
if (blocking) {
|
|
socket[kBlocking] = true
|
|
}
|
|
|
|
let header = `${method} ${path} HTTP/1.1\r\n`
|
|
|
|
if (typeof host === 'string') {
|
|
header += `host: ${host}\r\n`
|
|
} else {
|
|
header += client[kHostHeader]
|
|
}
|
|
|
|
if (upgrade) {
|
|
header += `connection: upgrade\r\nupgrade: ${upgrade}\r\n`
|
|
} else if (client[kPipelining] && !socket[kReset]) {
|
|
header += 'connection: keep-alive\r\n'
|
|
} else {
|
|
header += 'connection: close\r\n'
|
|
}
|
|
|
|
if (Array.isArray(headers)) {
|
|
for (let n = 0; n < headers.length; n += 2) {
|
|
const key = headers[n + 0]
|
|
const val = headers[n + 1]
|
|
|
|
if (Array.isArray(val)) {
|
|
for (let i = 0; i < val.length; i++) {
|
|
header += `${key}: ${val[i]}\r\n`
|
|
}
|
|
} else {
|
|
header += `${key}: ${val}\r\n`
|
|
}
|
|
}
|
|
}
|
|
|
|
if (channels.sendHeaders.hasSubscribers) {
|
|
channels.sendHeaders.publish({ request, headers: header, socket })
|
|
}
|
|
|
|
/* istanbul ignore else: assertion */
|
|
if (!body || bodyLength === 0) {
|
|
writeBuffer(abort, null, client, request, socket, contentLength, header, expectsPayload)
|
|
} else if (util.isBuffer(body)) {
|
|
writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload)
|
|
} else if (util.isBlobLike(body)) {
|
|
if (typeof body.stream === 'function') {
|
|
writeIterable(abort, body.stream(), client, request, socket, contentLength, header, expectsPayload)
|
|
} else {
|
|
writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload)
|
|
}
|
|
} else if (util.isStream(body)) {
|
|
writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload)
|
|
} else if (util.isIterable(body)) {
|
|
writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload)
|
|
} else {
|
|
assert(false)
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
function writeStream (abort, 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({ abort, socket, request, contentLength, client, expectsPayload, header })
|
|
|
|
const onData = function (chunk) {
|
|
if (finished) {
|
|
return
|
|
}
|
|
|
|
try {
|
|
if (!writer.write(chunk) && this.pause) {
|
|
this.pause()
|
|
}
|
|
} catch (err) {
|
|
util.destroy(this, err)
|
|
}
|
|
}
|
|
const onDrain = function () {
|
|
if (finished) {
|
|
return
|
|
}
|
|
|
|
if (body.resume) {
|
|
body.resume()
|
|
}
|
|
}
|
|
const onClose = function () {
|
|
// 'close' might be emitted *before* 'error' for
|
|
// broken streams. Wait a tick to avoid this case.
|
|
queueMicrotask(() => {
|
|
// It's only safe to remove 'error' listener after
|
|
// 'close'.
|
|
body.removeListener('error', onFinished)
|
|
})
|
|
|
|
if (!finished) {
|
|
const err = new RequestAbortedError()
|
|
queueMicrotask(() => onFinished(err))
|
|
}
|
|
}
|
|
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('close', onClose)
|
|
|
|
if (!err) {
|
|
try {
|
|
writer.end()
|
|
} catch (er) {
|
|
err = er
|
|
}
|
|
}
|
|
|
|
writer.destroy(err)
|
|
|
|
if (err && (err.code !== 'UND_ERR_INFO' || err.message !== 'reset')) {
|
|
util.destroy(body, err)
|
|
} else {
|
|
util.destroy(body)
|
|
}
|
|
}
|
|
|
|
body
|
|
.on('data', onData)
|
|
.on('end', onFinished)
|
|
.on('error', onFinished)
|
|
.on('close', onClose)
|
|
|
|
if (body.resume) {
|
|
body.resume()
|
|
}
|
|
|
|
socket
|
|
.on('drain', onDrain)
|
|
.on('error', onFinished)
|
|
|
|
if (body.errorEmitted ?? body.errored) {
|
|
setImmediate(() => onFinished(body.errored))
|
|
} else if (body.endEmitted ?? body.readableEnded) {
|
|
setImmediate(() => onFinished(null))
|
|
}
|
|
|
|
if (body.closeEmitted ?? body.closed) {
|
|
setImmediate(onClose)
|
|
}
|
|
}
|
|
|
|
function writeBuffer (abort, body, client, request, socket, contentLength, header, expectsPayload) {
|
|
try {
|
|
if (!body) {
|
|
if (contentLength === 0) {
|
|
socket.write(`${header}content-length: 0\r\n\r\n`, 'latin1')
|
|
} else {
|
|
assert(contentLength === null, 'no body must not have content length')
|
|
socket.write(`${header}\r\n`, 'latin1')
|
|
}
|
|
} else if (util.isBuffer(body)) {
|
|
assert(contentLength === body.byteLength, 'buffer body must have content length')
|
|
|
|
socket.cork()
|
|
socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1')
|
|
socket.write(body)
|
|
socket.uncork()
|
|
request.onBodySent(body)
|
|
|
|
if (!expectsPayload && request.reset !== false) {
|
|
socket[kReset] = true
|
|
}
|
|
}
|
|
request.onRequestSent()
|
|
|
|
client[kResume]()
|
|
} catch (err) {
|
|
abort(err)
|
|
}
|
|
}
|
|
|
|
async function writeBlob (abort, body, client, request, socket, contentLength, header, expectsPayload) {
|
|
assert(contentLength === body.size, 'blob body must have content length')
|
|
|
|
try {
|
|
if (contentLength != null && contentLength !== body.size) {
|
|
throw new RequestContentLengthMismatchError()
|
|
}
|
|
|
|
const buffer = Buffer.from(await body.arrayBuffer())
|
|
|
|
socket.cork()
|
|
socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1')
|
|
socket.write(buffer)
|
|
socket.uncork()
|
|
|
|
request.onBodySent(buffer)
|
|
request.onRequestSent()
|
|
|
|
if (!expectsPayload && request.reset !== false) {
|
|
socket[kReset] = true
|
|
}
|
|
|
|
client[kResume]()
|
|
} catch (err) {
|
|
abort(err)
|
|
}
|
|
}
|
|
|
|
async function writeIterable (abort, body, client, request, socket, contentLength, header, expectsPayload) {
|
|
assert(contentLength !== 0 || client[kRunning] === 0, 'iterator body cannot be pipelined')
|
|
|
|
let callback = null
|
|
function onDrain () {
|
|
if (callback) {
|
|
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({ abort, socket, request, contentLength, client, expectsPayload, header })
|
|
try {
|
|
// It's up to the user to somehow abort the async iterable.
|
|
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)
|
|
}
|
|
}
|
|
|
|
class AsyncWriter {
|
|
constructor ({ abort, socket, request, contentLength, client, expectsPayload, header }) {
|
|
this.socket = socket
|
|
this.request = request
|
|
this.contentLength = contentLength
|
|
this.client = client
|
|
this.bytesWritten = 0
|
|
this.expectsPayload = expectsPayload
|
|
this.header = header
|
|
this.abort = abort
|
|
|
|
socket[kWriting] = 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
|
|
}
|
|
|
|
// We should defer writing chunks.
|
|
if (contentLength !== null && bytesWritten + len > contentLength) {
|
|
if (client[kStrictContentLength]) {
|
|
throw new RequestContentLengthMismatchError()
|
|
}
|
|
|
|
process.emitWarning(new RequestContentLengthMismatchError())
|
|
}
|
|
|
|
socket.cork()
|
|
|
|
if (bytesWritten === 0) {
|
|
if (!expectsPayload && request.reset !== false) {
|
|
socket[kReset] = true
|
|
}
|
|
|
|
if (contentLength === null) {
|
|
socket.write(`${header}transfer-encoding: chunked\r\n`, 'latin1')
|
|
} else {
|
|
socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1')
|
|
}
|
|
}
|
|
|
|
if (contentLength === null) {
|
|
socket.write(`\r\n${len.toString(16)}\r\n`, 'latin1')
|
|
}
|
|
|
|
this.bytesWritten += len
|
|
|
|
const ret = socket.write(chunk)
|
|
|
|
socket.uncork()
|
|
|
|
request.onBodySent(chunk)
|
|
|
|
if (!ret) {
|
|
if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
|
|
// istanbul ignore else: only for jest
|
|
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) {
|
|
// https://tools.ietf.org/html/rfc7230#section-3.3.2
|
|
// A user agent SHOULD send a Content-Length in a request message when
|
|
// no Transfer-Encoding is sent and the request method defines a meaning
|
|
// for an enclosed payload body.
|
|
|
|
socket.write(`${header}content-length: 0\r\n\r\n`, 'latin1')
|
|
} else {
|
|
socket.write(`${header}\r\n`, 'latin1')
|
|
}
|
|
} else if (contentLength === null) {
|
|
socket.write('\r\n0\r\n\r\n', 'latin1')
|
|
}
|
|
|
|
if (contentLength !== null && bytesWritten !== contentLength) {
|
|
if (client[kStrictContentLength]) {
|
|
throw new RequestContentLengthMismatchError()
|
|
} else {
|
|
process.emitWarning(new RequestContentLengthMismatchError())
|
|
}
|
|
}
|
|
|
|
if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
|
|
// istanbul ignore else: only for jest
|
|
if (socket[kParser].timeout.refresh) {
|
|
socket[kParser].timeout.refresh()
|
|
}
|
|
}
|
|
|
|
client[kResume]()
|
|
}
|
|
|
|
destroy (err) {
|
|
const { socket, client, abort } = this
|
|
|
|
socket[kWriting] = false
|
|
|
|
if (err) {
|
|
assert(client[kRunning] <= 1, 'pipeline should only contain this request')
|
|
abort(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = connectH1
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8788:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const assert = __nccwpck_require__(4589)
|
|
const { pipeline } = __nccwpck_require__(7075)
|
|
const util = __nccwpck_require__(3440)
|
|
const {
|
|
RequestContentLengthMismatchError,
|
|
RequestAbortedError,
|
|
SocketError,
|
|
InformationalError
|
|
} = __nccwpck_require__(8707)
|
|
const {
|
|
kUrl,
|
|
kReset,
|
|
kClient,
|
|
kRunning,
|
|
kPending,
|
|
kQueue,
|
|
kPendingIdx,
|
|
kRunningIdx,
|
|
kError,
|
|
kSocket,
|
|
kStrictContentLength,
|
|
kOnError,
|
|
kMaxConcurrentStreams,
|
|
kHTTP2Session,
|
|
kResume,
|
|
kSize,
|
|
kHTTPContext
|
|
} = __nccwpck_require__(6443)
|
|
|
|
const kOpenStreams = Symbol('open streams')
|
|
|
|
let extractBody
|
|
|
|
// Experimental
|
|
let h2ExperimentalWarned = false
|
|
|
|
/** @type {import('http2')} */
|
|
let http2
|
|
try {
|
|
http2 = __nccwpck_require__(2467)
|
|
} catch {
|
|
// @ts-ignore
|
|
http2 = { constants: {} }
|
|
}
|
|
|
|
const {
|
|
constants: {
|
|
HTTP2_HEADER_AUTHORITY,
|
|
HTTP2_HEADER_METHOD,
|
|
HTTP2_HEADER_PATH,
|
|
HTTP2_HEADER_SCHEME,
|
|
HTTP2_HEADER_CONTENT_LENGTH,
|
|
HTTP2_HEADER_EXPECT,
|
|
HTTP2_HEADER_STATUS
|
|
}
|
|
} = http2
|
|
|
|
function parseH2Headers (headers) {
|
|
const result = []
|
|
|
|
for (const [name, value] of Object.entries(headers)) {
|
|
// h2 may concat the header value by array
|
|
// e.g. Set-Cookie
|
|
if (Array.isArray(value)) {
|
|
for (const subvalue of value) {
|
|
// we need to provide each header value of header name
|
|
// because the headers handler expect name-value pair
|
|
result.push(Buffer.from(name), Buffer.from(subvalue))
|
|
}
|
|
} else {
|
|
result.push(Buffer.from(name), Buffer.from(value))
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
async function connectH2 (client, socket) {
|
|
client[kSocket] = socket
|
|
|
|
if (!h2ExperimentalWarned) {
|
|
h2ExperimentalWarned = true
|
|
process.emitWarning('H2 support is experimental, expect them to change at any time.', {
|
|
code: 'UNDICI-H2'
|
|
})
|
|
}
|
|
|
|
const session = http2.connect(client[kUrl], {
|
|
createConnection: () => socket,
|
|
peerMaxConcurrentStreams: client[kMaxConcurrentStreams]
|
|
})
|
|
|
|
session[kOpenStreams] = 0
|
|
session[kClient] = client
|
|
session[kSocket] = socket
|
|
|
|
util.addListener(session, 'error', onHttp2SessionError)
|
|
util.addListener(session, 'frameError', onHttp2FrameError)
|
|
util.addListener(session, 'end', onHttp2SessionEnd)
|
|
util.addListener(session, 'goaway', onHTTP2GoAway)
|
|
util.addListener(session, 'close', function () {
|
|
const { [kClient]: client } = this
|
|
const { [kSocket]: socket } = client
|
|
|
|
const err = this[kSocket][kError] || this[kError] || new SocketError('closed', util.getSocketInfo(socket))
|
|
|
|
client[kHTTP2Session] = null
|
|
|
|
if (client.destroyed) {
|
|
assert(client[kPending] === 0)
|
|
|
|
// Fail entire queue.
|
|
const requests = client[kQueue].splice(client[kRunningIdx])
|
|
for (let i = 0; i < requests.length; i++) {
|
|
const request = requests[i]
|
|
util.errorRequest(client, request, err)
|
|
}
|
|
}
|
|
})
|
|
|
|
session.unref()
|
|
|
|
client[kHTTP2Session] = session
|
|
socket[kHTTP2Session] = session
|
|
|
|
util.addListener(socket, 'error', function (err) {
|
|
assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
|
|
|
|
this[kError] = err
|
|
|
|
this[kClient][kOnError](err)
|
|
})
|
|
|
|
util.addListener(socket, 'end', function () {
|
|
util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
|
|
})
|
|
|
|
util.addListener(socket, 'close', function () {
|
|
const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
|
|
|
|
client[kSocket] = null
|
|
|
|
if (this[kHTTP2Session] != null) {
|
|
this[kHTTP2Session].destroy(err)
|
|
}
|
|
|
|
client[kPendingIdx] = client[kRunningIdx]
|
|
|
|
assert(client[kRunning] === 0)
|
|
|
|
client.emit('disconnect', client[kUrl], [client], err)
|
|
|
|
client[kResume]()
|
|
})
|
|
|
|
let closed = false
|
|
socket.on('close', () => {
|
|
closed = true
|
|
})
|
|
|
|
return {
|
|
version: 'h2',
|
|
defaultPipelining: Infinity,
|
|
write (...args) {
|
|
return writeH2(client, ...args)
|
|
},
|
|
resume () {
|
|
resumeH2(client)
|
|
},
|
|
destroy (err, callback) {
|
|
if (closed) {
|
|
queueMicrotask(callback)
|
|
} else {
|
|
// Destroying the socket will trigger the session close
|
|
socket.destroy(err).on('close', callback)
|
|
}
|
|
},
|
|
get destroyed () {
|
|
return socket.destroyed
|
|
},
|
|
busy () {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
function resumeH2 (client) {
|
|
const socket = client[kSocket]
|
|
|
|
if (socket?.destroyed === false) {
|
|
if (client[kSize] === 0 && client[kMaxConcurrentStreams] === 0) {
|
|
socket.unref()
|
|
client[kHTTP2Session].unref()
|
|
} else {
|
|
socket.ref()
|
|
client[kHTTP2Session].ref()
|
|
}
|
|
}
|
|
}
|
|
|
|
function onHttp2SessionError (err) {
|
|
assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
|
|
|
|
this[kSocket][kError] = err
|
|
this[kClient][kOnError](err)
|
|
}
|
|
|
|
function onHttp2FrameError (type, code, id) {
|
|
if (id === 0) {
|
|
const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)
|
|
this[kSocket][kError] = err
|
|
this[kClient][kOnError](err)
|
|
}
|
|
}
|
|
|
|
function onHttp2SessionEnd () {
|
|
const err = new SocketError('other side closed', util.getSocketInfo(this[kSocket]))
|
|
this.destroy(err)
|
|
util.destroy(this[kSocket], err)
|
|
}
|
|
|
|
/**
|
|
* This is the root cause of #3011
|
|
* We need to handle GOAWAY frames properly, and trigger the session close
|
|
* along with the socket right away
|
|
*/
|
|
function onHTTP2GoAway (code) {
|
|
// We cannot recover, so best to close the session and the socket
|
|
const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${code}`, util.getSocketInfo(this))
|
|
const client = this[kClient]
|
|
|
|
client[kSocket] = null
|
|
client[kHTTPContext] = null
|
|
|
|
if (this[kHTTP2Session] != null) {
|
|
this[kHTTP2Session].destroy(err)
|
|
this[kHTTP2Session] = null
|
|
}
|
|
|
|
util.destroy(this[kSocket], err)
|
|
|
|
// Fail head of pipeline.
|
|
if (client[kRunningIdx] < client[kQueue].length) {
|
|
const request = client[kQueue][client[kRunningIdx]]
|
|
client[kQueue][client[kRunningIdx]++] = null
|
|
util.errorRequest(client, request, err)
|
|
client[kPendingIdx] = client[kRunningIdx]
|
|
}
|
|
|
|
assert(client[kRunning] === 0)
|
|
|
|
client.emit('disconnect', client[kUrl], [client], err)
|
|
|
|
client[kResume]()
|
|
}
|
|
|
|
// https://www.rfc-editor.org/rfc/rfc7230#section-3.3.2
|
|
function shouldSendContentLength (method) {
|
|
return method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS' && method !== 'TRACE' && method !== 'CONNECT'
|
|
}
|
|
|
|
function writeH2 (client, request) {
|
|
const session = client[kHTTP2Session]
|
|
const { method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request
|
|
let { body } = request
|
|
|
|
if (upgrade) {
|
|
util.errorRequest(client, request, new Error('Upgrade not supported for H2'))
|
|
return false
|
|
}
|
|
|
|
const headers = {}
|
|
for (let n = 0; n < reqHeaders.length; n += 2) {
|
|
const key = reqHeaders[n + 0]
|
|
const val = reqHeaders[n + 1]
|
|
|
|
if (Array.isArray(val)) {
|
|
for (let i = 0; i < val.length; i++) {
|
|
if (headers[key]) {
|
|
headers[key] += `,${val[i]}`
|
|
} else {
|
|
headers[key] = val[i]
|
|
}
|
|
}
|
|
} else {
|
|
headers[key] = val
|
|
}
|
|
}
|
|
|
|
/** @type {import('node:http2').ClientHttp2Stream} */
|
|
let stream
|
|
|
|
const { hostname, port } = client[kUrl]
|
|
|
|
headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ''}`
|
|
headers[HTTP2_HEADER_METHOD] = method
|
|
|
|
const abort = (err) => {
|
|
if (request.aborted || request.completed) {
|
|
return
|
|
}
|
|
|
|
err = err || new RequestAbortedError()
|
|
|
|
util.errorRequest(client, request, err)
|
|
|
|
if (stream != null) {
|
|
util.destroy(stream, err)
|
|
}
|
|
|
|
// We do not destroy the socket as we can continue using the session
|
|
// the stream get's destroyed and the session remains to create new streams
|
|
util.destroy(body, err)
|
|
client[kQueue][client[kRunningIdx]++] = null
|
|
client[kResume]()
|
|
}
|
|
|
|
try {
|
|
// We are already connected, streams are pending.
|
|
// We can call on connect, and wait for abort
|
|
request.onConnect(abort)
|
|
} catch (err) {
|
|
util.errorRequest(client, request, err)
|
|
}
|
|
|
|
if (request.aborted) {
|
|
return false
|
|
}
|
|
|
|
if (method === 'CONNECT') {
|
|
session.ref()
|
|
// We are already connected, streams are pending, first request
|
|
// will create a new stream. We trigger a request to create the stream and wait until
|
|
// `ready` event is triggered
|
|
// We disabled endStream to allow the user to write to the stream
|
|
stream = session.request(headers, { endStream: false, signal })
|
|
|
|
if (stream.id && !stream.pending) {
|
|
request.onUpgrade(null, null, stream)
|
|
++session[kOpenStreams]
|
|
client[kQueue][client[kRunningIdx]++] = null
|
|
} else {
|
|
stream.once('ready', () => {
|
|
request.onUpgrade(null, null, stream)
|
|
++session[kOpenStreams]
|
|
client[kQueue][client[kRunningIdx]++] = null
|
|
})
|
|
}
|
|
|
|
stream.once('close', () => {
|
|
session[kOpenStreams] -= 1
|
|
if (session[kOpenStreams] === 0) session.unref()
|
|
})
|
|
|
|
return true
|
|
}
|
|
|
|
// https://tools.ietf.org/html/rfc7540#section-8.3
|
|
// :path and :scheme headers must be omitted when sending CONNECT
|
|
|
|
headers[HTTP2_HEADER_PATH] = path
|
|
headers[HTTP2_HEADER_SCHEME] = 'https'
|
|
|
|
// https://tools.ietf.org/html/rfc7231#section-4.3.1
|
|
// https://tools.ietf.org/html/rfc7231#section-4.3.2
|
|
// https://tools.ietf.org/html/rfc7231#section-4.3.5
|
|
|
|
// Sending a payload body on a request that does not
|
|
// expect it can cause undefined behavior on some
|
|
// servers and corrupt connection state. Do not
|
|
// re-use the connection for further requests.
|
|
|
|
const expectsPayload = (
|
|
method === 'PUT' ||
|
|
method === 'POST' ||
|
|
method === 'PATCH'
|
|
)
|
|
|
|
if (body && typeof body.read === 'function') {
|
|
// Try to read EOF in order to get length.
|
|
body.read(0)
|
|
}
|
|
|
|
let contentLength = util.bodyLength(body)
|
|
|
|
if (util.isFormDataLike(body)) {
|
|
extractBody ??= (__nccwpck_require__(4492).extractBody)
|
|
|
|
const [bodyStream, contentType] = extractBody(body)
|
|
headers['content-type'] = contentType
|
|
|
|
body = bodyStream.stream
|
|
contentLength = bodyStream.length
|
|
}
|
|
|
|
if (contentLength == null) {
|
|
contentLength = request.contentLength
|
|
}
|
|
|
|
if (contentLength === 0 || !expectsPayload) {
|
|
// https://tools.ietf.org/html/rfc7230#section-3.3.2
|
|
// A user agent SHOULD NOT send a Content-Length header field when
|
|
// the request message does not contain a payload body and the method
|
|
// semantics do not anticipate such a body.
|
|
|
|
contentLength = null
|
|
}
|
|
|
|
// https://github.com/nodejs/undici/issues/2046
|
|
// A user agent may send a Content-Length header with 0 value, this should be allowed.
|
|
if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) {
|
|
if (client[kStrictContentLength]) {
|
|
util.errorRequest(client, request, new RequestContentLengthMismatchError())
|
|
return false
|
|
}
|
|
|
|
process.emitWarning(new RequestContentLengthMismatchError())
|
|
}
|
|
|
|
if (contentLength != null) {
|
|
assert(body, 'no body must not have content length')
|
|
headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`
|
|
}
|
|
|
|
session.ref()
|
|
|
|
const shouldEndStream = method === 'GET' || method === 'HEAD' || body === null
|
|
if (expectContinue) {
|
|
headers[HTTP2_HEADER_EXPECT] = '100-continue'
|
|
stream = session.request(headers, { endStream: shouldEndStream, signal })
|
|
|
|
stream.once('continue', writeBodyH2)
|
|
} else {
|
|
stream = session.request(headers, {
|
|
endStream: shouldEndStream,
|
|
signal
|
|
})
|
|
writeBodyH2()
|
|
}
|
|
|
|
// Increment counter as we have new streams open
|
|
++session[kOpenStreams]
|
|
|
|
stream.once('response', headers => {
|
|
const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers
|
|
request.onResponseStarted()
|
|
|
|
// Due to the stream nature, it is possible we face a race condition
|
|
// where the stream has been assigned, but the request has been aborted
|
|
// the request remains in-flight and headers hasn't been received yet
|
|
// for those scenarios, best effort is to destroy the stream immediately
|
|
// as there's no value to keep it open.
|
|
if (request.aborted) {
|
|
const err = new RequestAbortedError()
|
|
util.errorRequest(client, request, err)
|
|
util.destroy(stream, err)
|
|
return
|
|
}
|
|
|
|
if (request.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), '') === false) {
|
|
stream.pause()
|
|
}
|
|
|
|
stream.on('data', (chunk) => {
|
|
if (request.onData(chunk) === false) {
|
|
stream.pause()
|
|
}
|
|
})
|
|
})
|
|
|
|
stream.once('end', () => {
|
|
// When state is null, it means we haven't consumed body and the stream still do not have
|
|
// a state.
|
|
// Present specially when using pipeline or stream
|
|
if (stream.state?.state == null || stream.state.state < 6) {
|
|
request.onComplete([])
|
|
}
|
|
|
|
if (session[kOpenStreams] === 0) {
|
|
// Stream is closed or half-closed-remote (6), decrement counter and cleanup
|
|
// It does not have sense to continue working with the stream as we do not
|
|
// have yet RST_STREAM support on client-side
|
|
|
|
session.unref()
|
|
}
|
|
|
|
abort(new InformationalError('HTTP/2: stream half-closed (remote)'))
|
|
client[kQueue][client[kRunningIdx]++] = null
|
|
client[kPendingIdx] = client[kRunningIdx]
|
|
client[kResume]()
|
|
})
|
|
|
|
stream.once('close', () => {
|
|
session[kOpenStreams] -= 1
|
|
if (session[kOpenStreams] === 0) {
|
|
session.unref()
|
|
}
|
|
})
|
|
|
|
stream.once('error', function (err) {
|
|
abort(err)
|
|
})
|
|
|
|
stream.once('frameError', (type, code) => {
|
|
abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`))
|
|
})
|
|
|
|
// stream.on('aborted', () => {
|
|
// // TODO(HTTP/2): Support aborted
|
|
// })
|
|
|
|
// stream.on('timeout', () => {
|
|
// // TODO(HTTP/2): Support timeout
|
|
// })
|
|
|
|
// stream.on('push', headers => {
|
|
// // TODO(HTTP/2): Support push
|
|
// })
|
|
|
|
// stream.on('trailers', headers => {
|
|
// // TODO(HTTP/2): Support trailers
|
|
// })
|
|
|
|
return true
|
|
|
|
function writeBodyH2 () {
|
|
/* istanbul ignore else: assertion */
|
|
if (!body || contentLength === 0) {
|
|
writeBuffer(
|
|
abort,
|
|
stream,
|
|
null,
|
|
client,
|
|
request,
|
|
client[kSocket],
|
|
contentLength,
|
|
expectsPayload
|
|
)
|
|
} else if (util.isBuffer(body)) {
|
|
writeBuffer(
|
|
abort,
|
|
stream,
|
|
body,
|
|
client,
|
|
request,
|
|
client[kSocket],
|
|
contentLength,
|
|
expectsPayload
|
|
)
|
|
} else if (util.isBlobLike(body)) {
|
|
if (typeof body.stream === 'function') {
|
|
writeIterable(
|
|
abort,
|
|
stream,
|
|
body.stream(),
|
|
client,
|
|
request,
|
|
client[kSocket],
|
|
contentLength,
|
|
expectsPayload
|
|
)
|
|
} else {
|
|
writeBlob(
|
|
abort,
|
|
stream,
|
|
body,
|
|
client,
|
|
request,
|
|
client[kSocket],
|
|
contentLength,
|
|
expectsPayload
|
|
)
|
|
}
|
|
} else if (util.isStream(body)) {
|
|
writeStream(
|
|
abort,
|
|
client[kSocket],
|
|
expectsPayload,
|
|
stream,
|
|
body,
|
|
client,
|
|
request,
|
|
contentLength
|
|
)
|
|
} else if (util.isIterable(body)) {
|
|
writeIterable(
|
|
abort,
|
|
stream,
|
|
body,
|
|
client,
|
|
request,
|
|
client[kSocket],
|
|
contentLength,
|
|
expectsPayload
|
|
)
|
|
} else {
|
|
assert(false)
|
|
}
|
|
}
|
|
}
|
|
|
|
function writeBuffer (abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
|
|
try {
|
|
if (body != null && util.isBuffer(body)) {
|
|
assert(contentLength === body.byteLength, 'buffer body must have content length')
|
|
h2stream.cork()
|
|
h2stream.write(body)
|
|
h2stream.uncork()
|
|
h2stream.end()
|
|
|
|
request.onBodySent(body)
|
|
}
|
|
|
|
if (!expectsPayload) {
|
|
socket[kReset] = true
|
|
}
|
|
|
|
request.onRequestSent()
|
|
client[kResume]()
|
|
} catch (error) {
|
|
abort(error)
|
|
}
|
|
}
|
|
|
|
function writeStream (abort, socket, expectsPayload, h2stream, body, client, request, contentLength) {
|
|
assert(contentLength !== 0 || client[kRunning] === 0, 'stream body cannot be pipelined')
|
|
|
|
// For HTTP/2, is enough to pipe the stream
|
|
const pipe = pipeline(
|
|
body,
|
|
h2stream,
|
|
(err) => {
|
|
if (err) {
|
|
util.destroy(pipe, err)
|
|
abort(err)
|
|
} else {
|
|
util.removeAllListeners(pipe)
|
|
request.onRequestSent()
|
|
|
|
if (!expectsPayload) {
|
|
socket[kReset] = true
|
|
}
|
|
|
|
client[kResume]()
|
|
}
|
|
}
|
|
)
|
|
|
|
util.addListener(pipe, 'data', onPipeData)
|
|
|
|
function onPipeData (chunk) {
|
|
request.onBodySent(chunk)
|
|
}
|
|
}
|
|
|
|
async function writeBlob (abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
|
|
assert(contentLength === body.size, 'blob body must have content length')
|
|
|
|
try {
|
|
if (contentLength != null && contentLength !== body.size) {
|
|
throw new RequestContentLengthMismatchError()
|
|
}
|
|
|
|
const buffer = Buffer.from(await body.arrayBuffer())
|
|
|
|
h2stream.cork()
|
|
h2stream.write(buffer)
|
|
h2stream.uncork()
|
|
h2stream.end()
|
|
|
|
request.onBodySent(buffer)
|
|
request.onRequestSent()
|
|
|
|
if (!expectsPayload) {
|
|
socket[kReset] = true
|
|
}
|
|
|
|
client[kResume]()
|
|
} catch (err) {
|
|
abort(err)
|
|
}
|
|
}
|
|
|
|
async function writeIterable (abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
|
|
assert(contentLength !== 0 || client[kRunning] === 0, 'iterator body cannot be pipelined')
|
|
|
|
let callback = null
|
|
function onDrain () {
|
|
if (callback) {
|
|
const cb = callback
|
|
callback = null
|
|
cb()
|
|
}
|
|
}
|
|
|
|
const waitForDrain = () => new Promise((resolve, reject) => {
|
|
assert(callback === null)
|
|
|
|
if (socket[kError]) {
|
|
reject(socket[kError])
|
|
} else {
|
|
callback = resolve
|
|
}
|
|
})
|
|
|
|
h2stream
|
|
.on('close', onDrain)
|
|
.on('drain', onDrain)
|
|
|
|
try {
|
|
// It's up to the user to somehow abort the async iterable.
|
|
for await (const chunk of body) {
|
|
if (socket[kError]) {
|
|
throw socket[kError]
|
|
}
|
|
|
|
const res = h2stream.write(chunk)
|
|
request.onBodySent(chunk)
|
|
if (!res) {
|
|
await waitForDrain()
|
|
}
|
|
}
|
|
|
|
h2stream.end()
|
|
|
|
request.onRequestSent()
|
|
|
|
if (!expectsPayload) {
|
|
socket[kReset] = true
|
|
}
|
|
|
|
client[kResume]()
|
|
} catch (err) {
|
|
abort(err)
|
|
} finally {
|
|
h2stream
|
|
.off('close', onDrain)
|
|
.off('drain', onDrain)
|
|
}
|
|
}
|
|
|
|
module.exports = connectH2
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3701:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
// @ts-check
|
|
|
|
|
|
|
|
const assert = __nccwpck_require__(4589)
|
|
const net = __nccwpck_require__(7030)
|
|
const http = __nccwpck_require__(7067)
|
|
const util = __nccwpck_require__(3440)
|
|
const { channels } = __nccwpck_require__(2414)
|
|
const Request = __nccwpck_require__(4655)
|
|
const DispatcherBase = __nccwpck_require__(1841)
|
|
const {
|
|
InvalidArgumentError,
|
|
InformationalError,
|
|
ClientDestroyedError
|
|
} = __nccwpck_require__(8707)
|
|
const buildConnector = __nccwpck_require__(9136)
|
|
const {
|
|
kUrl,
|
|
kServerName,
|
|
kClient,
|
|
kBusy,
|
|
kConnect,
|
|
kResuming,
|
|
kRunning,
|
|
kPending,
|
|
kSize,
|
|
kQueue,
|
|
kConnected,
|
|
kConnecting,
|
|
kNeedDrain,
|
|
kKeepAliveDefaultTimeout,
|
|
kHostHeader,
|
|
kPendingIdx,
|
|
kRunningIdx,
|
|
kError,
|
|
kPipelining,
|
|
kKeepAliveTimeoutValue,
|
|
kMaxHeadersSize,
|
|
kKeepAliveMaxTimeout,
|
|
kKeepAliveTimeoutThreshold,
|
|
kHeadersTimeout,
|
|
kBodyTimeout,
|
|
kStrictContentLength,
|
|
kConnector,
|
|
kMaxRedirections,
|
|
kMaxRequests,
|
|
kCounter,
|
|
kClose,
|
|
kDestroy,
|
|
kDispatch,
|
|
kInterceptors,
|
|
kLocalAddress,
|
|
kMaxResponseSize,
|
|
kOnError,
|
|
kHTTPContext,
|
|
kMaxConcurrentStreams,
|
|
kResume
|
|
} = __nccwpck_require__(6443)
|
|
const connectH1 = __nccwpck_require__(637)
|
|
const connectH2 = __nccwpck_require__(8788)
|
|
let deprecatedInterceptorWarned = false
|
|
|
|
const kClosedResolve = Symbol('kClosedResolve')
|
|
|
|
const noop = () => {}
|
|
|
|
function getPipelining (client) {
|
|
return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1
|
|
}
|
|
|
|
/**
|
|
* @type {import('../../types/client.js').default}
|
|
*/
|
|
class Client extends DispatcherBase {
|
|
/**
|
|
*
|
|
* @param {string|URL} url
|
|
* @param {import('../../types/client.js').Client.Options} options
|
|
*/
|
|
constructor (url, {
|
|
interceptors,
|
|
maxHeaderSize,
|
|
headersTimeout,
|
|
socketTimeout,
|
|
requestTimeout,
|
|
connectTimeout,
|
|
bodyTimeout,
|
|
idleTimeout,
|
|
keepAlive,
|
|
keepAliveTimeout,
|
|
maxKeepAliveTimeout,
|
|
keepAliveMaxTimeout,
|
|
keepAliveTimeoutThreshold,
|
|
socketPath,
|
|
pipelining,
|
|
tls,
|
|
strictContentLength,
|
|
maxCachedSessions,
|
|
maxRedirections,
|
|
connect,
|
|
maxRequestsPerClient,
|
|
localAddress,
|
|
maxResponseSize,
|
|
autoSelectFamily,
|
|
autoSelectFamilyAttemptTimeout,
|
|
// h2
|
|
maxConcurrentStreams,
|
|
allowH2,
|
|
webSocket
|
|
} = {}) {
|
|
super({ webSocket })
|
|
|
|
if (keepAlive !== undefined) {
|
|
throw new InvalidArgumentError('unsupported keepAlive, use pipelining=0 instead')
|
|
}
|
|
|
|
if (socketTimeout !== undefined) {
|
|
throw new InvalidArgumentError('unsupported socketTimeout, use headersTimeout & bodyTimeout instead')
|
|
}
|
|
|
|
if (requestTimeout !== undefined) {
|
|
throw new InvalidArgumentError('unsupported requestTimeout, use headersTimeout & bodyTimeout instead')
|
|
}
|
|
|
|
if (idleTimeout !== undefined) {
|
|
throw new InvalidArgumentError('unsupported idleTimeout, use keepAliveTimeout instead')
|
|
}
|
|
|
|
if (maxKeepAliveTimeout !== undefined) {
|
|
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 (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
|
|
throw new InvalidArgumentError('connect must be a function or an object')
|
|
}
|
|
|
|
if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
|
|
throw new InvalidArgumentError('maxRedirections must be a positive number')
|
|
}
|
|
|
|
if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
|
|
throw new InvalidArgumentError('maxRequestsPerClient must be a positive number')
|
|
}
|
|
|
|
if (localAddress != null && (typeof localAddress !== 'string' || net.isIP(localAddress) === 0)) {
|
|
throw new InvalidArgumentError('localAddress must be valid string IP address')
|
|
}
|
|
|
|
if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) {
|
|
throw new InvalidArgumentError('maxResponseSize must be a positive number')
|
|
}
|
|
|
|
if (
|
|
autoSelectFamilyAttemptTimeout != null &&
|
|
(!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)
|
|
) {
|
|
throw new InvalidArgumentError('autoSelectFamilyAttemptTimeout must be a positive number')
|
|
}
|
|
|
|
// h2
|
|
if (allowH2 != null && typeof allowH2 !== 'boolean') {
|
|
throw new InvalidArgumentError('allowH2 must be a valid boolean value')
|
|
}
|
|
|
|
if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== 'number' || maxConcurrentStreams < 1)) {
|
|
throw new InvalidArgumentError('maxConcurrentStreams must be a positive integer, greater than 0')
|
|
}
|
|
|
|
if (typeof connect !== 'function') {
|
|
connect = buildConnector({
|
|
...tls,
|
|
maxCachedSessions,
|
|
allowH2,
|
|
socketPath,
|
|
timeout: connectTimeout,
|
|
...(autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
|
|
...connect
|
|
})
|
|
}
|
|
|
|
if (interceptors?.Client && Array.isArray(interceptors.Client)) {
|
|
this[kInterceptors] = interceptors.Client
|
|
if (!deprecatedInterceptorWarned) {
|
|
deprecatedInterceptorWarned = true
|
|
process.emitWarning('Client.Options#interceptor is deprecated. Use Dispatcher#compose instead.', {
|
|
code: 'UNDICI-CLIENT-INTERCEPTOR-DEPRECATED'
|
|
})
|
|
}
|
|
} else {
|
|
this[kInterceptors] = [createRedirectInterceptor({ maxRedirections })]
|
|
}
|
|
|
|
this[kUrl] = util.parseOrigin(url)
|
|
this[kConnector] = connect
|
|
this[kPipelining] = pipelining != null ? pipelining : 1
|
|
this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize
|
|
this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout
|
|
this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 600e3 : keepAliveMaxTimeout
|
|
this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 2e3 : keepAliveTimeoutThreshold
|
|
this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout]
|
|
this[kServerName] = null
|
|
this[kLocalAddress] = localAddress != null ? localAddress : null
|
|
this[kResuming] = 0 // 0, idle, 1, scheduled, 2 resuming
|
|
this[kNeedDrain] = 0 // 0, idle, 1, scheduled, 2 resuming
|
|
this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ''}\r\n`
|
|
this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 300e3
|
|
this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 300e3
|
|
this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength
|
|
this[kMaxRedirections] = maxRedirections
|
|
this[kMaxRequests] = maxRequestsPerClient
|
|
this[kClosedResolve] = null
|
|
this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1
|
|
this[kMaxConcurrentStreams] = maxConcurrentStreams != null ? maxConcurrentStreams : 100 // Max peerConcurrentStreams for a Node h2 server
|
|
this[kHTTPContext] = null
|
|
|
|
// kQueue is built up of 3 sections separated by
|
|
// the kRunningIdx and kPendingIdx indices.
|
|
// | complete | running | pending |
|
|
// ^ kRunningIdx ^ kPendingIdx ^ kQueue.length
|
|
// kRunningIdx points to the first running element.
|
|
// kPendingIdx points to the first pending element.
|
|
// This implements a fast queue with an amortized
|
|
// time of O(1).
|
|
|
|
this[kQueue] = []
|
|
this[kRunningIdx] = 0
|
|
this[kPendingIdx] = 0
|
|
|
|
this[kResume] = (sync) => resume(this, sync)
|
|
this[kOnError] = (err) => onError(this, err)
|
|
}
|
|
|
|
get pipelining () {
|
|
return this[kPipelining]
|
|
}
|
|
|
|
set pipelining (value) {
|
|
this[kPipelining] = value
|
|
this[kResume](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[kHTTPContext] && !this[kConnecting] && !this[kHTTPContext].destroyed
|
|
}
|
|
|
|
get [kBusy] () {
|
|
return Boolean(
|
|
this[kHTTPContext]?.busy(null) ||
|
|
(this[kSize] >= (getPipelining(this) || 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]) {
|
|
// Do nothing.
|
|
} else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) {
|
|
// Wait a tick in case stream/iterator is ended in the same tick.
|
|
this[kResuming] = 1
|
|
queueMicrotask(() => resume(this))
|
|
} else {
|
|
this[kResume](true)
|
|
}
|
|
|
|
if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) {
|
|
this[kNeedDrain] = 2
|
|
}
|
|
|
|
return this[kNeedDrain] < 2
|
|
}
|
|
|
|
async [kClose] () {
|
|
// TODO: for H2 we need to gracefully flush the remaining enqueued
|
|
// request and close each stream.
|
|
return new Promise((resolve) => {
|
|
if (this[kSize]) {
|
|
this[kClosedResolve] = resolve
|
|
} else {
|
|
resolve(null)
|
|
}
|
|
})
|
|
}
|
|
|
|
async [kDestroy] (err) {
|
|
return new Promise((resolve) => {
|
|
const requests = this[kQueue].splice(this[kPendingIdx])
|
|
for (let i = 0; i < requests.length; i++) {
|
|
const request = requests[i]
|
|
util.errorRequest(this, request, err)
|
|
}
|
|
|
|
const callback = () => {
|
|
if (this[kClosedResolve]) {
|
|
// TODO (fix): Should we error here with ClientDestroyedError?
|
|
this[kClosedResolve]()
|
|
this[kClosedResolve] = null
|
|
}
|
|
resolve(null)
|
|
}
|
|
|
|
if (this[kHTTPContext]) {
|
|
this[kHTTPContext].destroy(err, callback)
|
|
this[kHTTPContext] = null
|
|
} else {
|
|
queueMicrotask(callback)
|
|
}
|
|
|
|
this[kResume]()
|
|
})
|
|
}
|
|
}
|
|
|
|
const createRedirectInterceptor = __nccwpck_require__(5092)
|
|
|
|
function onError (client, err) {
|
|
if (
|
|
client[kRunning] === 0 &&
|
|
err.code !== 'UND_ERR_INFO' &&
|
|
err.code !== 'UND_ERR_SOCKET'
|
|
) {
|
|
// Error is not caused by running request and not a recoverable
|
|
// socket error.
|
|
|
|
assert(client[kPendingIdx] === client[kRunningIdx])
|
|
|
|
const requests = client[kQueue].splice(client[kRunningIdx])
|
|
|
|
for (let i = 0; i < requests.length; i++) {
|
|
const request = requests[i]
|
|
util.errorRequest(client, request, err)
|
|
}
|
|
assert(client[kSize] === 0)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Client} client
|
|
* @returns
|
|
*/
|
|
async function connect (client) {
|
|
assert(!client[kConnecting])
|
|
assert(!client[kHTTPContext])
|
|
|
|
let { host, hostname, protocol, port } = client[kUrl]
|
|
|
|
// Resolve ipv6
|
|
if (hostname[0] === '[') {
|
|
const idx = hostname.indexOf(']')
|
|
|
|
assert(idx !== -1)
|
|
const ip = hostname.substring(1, idx)
|
|
|
|
assert(net.isIP(ip))
|
|
hostname = ip
|
|
}
|
|
|
|
client[kConnecting] = true
|
|
|
|
if (channels.beforeConnect.hasSubscribers) {
|
|
channels.beforeConnect.publish({
|
|
connectParams: {
|
|
host,
|
|
hostname,
|
|
protocol,
|
|
port,
|
|
version: client[kHTTPContext]?.version,
|
|
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, socket) => {
|
|
if (err) {
|
|
reject(err)
|
|
} else {
|
|
resolve(socket)
|
|
}
|
|
})
|
|
})
|
|
|
|
if (client.destroyed) {
|
|
util.destroy(socket.on('error', noop), new ClientDestroyedError())
|
|
return
|
|
}
|
|
|
|
assert(socket)
|
|
|
|
try {
|
|
client[kHTTPContext] = socket.alpnProtocol === 'h2'
|
|
? await connectH2(client, socket)
|
|
: await connectH1(client, socket)
|
|
} catch (err) {
|
|
socket.destroy().on('error', noop)
|
|
throw err
|
|
}
|
|
|
|
client[kConnecting] = false
|
|
|
|
socket[kCounter] = 0
|
|
socket[kMaxRequests] = client[kMaxRequests]
|
|
socket[kClient] = client
|
|
socket[kError] = null
|
|
|
|
if (channels.connected.hasSubscribers) {
|
|
channels.connected.publish({
|
|
connectParams: {
|
|
host,
|
|
hostname,
|
|
protocol,
|
|
port,
|
|
version: client[kHTTPContext]?.version,
|
|
servername: client[kServerName],
|
|
localAddress: client[kLocalAddress]
|
|
},
|
|
connector: client[kConnector],
|
|
socket
|
|
})
|
|
}
|
|
client.emit('connect', client[kUrl], [client])
|
|
} catch (err) {
|
|
if (client.destroyed) {
|
|
return
|
|
}
|
|
|
|
client[kConnecting] = false
|
|
|
|
if (channels.connectError.hasSubscribers) {
|
|
channels.connectError.publish({
|
|
connectParams: {
|
|
host,
|
|
hostname,
|
|
protocol,
|
|
port,
|
|
version: client[kHTTPContext]?.version,
|
|
servername: client[kServerName],
|
|
localAddress: client[kLocalAddress]
|
|
},
|
|
connector: client[kConnector],
|
|
error: err
|
|
})
|
|
}
|
|
|
|
if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
|
|
assert(client[kRunning] === 0)
|
|
while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
|
|
const request = client[kQueue][client[kPendingIdx]++]
|
|
util.errorRequest(client, request, err)
|
|
}
|
|
} else {
|
|
onError(client, err)
|
|
}
|
|
|
|
client.emit('connectionError', client[kUrl], [client], err)
|
|
}
|
|
|
|
client[kResume]()
|
|
}
|
|
|
|
function emitDrain (client) {
|
|
client[kNeedDrain] = 0
|
|
client.emit('drain', client[kUrl], [client])
|
|
}
|
|
|
|
function resume (client, sync) {
|
|
if (client[kResuming] === 2) {
|
|
return
|
|
}
|
|
|
|
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[kClosedResolve] && !client[kSize]) {
|
|
client[kClosedResolve]()
|
|
client[kClosedResolve] = null
|
|
return
|
|
}
|
|
|
|
if (client[kHTTPContext]) {
|
|
client[kHTTPContext].resume()
|
|
}
|
|
|
|
if (client[kBusy]) {
|
|
client[kNeedDrain] = 2
|
|
} else if (client[kNeedDrain] === 2) {
|
|
if (sync) {
|
|
client[kNeedDrain] = 1
|
|
queueMicrotask(() => emitDrain(client))
|
|
} else {
|
|
emitDrain(client)
|
|
}
|
|
continue
|
|
}
|
|
|
|
if (client[kPending] === 0) {
|
|
return
|
|
}
|
|
|
|
if (client[kRunning] >= (getPipelining(client) || 1)) {
|
|
return
|
|
}
|
|
|
|
const request = client[kQueue][client[kPendingIdx]]
|
|
|
|
if (client[kUrl].protocol === 'https:' && client[kServerName] !== request.servername) {
|
|
if (client[kRunning] > 0) {
|
|
return
|
|
}
|
|
|
|
client[kServerName] = request.servername
|
|
client[kHTTPContext]?.destroy(new InformationalError('servername changed'), () => {
|
|
client[kHTTPContext] = null
|
|
resume(client)
|
|
})
|
|
}
|
|
|
|
if (client[kConnecting]) {
|
|
return
|
|
}
|
|
|
|
if (!client[kHTTPContext]) {
|
|
connect(client)
|
|
return
|
|
}
|
|
|
|
if (client[kHTTPContext].destroyed) {
|
|
return
|
|
}
|
|
|
|
if (client[kHTTPContext].busy(request)) {
|
|
return
|
|
}
|
|
|
|
if (!request.aborted && client[kHTTPContext].write(request)) {
|
|
client[kPendingIdx]++
|
|
} else {
|
|
client[kQueue].splice(client[kPendingIdx], 1)
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = Client
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1841:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const Dispatcher = __nccwpck_require__(883)
|
|
const {
|
|
ClientDestroyedError,
|
|
ClientClosedError,
|
|
InvalidArgumentError
|
|
} = __nccwpck_require__(8707)
|
|
const { kDestroy, kClose, kClosed, kDestroyed, kDispatch, kInterceptors } = __nccwpck_require__(6443)
|
|
|
|
const kOnDestroyed = Symbol('onDestroyed')
|
|
const kOnClosed = Symbol('onClosed')
|
|
const kInterceptedDispatch = Symbol('Intercepted Dispatch')
|
|
const kWebSocketOptions = Symbol('webSocketOptions')
|
|
|
|
class DispatcherBase extends Dispatcher {
|
|
constructor (opts) {
|
|
super()
|
|
|
|
this[kDestroyed] = false
|
|
this[kOnDestroyed] = null
|
|
this[kClosed] = false
|
|
this[kOnClosed] = []
|
|
this[kWebSocketOptions] = opts?.webSocket ?? {}
|
|
}
|
|
|
|
get webSocketOptions () {
|
|
return {
|
|
maxFragments: this[kWebSocketOptions].maxFragments ?? 131072,
|
|
maxPayloadSize: this[kWebSocketOptions].maxPayloadSize ?? 128 * 1024 * 1024
|
|
}
|
|
}
|
|
|
|
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 === undefined) {
|
|
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)
|
|
}
|
|
}
|
|
|
|
// Should not error.
|
|
this[kClose]()
|
|
.then(() => this.destroy())
|
|
.then(() => {
|
|
queueMicrotask(onClosed)
|
|
})
|
|
}
|
|
|
|
destroy (err, callback) {
|
|
if (typeof err === 'function') {
|
|
callback = err
|
|
err = null
|
|
}
|
|
|
|
if (callback === undefined) {
|
|
return new Promise((resolve, reject) => {
|
|
this.destroy(err, (err, data) => {
|
|
return err ? /* istanbul ignore next: should never error */ reject(err) : resolve(data)
|
|
})
|
|
})
|
|
}
|
|
|
|
if (typeof callback !== 'function') {
|
|
throw new InvalidArgumentError('invalid callback')
|
|
}
|
|
|
|
if (this[kDestroyed]) {
|
|
if (this[kOnDestroyed]) {
|
|
this[kOnDestroyed].push(callback)
|
|
} else {
|
|
queueMicrotask(() => callback(null, null))
|
|
}
|
|
return
|
|
}
|
|
|
|
if (!err) {
|
|
err = new ClientDestroyedError()
|
|
}
|
|
|
|
this[kDestroyed] = true
|
|
this[kOnDestroyed] = this[kOnDestroyed] || []
|
|
this[kOnDestroyed].push(callback)
|
|
|
|
const onDestroyed = () => {
|
|
const callbacks = this[kOnDestroyed]
|
|
this[kOnDestroyed] = null
|
|
for (let i = 0; i < callbacks.length; i++) {
|
|
callbacks[i](null, null)
|
|
}
|
|
}
|
|
|
|
// Should not error.
|
|
this[kDestroy](err).then(() => {
|
|
queueMicrotask(onDestroyed)
|
|
})
|
|
}
|
|
|
|
[kInterceptedDispatch] (opts, handler) {
|
|
if (!this[kInterceptors] || this[kInterceptors].length === 0) {
|
|
this[kInterceptedDispatch] = this[kDispatch]
|
|
return this[kDispatch](opts, handler)
|
|
}
|
|
|
|
let dispatch = this[kDispatch].bind(this)
|
|
for (let i = this[kInterceptors].length - 1; i >= 0; i--) {
|
|
dispatch = this[kInterceptors][i](dispatch)
|
|
}
|
|
this[kInterceptedDispatch] = dispatch
|
|
return dispatch(opts, handler)
|
|
}
|
|
|
|
dispatch (opts, handler) {
|
|
if (!handler || typeof handler !== 'object') {
|
|
throw new InvalidArgumentError('handler must be an object')
|
|
}
|
|
|
|
try {
|
|
if (!opts || typeof opts !== 'object') {
|
|
throw new InvalidArgumentError('opts must be an object.')
|
|
}
|
|
|
|
if (this[kDestroyed] || this[kOnDestroyed]) {
|
|
throw new ClientDestroyedError()
|
|
}
|
|
|
|
if (this[kClosed]) {
|
|
throw new ClientClosedError()
|
|
}
|
|
|
|
return this[kInterceptedDispatch](opts, handler)
|
|
} catch (err) {
|
|
if (typeof handler.onError !== 'function') {
|
|
throw new InvalidArgumentError('invalid onError method')
|
|
}
|
|
|
|
handler.onError(err)
|
|
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = DispatcherBase
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 883:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
const EventEmitter = __nccwpck_require__(8474)
|
|
|
|
class Dispatcher extends EventEmitter {
|
|
dispatch () {
|
|
throw new Error('not implemented')
|
|
}
|
|
|
|
close () {
|
|
throw new Error('not implemented')
|
|
}
|
|
|
|
destroy () {
|
|
throw new Error('not implemented')
|
|
}
|
|
|
|
compose (...args) {
|
|
// So we handle [interceptor1, interceptor2] or interceptor1, interceptor2, ...
|
|
const interceptors = Array.isArray(args[0]) ? args[0] : args
|
|
let dispatch = this.dispatch.bind(this)
|
|
|
|
for (const interceptor of interceptors) {
|
|
if (interceptor == null) {
|
|
continue
|
|
}
|
|
|
|
if (typeof interceptor !== 'function') {
|
|
throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`)
|
|
}
|
|
|
|
dispatch = interceptor(dispatch)
|
|
|
|
if (dispatch == null || typeof dispatch !== 'function' || dispatch.length !== 2) {
|
|
throw new TypeError('invalid interceptor')
|
|
}
|
|
}
|
|
|
|
return new ComposedDispatcher(this, dispatch)
|
|
}
|
|
}
|
|
|
|
class ComposedDispatcher extends Dispatcher {
|
|
#dispatcher = null
|
|
#dispatch = null
|
|
|
|
constructor (dispatcher, dispatch) {
|
|
super()
|
|
this.#dispatcher = dispatcher
|
|
this.#dispatch = dispatch
|
|
}
|
|
|
|
dispatch (...args) {
|
|
this.#dispatch(...args)
|
|
}
|
|
|
|
close (...args) {
|
|
return this.#dispatcher.close(...args)
|
|
}
|
|
|
|
destroy (...args) {
|
|
return this.#dispatcher.destroy(...args)
|
|
}
|
|
}
|
|
|
|
module.exports = Dispatcher
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3137:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const DispatcherBase = __nccwpck_require__(1841)
|
|
const { kClose, kDestroy, kClosed, kDestroyed, kDispatch, kNoProxyAgent, kHttpProxyAgent, kHttpsProxyAgent } = __nccwpck_require__(6443)
|
|
const ProxyAgent = __nccwpck_require__(6672)
|
|
const Agent = __nccwpck_require__(7405)
|
|
|
|
const DEFAULT_PORTS = {
|
|
'http:': 80,
|
|
'https:': 443
|
|
}
|
|
|
|
let experimentalWarned = false
|
|
|
|
class EnvHttpProxyAgent extends DispatcherBase {
|
|
#noProxyValue = null
|
|
#noProxyEntries = null
|
|
#opts = null
|
|
|
|
constructor (opts = {}) {
|
|
super()
|
|
this.#opts = opts
|
|
|
|
if (!experimentalWarned) {
|
|
experimentalWarned = true
|
|
process.emitWarning('EnvHttpProxyAgent is experimental, expect them to change at any time.', {
|
|
code: 'UNDICI-EHPA'
|
|
})
|
|
}
|
|
|
|
const { httpProxy, httpsProxy, noProxy, ...agentOpts } = opts
|
|
|
|
this[kNoProxyAgent] = new Agent(agentOpts)
|
|
|
|
const HTTP_PROXY = httpProxy ?? process.env.http_proxy ?? process.env.HTTP_PROXY
|
|
if (HTTP_PROXY) {
|
|
this[kHttpProxyAgent] = new ProxyAgent({ ...agentOpts, uri: HTTP_PROXY })
|
|
} else {
|
|
this[kHttpProxyAgent] = this[kNoProxyAgent]
|
|
}
|
|
|
|
const HTTPS_PROXY = httpsProxy ?? process.env.https_proxy ?? process.env.HTTPS_PROXY
|
|
if (HTTPS_PROXY) {
|
|
this[kHttpsProxyAgent] = new ProxyAgent({ ...agentOpts, uri: HTTPS_PROXY })
|
|
} else {
|
|
this[kHttpsProxyAgent] = this[kHttpProxyAgent]
|
|
}
|
|
|
|
this.#parseNoProxy()
|
|
}
|
|
|
|
[kDispatch] (opts, handler) {
|
|
const url = new URL(opts.origin)
|
|
const agent = this.#getProxyAgentForUrl(url)
|
|
return agent.dispatch(opts, handler)
|
|
}
|
|
|
|
async [kClose] () {
|
|
await this[kNoProxyAgent].close()
|
|
if (!this[kHttpProxyAgent][kClosed]) {
|
|
await this[kHttpProxyAgent].close()
|
|
}
|
|
if (!this[kHttpsProxyAgent][kClosed]) {
|
|
await this[kHttpsProxyAgent].close()
|
|
}
|
|
}
|
|
|
|
async [kDestroy] (err) {
|
|
await this[kNoProxyAgent].destroy(err)
|
|
if (!this[kHttpProxyAgent][kDestroyed]) {
|
|
await this[kHttpProxyAgent].destroy(err)
|
|
}
|
|
if (!this[kHttpsProxyAgent][kDestroyed]) {
|
|
await this[kHttpsProxyAgent].destroy(err)
|
|
}
|
|
}
|
|
|
|
#getProxyAgentForUrl (url) {
|
|
let { protocol, host: hostname, port } = url
|
|
|
|
// Stripping ports in this way instead of using parsedUrl.hostname to make
|
|
// sure that the brackets around IPv6 addresses are kept.
|
|
hostname = hostname.replace(/:\d*$/, '').toLowerCase()
|
|
port = Number.parseInt(port, 10) || DEFAULT_PORTS[protocol] || 0
|
|
if (!this.#shouldProxy(hostname, port)) {
|
|
return this[kNoProxyAgent]
|
|
}
|
|
if (protocol === 'https:') {
|
|
return this[kHttpsProxyAgent]
|
|
}
|
|
return this[kHttpProxyAgent]
|
|
}
|
|
|
|
#shouldProxy (hostname, port) {
|
|
if (this.#noProxyChanged) {
|
|
this.#parseNoProxy()
|
|
}
|
|
|
|
if (this.#noProxyEntries.length === 0) {
|
|
return true // Always proxy if NO_PROXY is not set or empty.
|
|
}
|
|
if (this.#noProxyValue === '*') {
|
|
return false // Never proxy if wildcard is set.
|
|
}
|
|
|
|
for (let i = 0; i < this.#noProxyEntries.length; i++) {
|
|
const entry = this.#noProxyEntries[i]
|
|
if (entry.port && entry.port !== port) {
|
|
continue // Skip if ports don't match.
|
|
}
|
|
if (!/^[.*]/.test(entry.hostname)) {
|
|
// No wildcards, so don't proxy only if there is not an exact match.
|
|
if (hostname === entry.hostname) {
|
|
return false
|
|
}
|
|
} else {
|
|
// Don't proxy if the hostname ends with the no_proxy host.
|
|
if (hostname.endsWith(entry.hostname.replace(/^\*/, ''))) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
#parseNoProxy () {
|
|
const noProxyValue = this.#opts.noProxy ?? this.#noProxyEnv
|
|
const noProxySplit = noProxyValue.split(/[,\s]/)
|
|
const noProxyEntries = []
|
|
|
|
for (let i = 0; i < noProxySplit.length; i++) {
|
|
const entry = noProxySplit[i]
|
|
if (!entry) {
|
|
continue
|
|
}
|
|
const parsed = entry.match(/^(.+):(\d+)$/)
|
|
noProxyEntries.push({
|
|
hostname: (parsed ? parsed[1] : entry).toLowerCase(),
|
|
port: parsed ? Number.parseInt(parsed[2], 10) : 0
|
|
})
|
|
}
|
|
|
|
this.#noProxyValue = noProxyValue
|
|
this.#noProxyEntries = noProxyEntries
|
|
}
|
|
|
|
get #noProxyChanged () {
|
|
if (this.#opts.noProxy !== undefined) {
|
|
return false
|
|
}
|
|
return this.#noProxyValue !== this.#noProxyEnv
|
|
}
|
|
|
|
get #noProxyEnv () {
|
|
return process.env.no_proxy ?? process.env.NO_PROXY ?? ''
|
|
}
|
|
}
|
|
|
|
module.exports = EnvHttpProxyAgent
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4660:
|
|
/***/ ((module) => {
|
|
|
|
/* eslint-disable */
|
|
|
|
|
|
|
|
// Extracted from node/lib/internal/fixed_queue.js
|
|
|
|
// Currently optimal queue size, tested on V8 6.0 - 6.6. Must be power of two.
|
|
const kSize = 2048;
|
|
const kMask = kSize - 1;
|
|
|
|
// The FixedQueue is implemented as a singly-linked list of fixed-size
|
|
// circular buffers. It looks something like this:
|
|
//
|
|
// head tail
|
|
// | |
|
|
// v v
|
|
// +-----------+ <-----\ +-----------+ <------\ +-----------+
|
|
// | [null] | \----- | next | \------- | next |
|
|
// +-----------+ +-----------+ +-----------+
|
|
// | item | <-- bottom | item | <-- bottom | [empty] |
|
|
// | item | | item | | [empty] |
|
|
// | item | | item | | [empty] |
|
|
// | item | | item | | [empty] |
|
|
// | item | | item | bottom --> | item |
|
|
// | item | | item | | item |
|
|
// | ... | | ... | | ... |
|
|
// | item | | item | | item |
|
|
// | item | | item | | item |
|
|
// | [empty] | <-- top | item | | item |
|
|
// | [empty] | | item | | item |
|
|
// | [empty] | | [empty] | <-- top top --> | [empty] |
|
|
// +-----------+ +-----------+ +-----------+
|
|
//
|
|
// Or, if there is only one circular buffer, it looks something
|
|
// like either of these:
|
|
//
|
|
// head tail head tail
|
|
// | | | |
|
|
// v v v v
|
|
// +-----------+ +-----------+
|
|
// | [null] | | [null] |
|
|
// +-----------+ +-----------+
|
|
// | [empty] | | item |
|
|
// | [empty] | | item |
|
|
// | item | <-- bottom top --> | [empty] |
|
|
// | item | | [empty] |
|
|
// | [empty] | <-- top bottom --> | item |
|
|
// | [empty] | | item |
|
|
// +-----------+ +-----------+
|
|
//
|
|
// Adding a value means moving `top` forward by one, removing means
|
|
// moving `bottom` forward by one. After reaching the end, the queue
|
|
// wraps around.
|
|
//
|
|
// When `top === bottom` the current queue is empty and when
|
|
// `top + 1 === bottom` it's full. This wastes a single space of storage
|
|
// but allows much quicker checks.
|
|
|
|
class FixedCircularBuffer {
|
|
constructor() {
|
|
this.bottom = 0;
|
|
this.top = 0;
|
|
this.list = new Array(kSize);
|
|
this.next = null;
|
|
}
|
|
|
|
isEmpty() {
|
|
return this.top === this.bottom;
|
|
}
|
|
|
|
isFull() {
|
|
return ((this.top + 1) & kMask) === this.bottom;
|
|
}
|
|
|
|
push(data) {
|
|
this.list[this.top] = data;
|
|
this.top = (this.top + 1) & kMask;
|
|
}
|
|
|
|
shift() {
|
|
const nextItem = this.list[this.bottom];
|
|
if (nextItem === undefined)
|
|
return null;
|
|
this.list[this.bottom] = undefined;
|
|
this.bottom = (this.bottom + 1) & kMask;
|
|
return nextItem;
|
|
}
|
|
}
|
|
|
|
module.exports = class FixedQueue {
|
|
constructor() {
|
|
this.head = this.tail = new FixedCircularBuffer();
|
|
}
|
|
|
|
isEmpty() {
|
|
return this.head.isEmpty();
|
|
}
|
|
|
|
push(data) {
|
|
if (this.head.isFull()) {
|
|
// Head is full: Creates a new queue, sets the old queue's `.next` to it,
|
|
// and sets it as the new main queue.
|
|
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) {
|
|
// If there is another queue, it forms the new tail.
|
|
this.tail = tail.next;
|
|
}
|
|
return next;
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2128:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const DispatcherBase = __nccwpck_require__(1841)
|
|
const FixedQueue = __nccwpck_require__(4660)
|
|
const { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = __nccwpck_require__(6443)
|
|
const PoolStats = __nccwpck_require__(3246)
|
|
|
|
const kClients = Symbol('clients')
|
|
const kNeedDrain = Symbol('needDrain')
|
|
const kQueue = Symbol('queue')
|
|
const kClosedResolve = Symbol('closed resolve')
|
|
const kOnDrain = Symbol('onDrain')
|
|
const kOnConnect = Symbol('onConnect')
|
|
const kOnDisconnect = Symbol('onDisconnect')
|
|
const kOnConnectionError = Symbol('onConnectionError')
|
|
const kGetDispatcher = Symbol('get dispatcher')
|
|
const kAddClient = Symbol('add client')
|
|
const kRemoveClient = Symbol('remove client')
|
|
const kStats = Symbol('stats')
|
|
|
|
class PoolBase extends DispatcherBase {
|
|
constructor (opts) {
|
|
super(opts)
|
|
|
|
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()) {
|
|
await Promise.all(this[kClients].map(c => c.close()))
|
|
} else {
|
|
await new Promise((resolve) => {
|
|
this[kClosedResolve] = resolve
|
|
})
|
|
}
|
|
}
|
|
|
|
async [kDestroy] (err) {
|
|
while (true) {
|
|
const item = this[kQueue].shift()
|
|
if (!item) {
|
|
break
|
|
}
|
|
item.handler.onError(err)
|
|
}
|
|
|
|
await 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]) {
|
|
queueMicrotask(() => {
|
|
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
|
|
))
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
PoolBase,
|
|
kClients,
|
|
kNeedDrain,
|
|
kAddClient,
|
|
kRemoveClient,
|
|
kGetDispatcher
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3246:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
const { kFree, kConnected, kPending, kQueued, kRunning, kSize } = __nccwpck_require__(6443)
|
|
const kPool = Symbol('pool')
|
|
|
|
class PoolStats {
|
|
constructor (pool) {
|
|
this[kPool] = pool
|
|
}
|
|
|
|
get connected () {
|
|
return this[kPool][kConnected]
|
|
}
|
|
|
|
get free () {
|
|
return this[kPool][kFree]
|
|
}
|
|
|
|
get pending () {
|
|
return this[kPool][kPending]
|
|
}
|
|
|
|
get queued () {
|
|
return this[kPool][kQueued]
|
|
}
|
|
|
|
get running () {
|
|
return this[kPool][kRunning]
|
|
}
|
|
|
|
get size () {
|
|
return this[kPool][kSize]
|
|
}
|
|
}
|
|
|
|
module.exports = PoolStats
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 628:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const {
|
|
PoolBase,
|
|
kClients,
|
|
kNeedDrain,
|
|
kAddClient,
|
|
kGetDispatcher
|
|
} = __nccwpck_require__(2128)
|
|
const Client = __nccwpck_require__(3701)
|
|
const {
|
|
InvalidArgumentError
|
|
} = __nccwpck_require__(8707)
|
|
const util = __nccwpck_require__(3440)
|
|
const { kUrl, kInterceptors } = __nccwpck_require__(6443)
|
|
const buildConnector = __nccwpck_require__(9136)
|
|
|
|
const kOptions = Symbol('options')
|
|
const kConnections = Symbol('connections')
|
|
const kFactory = Symbol('factory')
|
|
|
|
function defaultFactory (origin, opts) {
|
|
return new Client(origin, opts)
|
|
}
|
|
|
|
class Pool extends PoolBase {
|
|
constructor (origin, {
|
|
connections,
|
|
factory = defaultFactory,
|
|
connect,
|
|
connectTimeout,
|
|
tls,
|
|
maxCachedSessions,
|
|
socketPath,
|
|
autoSelectFamily,
|
|
autoSelectFamilyAttemptTimeout,
|
|
allowH2,
|
|
...options
|
|
} = {}) {
|
|
if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
|
|
throw new InvalidArgumentError('invalid connections')
|
|
}
|
|
|
|
if (typeof factory !== 'function') {
|
|
throw new InvalidArgumentError('factory must be a function.')
|
|
}
|
|
|
|
if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
|
|
throw new InvalidArgumentError('connect must be a function or an object')
|
|
}
|
|
|
|
if (typeof connect !== 'function') {
|
|
connect = buildConnector({
|
|
...tls,
|
|
maxCachedSessions,
|
|
allowH2,
|
|
socketPath,
|
|
timeout: connectTimeout,
|
|
...(autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
|
|
...connect
|
|
})
|
|
}
|
|
|
|
super(options)
|
|
|
|
this[kInterceptors] = options.interceptors?.Pool && Array.isArray(options.interceptors.Pool)
|
|
? options.interceptors.Pool
|
|
: []
|
|
this[kConnections] = connections || null
|
|
this[kUrl] = util.parseOrigin(origin)
|
|
this[kOptions] = { ...util.deepClone(options), connect, allowH2 }
|
|
this[kOptions].interceptors = options.interceptors
|
|
? { ...options.interceptors }
|
|
: undefined
|
|
this[kFactory] = factory
|
|
|
|
this.on('connectionError', (origin, targets, error) => {
|
|
// If a connection error occurs, we remove the client from the pool,
|
|
// and emit a connectionError event. They will not be re-used.
|
|
// Fixes https://github.com/nodejs/undici/issues/3895
|
|
for (const target of targets) {
|
|
// Do not use kRemoveClient here, as it will close the client,
|
|
// but the client cannot be closed in this state.
|
|
const idx = this[kClients].indexOf(target)
|
|
if (idx !== -1) {
|
|
this[kClients].splice(idx, 1)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
[kGetDispatcher] () {
|
|
for (const client of this[kClients]) {
|
|
if (!client[kNeedDrain]) {
|
|
return client
|
|
}
|
|
}
|
|
|
|
if (!this[kConnections] || this[kClients].length < this[kConnections]) {
|
|
const dispatcher = this[kFactory](this[kUrl], this[kOptions])
|
|
this[kAddClient](dispatcher)
|
|
return dispatcher
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = Pool
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6672:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { kProxy, kClose, kDestroy, kDispatch, kInterceptors } = __nccwpck_require__(6443)
|
|
const { URL } = __nccwpck_require__(3136)
|
|
const Agent = __nccwpck_require__(7405)
|
|
const Pool = __nccwpck_require__(628)
|
|
const DispatcherBase = __nccwpck_require__(1841)
|
|
const { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = __nccwpck_require__(8707)
|
|
const buildConnector = __nccwpck_require__(9136)
|
|
const Client = __nccwpck_require__(3701)
|
|
|
|
const kAgent = Symbol('proxy agent')
|
|
const kClient = Symbol('proxy client')
|
|
const kProxyHeaders = Symbol('proxy headers')
|
|
const kRequestTls = Symbol('request tls settings')
|
|
const kProxyTls = Symbol('proxy tls settings')
|
|
const kConnectEndpoint = Symbol('connect endpoint function')
|
|
const kTunnelProxy = Symbol('tunnel proxy')
|
|
|
|
function defaultProtocolPort (protocol) {
|
|
return protocol === 'https:' ? 443 : 80
|
|
}
|
|
|
|
function defaultFactory (origin, opts) {
|
|
return new Pool(origin, opts)
|
|
}
|
|
|
|
const noop = () => {}
|
|
|
|
function defaultAgentFactory (origin, opts) {
|
|
if (opts.connections === 1) {
|
|
return new Client(origin, opts)
|
|
}
|
|
return new Pool(origin, opts)
|
|
}
|
|
|
|
class Http1ProxyWrapper extends DispatcherBase {
|
|
#client
|
|
|
|
constructor (proxyUrl, { headers = {}, connect, factory }) {
|
|
super()
|
|
if (!proxyUrl) {
|
|
throw new InvalidArgumentError('Proxy URL is mandatory')
|
|
}
|
|
|
|
this[kProxyHeaders] = headers
|
|
if (factory) {
|
|
this.#client = factory(proxyUrl, { connect })
|
|
} else {
|
|
this.#client = new Client(proxyUrl, { connect })
|
|
}
|
|
}
|
|
|
|
[kDispatch] (opts, handler) {
|
|
const onHeaders = handler.onHeaders
|
|
handler.onHeaders = function (statusCode, data, resume) {
|
|
if (statusCode === 407) {
|
|
if (typeof handler.onError === 'function') {
|
|
handler.onError(new InvalidArgumentError('Proxy Authentication Required (407)'))
|
|
}
|
|
return
|
|
}
|
|
if (onHeaders) onHeaders.call(this, statusCode, data, resume)
|
|
}
|
|
|
|
// Rewrite request as an HTTP1 Proxy request, without tunneling.
|
|
const {
|
|
origin,
|
|
path = '/',
|
|
headers = {}
|
|
} = opts
|
|
|
|
opts.path = origin + path
|
|
|
|
if (!('host' in headers) && !('Host' in headers)) {
|
|
const { host } = new URL(origin)
|
|
headers.host = host
|
|
}
|
|
opts.headers = { ...this[kProxyHeaders], ...headers }
|
|
|
|
return this.#client[kDispatch](opts, handler)
|
|
}
|
|
|
|
async [kClose] () {
|
|
return this.#client.close()
|
|
}
|
|
|
|
async [kDestroy] (err) {
|
|
return this.#client.destroy(err)
|
|
}
|
|
}
|
|
|
|
class ProxyAgent extends DispatcherBase {
|
|
constructor (opts) {
|
|
super()
|
|
|
|
if (!opts || (typeof opts === 'object' && !(opts instanceof URL) && !opts.uri)) {
|
|
throw new InvalidArgumentError('Proxy uri is mandatory')
|
|
}
|
|
|
|
const { clientFactory = defaultFactory } = opts
|
|
if (typeof clientFactory !== 'function') {
|
|
throw new InvalidArgumentError('Proxy opts.clientFactory must be a function.')
|
|
}
|
|
|
|
const { proxyTunnel = true } = opts
|
|
|
|
const url = this.#getUrl(opts)
|
|
const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url
|
|
|
|
this[kProxy] = { uri: href, protocol }
|
|
this[kInterceptors] = opts.interceptors?.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent)
|
|
? opts.interceptors.ProxyAgent
|
|
: []
|
|
this[kRequestTls] = opts.requestTls
|
|
this[kProxyTls] = opts.proxyTls
|
|
this[kProxyHeaders] = opts.headers || {}
|
|
this[kTunnelProxy] = proxyTunnel
|
|
|
|
if (opts.auth && opts.token) {
|
|
throw new InvalidArgumentError('opts.auth cannot be used in combination with opts.token')
|
|
} else if (opts.auth) {
|
|
/* @deprecated in favour of opts.token */
|
|
this[kProxyHeaders]['proxy-authorization'] = `Basic ${opts.auth}`
|
|
} else if (opts.token) {
|
|
this[kProxyHeaders]['proxy-authorization'] = opts.token
|
|
} else if (username && password) {
|
|
this[kProxyHeaders]['proxy-authorization'] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString('base64')}`
|
|
}
|
|
|
|
const connect = buildConnector({ ...opts.proxyTls })
|
|
this[kConnectEndpoint] = buildConnector({ ...opts.requestTls })
|
|
|
|
const agentFactory = opts.factory || defaultAgentFactory
|
|
const factory = (origin, options) => {
|
|
const { protocol } = new URL(origin)
|
|
if (!this[kTunnelProxy] && protocol === 'http:' && this[kProxy].protocol === 'http:') {
|
|
return new Http1ProxyWrapper(this[kProxy].uri, {
|
|
headers: this[kProxyHeaders],
|
|
connect,
|
|
factory: agentFactory
|
|
})
|
|
}
|
|
return agentFactory(origin, options)
|
|
}
|
|
this[kClient] = clientFactory(url, { connect })
|
|
this[kAgent] = new Agent({
|
|
...opts,
|
|
factory,
|
|
connect: async (opts, callback) => {
|
|
let requestedPath = opts.host
|
|
if (!opts.port) {
|
|
requestedPath += `:${defaultProtocolPort(opts.protocol)}`
|
|
}
|
|
try {
|
|
const { socket, statusCode } = await this[kClient].connect({
|
|
origin,
|
|
port,
|
|
path: requestedPath,
|
|
signal: opts.signal,
|
|
headers: {
|
|
...this[kProxyHeaders],
|
|
host: opts.host
|
|
},
|
|
servername: this[kProxyTls]?.servername || proxyHostname
|
|
})
|
|
if (statusCode !== 200) {
|
|
socket.on('error', noop).destroy()
|
|
callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`))
|
|
}
|
|
if (opts.protocol !== 'https:') {
|
|
callback(null, socket)
|
|
return
|
|
}
|
|
let servername
|
|
if (this[kRequestTls]) {
|
|
servername = this[kRequestTls].servername
|
|
} else {
|
|
servername = opts.servername
|
|
}
|
|
this[kConnectEndpoint]({ ...opts, servername, httpSocket: socket }, callback)
|
|
} catch (err) {
|
|
if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
|
|
// Throw a custom error to avoid loop in client.js#connect
|
|
callback(new SecureProxyConnectionError(err))
|
|
} else {
|
|
callback(err)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
dispatch (opts, handler) {
|
|
const headers = buildHeaders(opts.headers)
|
|
throwIfProxyAuthIsSent(headers)
|
|
|
|
if (headers && !('host' in headers) && !('Host' in headers)) {
|
|
const { host } = new URL(opts.origin)
|
|
headers.host = host
|
|
}
|
|
|
|
return this[kAgent].dispatch(
|
|
{
|
|
...opts,
|
|
headers
|
|
},
|
|
handler
|
|
)
|
|
}
|
|
|
|
/**
|
|
* @param {import('../types/proxy-agent').ProxyAgent.Options | string | URL} opts
|
|
* @returns {URL}
|
|
*/
|
|
#getUrl (opts) {
|
|
if (typeof opts === 'string') {
|
|
return new URL(opts)
|
|
} else if (opts instanceof URL) {
|
|
return opts
|
|
} else {
|
|
return new URL(opts.uri)
|
|
}
|
|
}
|
|
|
|
async [kClose] () {
|
|
await this[kAgent].close()
|
|
await this[kClient].close()
|
|
}
|
|
|
|
async [kDestroy] () {
|
|
await this[kAgent].destroy()
|
|
await this[kClient].destroy()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {string[] | Record<string, string>} headers
|
|
* @returns {Record<string, string>}
|
|
*/
|
|
function buildHeaders (headers) {
|
|
// When using undici.fetch, the headers list is stored
|
|
// as an array.
|
|
if (Array.isArray(headers)) {
|
|
/** @type {Record<string, string>} */
|
|
const headersPair = {}
|
|
|
|
for (let i = 0; i < headers.length; i += 2) {
|
|
headersPair[headers[i]] = headers[i + 1]
|
|
}
|
|
|
|
return headersPair
|
|
}
|
|
|
|
return headers
|
|
}
|
|
|
|
/**
|
|
* @param {Record<string, string>} headers
|
|
*
|
|
* Previous versions of ProxyAgent suggests the Proxy-Authorization in request headers
|
|
* Nevertheless, it was changed and to avoid a security vulnerability by end users
|
|
* this check was created.
|
|
* It should be removed in the next major version for performance reasons
|
|
*/
|
|
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')
|
|
}
|
|
}
|
|
|
|
module.exports = ProxyAgent
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 50:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const Dispatcher = __nccwpck_require__(883)
|
|
const RetryHandler = __nccwpck_require__(7816)
|
|
|
|
class RetryAgent extends Dispatcher {
|
|
#agent = null
|
|
#options = null
|
|
constructor (agent, options = {}) {
|
|
super(options)
|
|
this.#agent = agent
|
|
this.#options = options
|
|
}
|
|
|
|
dispatch (opts, handler) {
|
|
const retry = new RetryHandler({
|
|
...opts,
|
|
retryOptions: this.#options
|
|
}, {
|
|
dispatch: this.#agent.dispatch.bind(this.#agent),
|
|
handler
|
|
})
|
|
return this.#agent.dispatch(opts, retry)
|
|
}
|
|
|
|
close () {
|
|
return this.#agent.close()
|
|
}
|
|
|
|
destroy () {
|
|
return this.#agent.destroy()
|
|
}
|
|
}
|
|
|
|
module.exports = RetryAgent
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2581:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
// We include a version number for the Dispatcher API. In case of breaking changes,
|
|
// this version number must be increased to avoid conflicts.
|
|
const globalDispatcher = Symbol.for('undici.globalDispatcher.1')
|
|
const { InvalidArgumentError } = __nccwpck_require__(8707)
|
|
const Agent = __nccwpck_require__(7405)
|
|
|
|
if (getGlobalDispatcher() === undefined) {
|
|
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]
|
|
}
|
|
|
|
module.exports = {
|
|
setGlobalDispatcher,
|
|
getGlobalDispatcher
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8155:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
module.exports = class DecoratorHandler {
|
|
#handler
|
|
|
|
constructor (handler) {
|
|
if (typeof handler !== 'object' || handler === null) {
|
|
throw new TypeError('handler must be an object')
|
|
}
|
|
this.#handler = handler
|
|
}
|
|
|
|
onConnect (...args) {
|
|
return this.#handler.onConnect?.(...args)
|
|
}
|
|
|
|
onError (...args) {
|
|
return this.#handler.onError?.(...args)
|
|
}
|
|
|
|
onUpgrade (...args) {
|
|
return this.#handler.onUpgrade?.(...args)
|
|
}
|
|
|
|
onResponseStarted (...args) {
|
|
return this.#handler.onResponseStarted?.(...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)
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8754:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const util = __nccwpck_require__(3440)
|
|
const { kBodyUsed } = __nccwpck_require__(6443)
|
|
const assert = __nccwpck_require__(4589)
|
|
const { InvalidArgumentError } = __nccwpck_require__(8707)
|
|
const EE = __nccwpck_require__(8474)
|
|
|
|
const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
|
|
|
|
const kBody = Symbol('body')
|
|
|
|
class BodyAsyncIterable {
|
|
constructor (body) {
|
|
this[kBody] = body
|
|
this[kBodyUsed] = false
|
|
}
|
|
|
|
async * [Symbol.asyncIterator] () {
|
|
assert(!this[kBodyUsed], 'disturbed')
|
|
this[kBodyUsed] = true
|
|
yield * this[kBody]
|
|
}
|
|
}
|
|
|
|
class RedirectHandler {
|
|
constructor (dispatch, maxRedirections, opts, handler) {
|
|
if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
|
|
throw new InvalidArgumentError('maxRedirections must be a positive number')
|
|
}
|
|
|
|
util.validateHandler(handler, opts.method, opts.upgrade)
|
|
|
|
this.dispatch = dispatch
|
|
this.location = null
|
|
this.abort = null
|
|
this.opts = { ...opts, maxRedirections: 0 } // opts must be a copy
|
|
this.maxRedirections = maxRedirections
|
|
this.handler = handler
|
|
this.history = []
|
|
this.redirectionLimitReached = false
|
|
|
|
if (util.isStream(this.opts.body)) {
|
|
// TODO (fix): Provide some way for the user to cache the file to e.g. /tmp
|
|
// so that it can be dispatched again?
|
|
// TODO (fix): Do we need 100-expect support to provide a way to do this properly?
|
|
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') {
|
|
// TODO (fix): We can't access ReadableStream internal state
|
|
// to determine whether or not it has been disturbed. This is just
|
|
// a workaround.
|
|
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)
|
|
) {
|
|
// TODO: Should we allow re-using iterable if !this.opts.idempotent
|
|
// or through some other flag?
|
|
this.opts.body = new BodyAsyncIterable(this.opts.body)
|
|
}
|
|
}
|
|
|
|
onConnect (abort) {
|
|
this.abort = abort
|
|
this.handler.onConnect(abort, { history: this.history })
|
|
}
|
|
|
|
onUpgrade (statusCode, headers, socket) {
|
|
this.handler.onUpgrade(statusCode, headers, socket)
|
|
}
|
|
|
|
onError (error) {
|
|
this.handler.onError(error)
|
|
}
|
|
|
|
onHeaders (statusCode, headers, resume, statusText) {
|
|
this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body)
|
|
? null
|
|
: parseLocation(statusCode, headers)
|
|
|
|
if (this.opts.throwOnMaxRedirect && this.history.length >= this.maxRedirections) {
|
|
if (this.request) {
|
|
this.request.abort(new Error('max redirects'))
|
|
}
|
|
|
|
this.redirectionLimitReached = true
|
|
this.abort(new Error('max redirects'))
|
|
return
|
|
}
|
|
|
|
if (this.opts.origin) {
|
|
this.history.push(new URL(this.opts.path, this.opts.origin))
|
|
}
|
|
|
|
if (!this.location) {
|
|
return this.handler.onHeaders(statusCode, headers, resume, statusText)
|
|
}
|
|
|
|
const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)))
|
|
const path = search ? `${pathname}${search}` : pathname
|
|
|
|
// Remove headers referring to the original URL.
|
|
// By default it is Host only, unless it's a 303 (see below), which removes also all Content-* headers.
|
|
// https://tools.ietf.org/html/rfc7231#section-6.4
|
|
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
|
|
|
|
// https://tools.ietf.org/html/rfc7231#section-6.4.4
|
|
// In case of HTTP 303, always replace method to be either HEAD or GET
|
|
if (statusCode === 303 && this.opts.method !== 'HEAD') {
|
|
this.opts.method = 'GET'
|
|
this.opts.body = null
|
|
}
|
|
}
|
|
|
|
onData (chunk) {
|
|
if (this.location) {
|
|
/*
|
|
https://tools.ietf.org/html/rfc7231#section-6.4
|
|
|
|
TLDR: undici always ignores 3xx response bodies.
|
|
|
|
Redirection is used to serve the requested resource from another URL, so it is assumes that
|
|
no body is generated (and thus can be ignored). Even though generating a body is not prohibited.
|
|
|
|
For status 301, 302, 303, 307 and 308 (the latter from RFC 7238), the specs mention that the body usually
|
|
(which means it's optional and not mandated) contain just an hyperlink to the value of
|
|
the Location response header, so the body can be ignored safely.
|
|
|
|
For status 300, which is "Multiple Choices", the spec mentions both generating a Location
|
|
response header AND a response body with the other possible location to follow.
|
|
Since the spec explicitly chooses not to specify a format for such body and leave it to
|
|
servers and browsers implementors, we ignore the body as there is no specified way to eventually parse it.
|
|
*/
|
|
} else {
|
|
return this.handler.onData(chunk)
|
|
}
|
|
}
|
|
|
|
onComplete (trailers) {
|
|
if (this.location) {
|
|
/*
|
|
https://tools.ietf.org/html/rfc7231#section-6.4
|
|
|
|
TLDR: undici always ignores 3xx response trailers as they are not expected in case of redirections
|
|
and neither are useful if present.
|
|
|
|
See comment on onData method above for more detailed information.
|
|
*/
|
|
|
|
this.location = null
|
|
this.abort = null
|
|
|
|
this.dispatch(this.opts, this)
|
|
} else {
|
|
this.handler.onComplete(trailers)
|
|
}
|
|
}
|
|
|
|
onBodySent (chunk) {
|
|
if (this.handler.onBodySent) {
|
|
this.handler.onBodySent(chunk)
|
|
}
|
|
}
|
|
}
|
|
|
|
function parseLocation (statusCode, headers) {
|
|
if (redirectableStatusCodes.indexOf(statusCode) === -1) {
|
|
return null
|
|
}
|
|
|
|
for (let i = 0; i < headers.length; i += 2) {
|
|
if (headers[i].length === 8 && util.headerNameToString(headers[i]) === 'location') {
|
|
return headers[i + 1]
|
|
}
|
|
}
|
|
}
|
|
|
|
// https://tools.ietf.org/html/rfc7231#section-6.4.4
|
|
function shouldRemoveHeader (header, removeContent, unknownOrigin) {
|
|
if (header.length === 4) {
|
|
return util.headerNameToString(header) === 'host'
|
|
}
|
|
if (removeContent && util.headerNameToString(header).startsWith('content-')) {
|
|
return true
|
|
}
|
|
if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) {
|
|
const name = util.headerNameToString(header)
|
|
return name === 'authorization' || name === 'cookie' || name === 'proxy-authorization'
|
|
}
|
|
return false
|
|
}
|
|
|
|
// https://tools.ietf.org/html/rfc7231#section-6.4
|
|
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
|
|
}
|
|
|
|
module.exports = RedirectHandler
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7816:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
const assert = __nccwpck_require__(4589)
|
|
|
|
const { kRetryHandlerDefaultRetry } = __nccwpck_require__(6443)
|
|
const { RequestRetryError } = __nccwpck_require__(8707)
|
|
const {
|
|
isDisturbed,
|
|
parseHeaders,
|
|
parseRangeHeader,
|
|
wrapRequestBody
|
|
} = __nccwpck_require__(3440)
|
|
|
|
function calculateRetryAfterHeader (retryAfter) {
|
|
const current = Date.now()
|
|
return new Date(retryAfter).getTime() - current
|
|
}
|
|
|
|
class RetryHandler {
|
|
constructor (opts, handlers) {
|
|
const { retryOptions, ...dispatchOpts } = opts
|
|
const {
|
|
// Retry scoped
|
|
retry: retryFn,
|
|
maxRetries,
|
|
maxTimeout,
|
|
minTimeout,
|
|
timeoutFactor,
|
|
// Response scoped
|
|
methods,
|
|
errorCodes,
|
|
retryAfter,
|
|
statusCodes
|
|
} = retryOptions ?? {}
|
|
|
|
this.dispatch = handlers.dispatch
|
|
this.handler = handlers.handler
|
|
this.opts = { ...dispatchOpts, body: wrapRequestBody(opts.body) }
|
|
this.abort = null
|
|
this.aborted = false
|
|
this.retryOpts = {
|
|
retry: retryFn ?? RetryHandler[kRetryHandlerDefaultRetry],
|
|
retryAfter: retryAfter ?? true,
|
|
maxTimeout: maxTimeout ?? 30 * 1000, // 30s,
|
|
minTimeout: minTimeout ?? 500, // .5s
|
|
timeoutFactor: timeoutFactor ?? 2,
|
|
maxRetries: maxRetries ?? 5,
|
|
// What errors we should retry
|
|
methods: methods ?? ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE'],
|
|
// Indicates which errors to retry
|
|
statusCodes: statusCodes ?? [500, 502, 503, 504, 429],
|
|
// List of errors to retry
|
|
errorCodes: errorCodes ?? [
|
|
'ECONNRESET',
|
|
'ECONNREFUSED',
|
|
'ENOTFOUND',
|
|
'ENETDOWN',
|
|
'ENETUNREACH',
|
|
'EHOSTDOWN',
|
|
'EHOSTUNREACH',
|
|
'EPIPE',
|
|
'UND_ERR_SOCKET'
|
|
]
|
|
}
|
|
|
|
this.retryCount = 0
|
|
this.retryCountCheckpoint = 0
|
|
this.start = 0
|
|
this.end = null
|
|
this.etag = null
|
|
this.resume = null
|
|
|
|
// Handle possible onConnect duplication
|
|
this.handler.onConnect(reason => {
|
|
this.aborted = true
|
|
if (this.abort) {
|
|
this.abort(reason)
|
|
} else {
|
|
this.reason = reason
|
|
}
|
|
})
|
|
}
|
|
|
|
onRequestSent () {
|
|
if (this.handler.onRequestSent) {
|
|
this.handler.onRequestSent()
|
|
}
|
|
}
|
|
|
|
onUpgrade (statusCode, headers, socket) {
|
|
if (this.handler.onUpgrade) {
|
|
this.handler.onUpgrade(statusCode, headers, socket)
|
|
}
|
|
}
|
|
|
|
onConnect (abort) {
|
|
if (this.aborted) {
|
|
abort(this.reason)
|
|
} else {
|
|
this.abort = abort
|
|
}
|
|
}
|
|
|
|
onBodySent (chunk) {
|
|
if (this.handler.onBodySent) return this.handler.onBodySent(chunk)
|
|
}
|
|
|
|
static [kRetryHandlerDefaultRetry] (err, { state, opts }, cb) {
|
|
const { statusCode, code, headers } = err
|
|
const { method, retryOptions } = opts
|
|
const {
|
|
maxRetries,
|
|
minTimeout,
|
|
maxTimeout,
|
|
timeoutFactor,
|
|
statusCodes,
|
|
errorCodes,
|
|
methods
|
|
} = retryOptions
|
|
const { counter } = state
|
|
|
|
// Any code that is not a Undici's originated and allowed to retry
|
|
if (code && code !== 'UND_ERR_REQ_RETRY' && !errorCodes.includes(code)) {
|
|
cb(err)
|
|
return
|
|
}
|
|
|
|
// If a set of method are provided and the current method is not in the list
|
|
if (Array.isArray(methods) && !methods.includes(method)) {
|
|
cb(err)
|
|
return
|
|
}
|
|
|
|
// If a set of status code are provided and the current status code is not in the list
|
|
if (
|
|
statusCode != null &&
|
|
Array.isArray(statusCodes) &&
|
|
!statusCodes.includes(statusCode)
|
|
) {
|
|
cb(err)
|
|
return
|
|
}
|
|
|
|
// If we reached the max number of retries
|
|
if (counter > maxRetries) {
|
|
cb(err)
|
|
return
|
|
}
|
|
|
|
let retryAfterHeader = headers?.['retry-after']
|
|
if (retryAfterHeader) {
|
|
retryAfterHeader = Number(retryAfterHeader)
|
|
retryAfterHeader = Number.isNaN(retryAfterHeader)
|
|
? calculateRetryAfterHeader(retryAfterHeader)
|
|
: retryAfterHeader * 1e3 // Retry-After is in seconds
|
|
}
|
|
|
|
const retryTimeout =
|
|
retryAfterHeader > 0
|
|
? Math.min(retryAfterHeader, maxTimeout)
|
|
: Math.min(minTimeout * timeoutFactor ** (counter - 1), maxTimeout)
|
|
|
|
setTimeout(() => cb(null), retryTimeout)
|
|
}
|
|
|
|
onHeaders (statusCode, rawHeaders, resume, statusMessage) {
|
|
const headers = parseHeaders(rawHeaders)
|
|
|
|
this.retryCount += 1
|
|
|
|
if (statusCode >= 300) {
|
|
if (this.retryOpts.statusCodes.includes(statusCode) === false) {
|
|
return this.handler.onHeaders(
|
|
statusCode,
|
|
rawHeaders,
|
|
resume,
|
|
statusMessage
|
|
)
|
|
} else {
|
|
this.abort(
|
|
new RequestRetryError('Request failed', statusCode, {
|
|
headers,
|
|
data: {
|
|
count: this.retryCount
|
|
}
|
|
})
|
|
)
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Checkpoint for resume from where we left it
|
|
if (this.resume != null) {
|
|
this.resume = null
|
|
|
|
// Only Partial Content 206 supposed to provide Content-Range,
|
|
// any other status code that partially consumed the payload
|
|
// should not be retry because it would result in downstream
|
|
// wrongly concatanete multiple responses.
|
|
if (statusCode !== 206 && (this.start > 0 || statusCode !== 200)) {
|
|
this.abort(
|
|
new RequestRetryError('server does not support the range header and the payload was partially consumed', statusCode, {
|
|
headers,
|
|
data: { count: this.retryCount }
|
|
})
|
|
)
|
|
return false
|
|
}
|
|
|
|
const contentRange = parseRangeHeader(headers['content-range'])
|
|
// If no content range
|
|
if (!contentRange) {
|
|
this.abort(
|
|
new RequestRetryError('Content-Range mismatch', statusCode, {
|
|
headers,
|
|
data: { count: this.retryCount }
|
|
})
|
|
)
|
|
return false
|
|
}
|
|
|
|
// Let's start with a weak etag check
|
|
if (this.etag != null && this.etag !== headers.etag) {
|
|
this.abort(
|
|
new RequestRetryError('ETag mismatch', statusCode, {
|
|
headers,
|
|
data: { count: this.retryCount }
|
|
})
|
|
)
|
|
return false
|
|
}
|
|
|
|
const { start, size, end = size - 1 } = contentRange
|
|
|
|
assert(this.start === start, 'content-range mismatch')
|
|
assert(this.end == null || this.end === end, 'content-range mismatch')
|
|
|
|
this.resume = resume
|
|
return true
|
|
}
|
|
|
|
if (this.end == null) {
|
|
if (statusCode === 206) {
|
|
// First time we receive 206
|
|
const range = parseRangeHeader(headers['content-range'])
|
|
|
|
if (range == null) {
|
|
return this.handler.onHeaders(
|
|
statusCode,
|
|
rawHeaders,
|
|
resume,
|
|
statusMessage
|
|
)
|
|
}
|
|
|
|
const { start, size, end = size - 1 } = range
|
|
assert(
|
|
start != null && Number.isFinite(start),
|
|
'content-range mismatch'
|
|
)
|
|
assert(end != null && Number.isFinite(end), 'invalid content-length')
|
|
|
|
this.start = start
|
|
this.end = end
|
|
}
|
|
|
|
// We make our best to checkpoint the body for further range headers
|
|
if (this.end == null) {
|
|
const contentLength = headers['content-length']
|
|
this.end = contentLength != null ? Number(contentLength) - 1 : null
|
|
}
|
|
|
|
assert(Number.isFinite(this.start))
|
|
assert(
|
|
this.end == null || Number.isFinite(this.end),
|
|
'invalid content-length'
|
|
)
|
|
|
|
this.resume = resume
|
|
this.etag = headers.etag != null ? headers.etag : null
|
|
|
|
// Weak etags are not useful for comparison nor cache
|
|
// for instance not safe to assume if the response is byte-per-byte
|
|
// equal
|
|
if (this.etag != null && this.etag.startsWith('W/')) {
|
|
this.etag = null
|
|
}
|
|
|
|
return this.handler.onHeaders(
|
|
statusCode,
|
|
rawHeaders,
|
|
resume,
|
|
statusMessage
|
|
)
|
|
}
|
|
|
|
const err = new RequestRetryError('Request failed', statusCode, {
|
|
headers,
|
|
data: { count: this.retryCount }
|
|
})
|
|
|
|
this.abort(err)
|
|
|
|
return false
|
|
}
|
|
|
|
onData (chunk) {
|
|
this.start += chunk.length
|
|
|
|
return this.handler.onData(chunk)
|
|
}
|
|
|
|
onComplete (rawTrailers) {
|
|
this.retryCount = 0
|
|
return this.handler.onComplete(rawTrailers)
|
|
}
|
|
|
|
onError (err) {
|
|
if (this.aborted || isDisturbed(this.opts.body)) {
|
|
return this.handler.onError(err)
|
|
}
|
|
|
|
// We reconcile in case of a mix between network errors
|
|
// and server error response
|
|
if (this.retryCount - this.retryCountCheckpoint > 0) {
|
|
// We count the difference between the last checkpoint and the current retry count
|
|
this.retryCount =
|
|
this.retryCountCheckpoint +
|
|
(this.retryCount - this.retryCountCheckpoint)
|
|
} else {
|
|
this.retryCount += 1
|
|
}
|
|
|
|
this.retryOpts.retry(
|
|
err,
|
|
{
|
|
state: { counter: this.retryCount },
|
|
opts: { retryOptions: this.retryOpts, ...this.opts }
|
|
},
|
|
onRetry.bind(this)
|
|
)
|
|
|
|
function onRetry (err) {
|
|
if (err != null || this.aborted || isDisturbed(this.opts.body)) {
|
|
return this.handler.onError(err)
|
|
}
|
|
|
|
if (this.start !== 0) {
|
|
const headers = { range: `bytes=${this.start}-${this.end ?? ''}` }
|
|
|
|
// Weak etag check - weak etags will make comparison algorithms never match
|
|
if (this.etag != null) {
|
|
headers['if-match'] = this.etag
|
|
}
|
|
|
|
this.opts = {
|
|
...this.opts,
|
|
headers: {
|
|
...this.opts.headers,
|
|
...headers
|
|
}
|
|
}
|
|
}
|
|
|
|
try {
|
|
this.retryCountCheckpoint = this.retryCount
|
|
this.dispatch(this.opts, this)
|
|
} catch (err) {
|
|
this.handler.onError(err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = RetryHandler
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 379:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
const { isIP } = __nccwpck_require__(7030)
|
|
const { lookup } = __nccwpck_require__(610)
|
|
const DecoratorHandler = __nccwpck_require__(8155)
|
|
const { InvalidArgumentError, InformationalError } = __nccwpck_require__(8707)
|
|
const maxInt = Math.pow(2, 31) - 1
|
|
|
|
class DNSInstance {
|
|
#maxTTL = 0
|
|
#maxItems = 0
|
|
#records = new Map()
|
|
dualStack = true
|
|
affinity = null
|
|
lookup = null
|
|
pick = null
|
|
|
|
constructor (opts) {
|
|
this.#maxTTL = opts.maxTTL
|
|
this.#maxItems = opts.maxItems
|
|
this.dualStack = opts.dualStack
|
|
this.affinity = opts.affinity
|
|
this.lookup = opts.lookup ?? this.#defaultLookup
|
|
this.pick = opts.pick ?? this.#defaultPick
|
|
}
|
|
|
|
get full () {
|
|
return this.#records.size === this.#maxItems
|
|
}
|
|
|
|
runLookup (origin, opts, cb) {
|
|
const ips = this.#records.get(origin.hostname)
|
|
|
|
// If full, we just return the origin
|
|
if (ips == null && this.full) {
|
|
cb(null, origin.origin)
|
|
return
|
|
}
|
|
|
|
const newOpts = {
|
|
affinity: this.affinity,
|
|
dualStack: this.dualStack,
|
|
lookup: this.lookup,
|
|
pick: this.pick,
|
|
...opts.dns,
|
|
maxTTL: this.#maxTTL,
|
|
maxItems: this.#maxItems
|
|
}
|
|
|
|
// If no IPs we lookup
|
|
if (ips == null) {
|
|
this.lookup(origin, newOpts, (err, addresses) => {
|
|
if (err || addresses == null || addresses.length === 0) {
|
|
cb(err ?? new InformationalError('No DNS entries found'))
|
|
return
|
|
}
|
|
|
|
this.setRecords(origin, addresses)
|
|
const records = this.#records.get(origin.hostname)
|
|
|
|
const ip = this.pick(
|
|
origin,
|
|
records,
|
|
newOpts.affinity
|
|
)
|
|
|
|
let port
|
|
if (typeof ip.port === 'number') {
|
|
port = `:${ip.port}`
|
|
} else if (origin.port !== '') {
|
|
port = `:${origin.port}`
|
|
} else {
|
|
port = ''
|
|
}
|
|
|
|
cb(
|
|
null,
|
|
`${origin.protocol}//${
|
|
ip.family === 6 ? `[${ip.address}]` : ip.address
|
|
}${port}`
|
|
)
|
|
})
|
|
} else {
|
|
// If there's IPs we pick
|
|
const ip = this.pick(
|
|
origin,
|
|
ips,
|
|
newOpts.affinity
|
|
)
|
|
|
|
// If no IPs we lookup - deleting old records
|
|
if (ip == null) {
|
|
this.#records.delete(origin.hostname)
|
|
this.runLookup(origin, opts, cb)
|
|
return
|
|
}
|
|
|
|
let port
|
|
if (typeof ip.port === 'number') {
|
|
port = `:${ip.port}`
|
|
} else if (origin.port !== '') {
|
|
port = `:${origin.port}`
|
|
} else {
|
|
port = ''
|
|
}
|
|
|
|
cb(
|
|
null,
|
|
`${origin.protocol}//${
|
|
ip.family === 6 ? `[${ip.address}]` : ip.address
|
|
}${port}`
|
|
)
|
|
}
|
|
}
|
|
|
|
#defaultLookup (origin, opts, cb) {
|
|
lookup(
|
|
origin.hostname,
|
|
{
|
|
all: true,
|
|
family: this.dualStack === false ? this.affinity : 0,
|
|
order: 'ipv4first'
|
|
},
|
|
(err, addresses) => {
|
|
if (err) {
|
|
return cb(err)
|
|
}
|
|
|
|
const results = new Map()
|
|
|
|
for (const addr of addresses) {
|
|
// On linux we found duplicates, we attempt to remove them with
|
|
// the latest record
|
|
results.set(`${addr.address}:${addr.family}`, addr)
|
|
}
|
|
|
|
cb(null, results.values())
|
|
}
|
|
)
|
|
}
|
|
|
|
#defaultPick (origin, hostnameRecords, affinity) {
|
|
let ip = null
|
|
const { records, offset } = hostnameRecords
|
|
|
|
let family
|
|
if (this.dualStack) {
|
|
if (affinity == null) {
|
|
// Balance between ip families
|
|
if (offset == null || offset === maxInt) {
|
|
hostnameRecords.offset = 0
|
|
affinity = 4
|
|
} else {
|
|
hostnameRecords.offset++
|
|
affinity = (hostnameRecords.offset & 1) === 1 ? 6 : 4
|
|
}
|
|
}
|
|
|
|
if (records[affinity] != null && records[affinity].ips.length > 0) {
|
|
family = records[affinity]
|
|
} else {
|
|
family = records[affinity === 4 ? 6 : 4]
|
|
}
|
|
} else {
|
|
family = records[affinity]
|
|
}
|
|
|
|
// If no IPs we return null
|
|
if (family == null || family.ips.length === 0) {
|
|
return ip
|
|
}
|
|
|
|
if (family.offset == null || family.offset === maxInt) {
|
|
family.offset = 0
|
|
} else {
|
|
family.offset++
|
|
}
|
|
|
|
const position = family.offset % family.ips.length
|
|
ip = family.ips[position] ?? null
|
|
|
|
if (ip == null) {
|
|
return ip
|
|
}
|
|
|
|
if (Date.now() - ip.timestamp > ip.ttl) { // record TTL is already in ms
|
|
// We delete expired records
|
|
// It is possible that they have different TTL, so we manage them individually
|
|
family.ips.splice(position, 1)
|
|
return this.pick(origin, hostnameRecords, affinity)
|
|
}
|
|
|
|
return ip
|
|
}
|
|
|
|
setRecords (origin, addresses) {
|
|
const timestamp = Date.now()
|
|
const records = { records: { 4: null, 6: null } }
|
|
for (const record of addresses) {
|
|
record.timestamp = timestamp
|
|
if (typeof record.ttl === 'number') {
|
|
// The record TTL is expected to be in ms
|
|
record.ttl = Math.min(record.ttl, this.#maxTTL)
|
|
} else {
|
|
record.ttl = this.#maxTTL
|
|
}
|
|
|
|
const familyRecords = records.records[record.family] ?? { ips: [] }
|
|
|
|
familyRecords.ips.push(record)
|
|
records.records[record.family] = familyRecords
|
|
}
|
|
|
|
this.#records.set(origin.hostname, records)
|
|
}
|
|
|
|
getHandler (meta, opts) {
|
|
return new DNSDispatchHandler(this, meta, opts)
|
|
}
|
|
}
|
|
|
|
class DNSDispatchHandler extends DecoratorHandler {
|
|
#state = null
|
|
#opts = null
|
|
#dispatch = null
|
|
#handler = null
|
|
#origin = null
|
|
|
|
constructor (state, { origin, handler, dispatch }, opts) {
|
|
super(handler)
|
|
this.#origin = origin
|
|
this.#handler = handler
|
|
this.#opts = { ...opts }
|
|
this.#state = state
|
|
this.#dispatch = dispatch
|
|
}
|
|
|
|
onError (err) {
|
|
switch (err.code) {
|
|
case 'ETIMEDOUT':
|
|
case 'ECONNREFUSED': {
|
|
if (this.#state.dualStack) {
|
|
// We delete the record and retry
|
|
this.#state.runLookup(this.#origin, this.#opts, (err, newOrigin) => {
|
|
if (err) {
|
|
return this.#handler.onError(err)
|
|
}
|
|
|
|
const dispatchOpts = {
|
|
...this.#opts,
|
|
origin: newOrigin
|
|
}
|
|
|
|
this.#dispatch(dispatchOpts, this)
|
|
})
|
|
|
|
// if dual-stack disabled, we error out
|
|
return
|
|
}
|
|
|
|
this.#handler.onError(err)
|
|
return
|
|
}
|
|
case 'ENOTFOUND':
|
|
this.#state.deleteRecord(this.#origin)
|
|
// eslint-disable-next-line no-fallthrough
|
|
default:
|
|
this.#handler.onError(err)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = interceptorOpts => {
|
|
if (
|
|
interceptorOpts?.maxTTL != null &&
|
|
(typeof interceptorOpts?.maxTTL !== 'number' || interceptorOpts?.maxTTL < 0)
|
|
) {
|
|
throw new InvalidArgumentError('Invalid maxTTL. Must be a positive number')
|
|
}
|
|
|
|
if (
|
|
interceptorOpts?.maxItems != null &&
|
|
(typeof interceptorOpts?.maxItems !== 'number' ||
|
|
interceptorOpts?.maxItems < 1)
|
|
) {
|
|
throw new InvalidArgumentError(
|
|
'Invalid maxItems. Must be a positive number and greater than zero'
|
|
)
|
|
}
|
|
|
|
if (
|
|
interceptorOpts?.affinity != null &&
|
|
interceptorOpts?.affinity !== 4 &&
|
|
interceptorOpts?.affinity !== 6
|
|
) {
|
|
throw new InvalidArgumentError('Invalid affinity. Must be either 4 or 6')
|
|
}
|
|
|
|
if (
|
|
interceptorOpts?.dualStack != null &&
|
|
typeof interceptorOpts?.dualStack !== 'boolean'
|
|
) {
|
|
throw new InvalidArgumentError('Invalid dualStack. Must be a boolean')
|
|
}
|
|
|
|
if (
|
|
interceptorOpts?.lookup != null &&
|
|
typeof interceptorOpts?.lookup !== 'function'
|
|
) {
|
|
throw new InvalidArgumentError('Invalid lookup. Must be a function')
|
|
}
|
|
|
|
if (
|
|
interceptorOpts?.pick != null &&
|
|
typeof interceptorOpts?.pick !== 'function'
|
|
) {
|
|
throw new InvalidArgumentError('Invalid pick. Must be a function')
|
|
}
|
|
|
|
const dualStack = interceptorOpts?.dualStack ?? true
|
|
let affinity
|
|
if (dualStack) {
|
|
affinity = interceptorOpts?.affinity ?? null
|
|
} else {
|
|
affinity = interceptorOpts?.affinity ?? 4
|
|
}
|
|
|
|
const opts = {
|
|
maxTTL: interceptorOpts?.maxTTL ?? 10e3, // Expressed in ms
|
|
lookup: interceptorOpts?.lookup ?? null,
|
|
pick: interceptorOpts?.pick ?? null,
|
|
dualStack,
|
|
affinity,
|
|
maxItems: interceptorOpts?.maxItems ?? Infinity
|
|
}
|
|
|
|
const instance = new DNSInstance(opts)
|
|
|
|
return dispatch => {
|
|
return function dnsInterceptor (origDispatchOpts, handler) {
|
|
const origin =
|
|
origDispatchOpts.origin.constructor === URL
|
|
? origDispatchOpts.origin
|
|
: new URL(origDispatchOpts.origin)
|
|
|
|
if (isIP(origin.hostname) !== 0) {
|
|
return dispatch(origDispatchOpts, handler)
|
|
}
|
|
|
|
instance.runLookup(origin, origDispatchOpts, (err, newOrigin) => {
|
|
if (err) {
|
|
return handler.onError(err)
|
|
}
|
|
|
|
let dispatchOpts = null
|
|
dispatchOpts = {
|
|
...origDispatchOpts,
|
|
servername: origin.hostname, // For SNI on TLS
|
|
origin: newOrigin,
|
|
headers: {
|
|
host: origin.hostname,
|
|
...origDispatchOpts.headers
|
|
}
|
|
}
|
|
|
|
dispatch(
|
|
dispatchOpts,
|
|
instance.getHandler({ origin, dispatch, handler }, origDispatchOpts)
|
|
)
|
|
})
|
|
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8060:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const util = __nccwpck_require__(3440)
|
|
const { InvalidArgumentError, RequestAbortedError } = __nccwpck_require__(8707)
|
|
const DecoratorHandler = __nccwpck_require__(8155)
|
|
|
|
class DumpHandler extends DecoratorHandler {
|
|
#maxSize = 1024 * 1024
|
|
#abort = null
|
|
#dumped = false
|
|
#aborted = false
|
|
#size = 0
|
|
#reason = null
|
|
#handler = null
|
|
|
|
constructor ({ maxSize }, handler) {
|
|
super(handler)
|
|
|
|
if (maxSize != null && (!Number.isFinite(maxSize) || maxSize < 1)) {
|
|
throw new InvalidArgumentError('maxSize must be a number greater than 0')
|
|
}
|
|
|
|
this.#maxSize = maxSize ?? this.#maxSize
|
|
this.#handler = handler
|
|
}
|
|
|
|
onConnect (abort) {
|
|
this.#abort = abort
|
|
|
|
this.#handler.onConnect(this.#customAbort.bind(this))
|
|
}
|
|
|
|
#customAbort (reason) {
|
|
this.#aborted = true
|
|
this.#reason = reason
|
|
}
|
|
|
|
// TODO: will require adjustment after new hooks are out
|
|
onHeaders (statusCode, rawHeaders, resume, statusMessage) {
|
|
const headers = util.parseHeaders(rawHeaders)
|
|
const contentLength = headers['content-length']
|
|
|
|
if (contentLength != null && contentLength > this.#maxSize) {
|
|
throw new RequestAbortedError(
|
|
`Response size (${contentLength}) larger than maxSize (${
|
|
this.#maxSize
|
|
})`
|
|
)
|
|
}
|
|
|
|
if (this.#aborted) {
|
|
return true
|
|
}
|
|
|
|
return this.#handler.onHeaders(
|
|
statusCode,
|
|
rawHeaders,
|
|
resume,
|
|
statusMessage
|
|
)
|
|
}
|
|
|
|
onError (err) {
|
|
if (this.#dumped) {
|
|
return
|
|
}
|
|
|
|
err = this.#reason ?? err
|
|
|
|
this.#handler.onError(err)
|
|
}
|
|
|
|
onData (chunk) {
|
|
this.#size = this.#size + chunk.length
|
|
|
|
if (this.#size >= this.#maxSize) {
|
|
this.#dumped = true
|
|
|
|
if (this.#aborted) {
|
|
this.#handler.onError(this.#reason)
|
|
} else {
|
|
this.#handler.onComplete([])
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
onComplete (trailers) {
|
|
if (this.#dumped) {
|
|
return
|
|
}
|
|
|
|
if (this.#aborted) {
|
|
this.#handler.onError(this.reason)
|
|
return
|
|
}
|
|
|
|
this.#handler.onComplete(trailers)
|
|
}
|
|
}
|
|
|
|
function createDumpInterceptor (
|
|
{ maxSize: defaultMaxSize } = {
|
|
maxSize: 1024 * 1024
|
|
}
|
|
) {
|
|
return dispatch => {
|
|
return function Intercept (opts, handler) {
|
|
const { dumpMaxSize = defaultMaxSize } =
|
|
opts
|
|
|
|
const dumpHandler = new DumpHandler(
|
|
{ maxSize: dumpMaxSize },
|
|
handler
|
|
)
|
|
|
|
return dispatch(opts, dumpHandler)
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = createDumpInterceptor
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5092:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const RedirectHandler = __nccwpck_require__(8754)
|
|
|
|
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 } // Stop sub dispatcher from also redirecting.
|
|
return dispatch(opts, redirectHandler)
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = createRedirectInterceptor
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1514:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
const RedirectHandler = __nccwpck_require__(8754)
|
|
|
|
module.exports = opts => {
|
|
const globalMaxRedirections = opts?.maxRedirections
|
|
return dispatch => {
|
|
return function redirectInterceptor (opts, handler) {
|
|
const { maxRedirections = globalMaxRedirections, ...baseOpts } = opts
|
|
|
|
if (!maxRedirections) {
|
|
return dispatch(opts, handler)
|
|
}
|
|
|
|
const redirectHandler = new RedirectHandler(
|
|
dispatch,
|
|
maxRedirections,
|
|
opts,
|
|
handler
|
|
)
|
|
|
|
return dispatch(baseOpts, redirectHandler)
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2026:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
const RetryHandler = __nccwpck_require__(7816)
|
|
|
|
module.exports = globalOpts => {
|
|
return dispatch => {
|
|
return function retryInterceptor (opts, handler) {
|
|
return dispatch(
|
|
opts,
|
|
new RetryHandler(
|
|
{ ...opts, retryOptions: { ...globalOpts, ...opts.retryOptions } },
|
|
{
|
|
handler,
|
|
dispatch
|
|
}
|
|
)
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2824:
|
|
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.SPECIAL_HEADERS = exports.HEADER_STATE = exports.MINOR = exports.MAJOR = exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS = exports.TOKEN = exports.STRICT_TOKEN = exports.HEX = exports.URL_CHAR = exports.STRICT_URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.NUM = exports.HEX_MAP = exports.NUM_MAP = exports.ALPHA = exports.FINISH = exports.H_METHOD_MAP = exports.METHOD_MAP = exports.METHODS_RTSP = exports.METHODS_ICE = exports.METHODS_HTTP = exports.METHODS = exports.LENIENT_FLAGS = exports.FLAGS = exports.TYPE = exports.ERROR = void 0;
|
|
const utils_1 = __nccwpck_require__(172);
|
|
// C headers
|
|
var ERROR;
|
|
(function (ERROR) {
|
|
ERROR[ERROR["OK"] = 0] = "OK";
|
|
ERROR[ERROR["INTERNAL"] = 1] = "INTERNAL";
|
|
ERROR[ERROR["STRICT"] = 2] = "STRICT";
|
|
ERROR[ERROR["LF_EXPECTED"] = 3] = "LF_EXPECTED";
|
|
ERROR[ERROR["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH";
|
|
ERROR[ERROR["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION";
|
|
ERROR[ERROR["INVALID_METHOD"] = 6] = "INVALID_METHOD";
|
|
ERROR[ERROR["INVALID_URL"] = 7] = "INVALID_URL";
|
|
ERROR[ERROR["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT";
|
|
ERROR[ERROR["INVALID_VERSION"] = 9] = "INVALID_VERSION";
|
|
ERROR[ERROR["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN";
|
|
ERROR[ERROR["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH";
|
|
ERROR[ERROR["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE";
|
|
ERROR[ERROR["INVALID_STATUS"] = 13] = "INVALID_STATUS";
|
|
ERROR[ERROR["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE";
|
|
ERROR[ERROR["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING";
|
|
ERROR[ERROR["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN";
|
|
ERROR[ERROR["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE";
|
|
ERROR[ERROR["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE";
|
|
ERROR[ERROR["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER";
|
|
ERROR[ERROR["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE";
|
|
ERROR[ERROR["PAUSED"] = 21] = "PAUSED";
|
|
ERROR[ERROR["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE";
|
|
ERROR[ERROR["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE";
|
|
ERROR[ERROR["USER"] = 24] = "USER";
|
|
})(ERROR = exports.ERROR || (exports.ERROR = {}));
|
|
var TYPE;
|
|
(function (TYPE) {
|
|
TYPE[TYPE["BOTH"] = 0] = "BOTH";
|
|
TYPE[TYPE["REQUEST"] = 1] = "REQUEST";
|
|
TYPE[TYPE["RESPONSE"] = 2] = "RESPONSE";
|
|
})(TYPE = exports.TYPE || (exports.TYPE = {}));
|
|
var FLAGS;
|
|
(function (FLAGS) {
|
|
FLAGS[FLAGS["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE";
|
|
FLAGS[FLAGS["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE";
|
|
FLAGS[FLAGS["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE";
|
|
FLAGS[FLAGS["CHUNKED"] = 8] = "CHUNKED";
|
|
FLAGS[FLAGS["UPGRADE"] = 16] = "UPGRADE";
|
|
FLAGS[FLAGS["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH";
|
|
FLAGS[FLAGS["SKIPBODY"] = 64] = "SKIPBODY";
|
|
FLAGS[FLAGS["TRAILING"] = 128] = "TRAILING";
|
|
// 1 << 8 is unused
|
|
FLAGS[FLAGS["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING";
|
|
})(FLAGS = exports.FLAGS || (exports.FLAGS = {}));
|
|
var LENIENT_FLAGS;
|
|
(function (LENIENT_FLAGS) {
|
|
LENIENT_FLAGS[LENIENT_FLAGS["HEADERS"] = 1] = "HEADERS";
|
|
LENIENT_FLAGS[LENIENT_FLAGS["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH";
|
|
LENIENT_FLAGS[LENIENT_FLAGS["KEEP_ALIVE"] = 4] = "KEEP_ALIVE";
|
|
})(LENIENT_FLAGS = exports.LENIENT_FLAGS || (exports.LENIENT_FLAGS = {}));
|
|
var METHODS;
|
|
(function (METHODS) {
|
|
METHODS[METHODS["DELETE"] = 0] = "DELETE";
|
|
METHODS[METHODS["GET"] = 1] = "GET";
|
|
METHODS[METHODS["HEAD"] = 2] = "HEAD";
|
|
METHODS[METHODS["POST"] = 3] = "POST";
|
|
METHODS[METHODS["PUT"] = 4] = "PUT";
|
|
/* pathological */
|
|
METHODS[METHODS["CONNECT"] = 5] = "CONNECT";
|
|
METHODS[METHODS["OPTIONS"] = 6] = "OPTIONS";
|
|
METHODS[METHODS["TRACE"] = 7] = "TRACE";
|
|
/* WebDAV */
|
|
METHODS[METHODS["COPY"] = 8] = "COPY";
|
|
METHODS[METHODS["LOCK"] = 9] = "LOCK";
|
|
METHODS[METHODS["MKCOL"] = 10] = "MKCOL";
|
|
METHODS[METHODS["MOVE"] = 11] = "MOVE";
|
|
METHODS[METHODS["PROPFIND"] = 12] = "PROPFIND";
|
|
METHODS[METHODS["PROPPATCH"] = 13] = "PROPPATCH";
|
|
METHODS[METHODS["SEARCH"] = 14] = "SEARCH";
|
|
METHODS[METHODS["UNLOCK"] = 15] = "UNLOCK";
|
|
METHODS[METHODS["BIND"] = 16] = "BIND";
|
|
METHODS[METHODS["REBIND"] = 17] = "REBIND";
|
|
METHODS[METHODS["UNBIND"] = 18] = "UNBIND";
|
|
METHODS[METHODS["ACL"] = 19] = "ACL";
|
|
/* subversion */
|
|
METHODS[METHODS["REPORT"] = 20] = "REPORT";
|
|
METHODS[METHODS["MKACTIVITY"] = 21] = "MKACTIVITY";
|
|
METHODS[METHODS["CHECKOUT"] = 22] = "CHECKOUT";
|
|
METHODS[METHODS["MERGE"] = 23] = "MERGE";
|
|
/* upnp */
|
|
METHODS[METHODS["M-SEARCH"] = 24] = "M-SEARCH";
|
|
METHODS[METHODS["NOTIFY"] = 25] = "NOTIFY";
|
|
METHODS[METHODS["SUBSCRIBE"] = 26] = "SUBSCRIBE";
|
|
METHODS[METHODS["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE";
|
|
/* RFC-5789 */
|
|
METHODS[METHODS["PATCH"] = 28] = "PATCH";
|
|
METHODS[METHODS["PURGE"] = 29] = "PURGE";
|
|
/* CalDAV */
|
|
METHODS[METHODS["MKCALENDAR"] = 30] = "MKCALENDAR";
|
|
/* RFC-2068, section 19.6.1.2 */
|
|
METHODS[METHODS["LINK"] = 31] = "LINK";
|
|
METHODS[METHODS["UNLINK"] = 32] = "UNLINK";
|
|
/* icecast */
|
|
METHODS[METHODS["SOURCE"] = 33] = "SOURCE";
|
|
/* RFC-7540, section 11.6 */
|
|
METHODS[METHODS["PRI"] = 34] = "PRI";
|
|
/* RFC-2326 RTSP */
|
|
METHODS[METHODS["DESCRIBE"] = 35] = "DESCRIBE";
|
|
METHODS[METHODS["ANNOUNCE"] = 36] = "ANNOUNCE";
|
|
METHODS[METHODS["SETUP"] = 37] = "SETUP";
|
|
METHODS[METHODS["PLAY"] = 38] = "PLAY";
|
|
METHODS[METHODS["PAUSE"] = 39] = "PAUSE";
|
|
METHODS[METHODS["TEARDOWN"] = 40] = "TEARDOWN";
|
|
METHODS[METHODS["GET_PARAMETER"] = 41] = "GET_PARAMETER";
|
|
METHODS[METHODS["SET_PARAMETER"] = 42] = "SET_PARAMETER";
|
|
METHODS[METHODS["REDIRECT"] = 43] = "REDIRECT";
|
|
METHODS[METHODS["RECORD"] = 44] = "RECORD";
|
|
/* RAOP */
|
|
METHODS[METHODS["FLUSH"] = 45] = "FLUSH";
|
|
})(METHODS = exports.METHODS || (exports.METHODS = {}));
|
|
exports.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,
|
|
];
|
|
exports.METHODS_ICE = [
|
|
METHODS.SOURCE,
|
|
];
|
|
exports.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,
|
|
];
|
|
exports.METHOD_MAP = utils_1.enumToMap(METHODS);
|
|
exports.H_METHOD_MAP = {};
|
|
Object.keys(exports.METHOD_MAP).forEach((key) => {
|
|
if (/^H/.test(key)) {
|
|
exports.H_METHOD_MAP[key] = exports.METHOD_MAP[key];
|
|
}
|
|
});
|
|
var FINISH;
|
|
(function (FINISH) {
|
|
FINISH[FINISH["SAFE"] = 0] = "SAFE";
|
|
FINISH[FINISH["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB";
|
|
FINISH[FINISH["UNSAFE"] = 2] = "UNSAFE";
|
|
})(FINISH = exports.FINISH || (exports.FINISH = {}));
|
|
exports.ALPHA = [];
|
|
for (let i = 'A'.charCodeAt(0); i <= 'Z'.charCodeAt(0); i++) {
|
|
// Upper case
|
|
exports.ALPHA.push(String.fromCharCode(i));
|
|
// Lower case
|
|
exports.ALPHA.push(String.fromCharCode(i + 0x20));
|
|
}
|
|
exports.NUM_MAP = {
|
|
0: 0, 1: 1, 2: 2, 3: 3, 4: 4,
|
|
5: 5, 6: 6, 7: 7, 8: 8, 9: 9,
|
|
};
|
|
exports.HEX_MAP = {
|
|
0: 0, 1: 1, 2: 2, 3: 3, 4: 4,
|
|
5: 5, 6: 6, 7: 7, 8: 8, 9: 9,
|
|
A: 0XA, B: 0XB, C: 0XC, D: 0XD, E: 0XE, F: 0XF,
|
|
a: 0xa, b: 0xb, c: 0xc, d: 0xd, e: 0xe, f: 0xf,
|
|
};
|
|
exports.NUM = [
|
|
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
|
];
|
|
exports.ALPHANUM = exports.ALPHA.concat(exports.NUM);
|
|
exports.MARK = ['-', '_', '.', '!', '~', '*', '\'', '(', ')'];
|
|
exports.USERINFO_CHARS = exports.ALPHANUM
|
|
.concat(exports.MARK)
|
|
.concat(['%', ';', ':', '&', '=', '+', '$', ',']);
|
|
// TODO(indutny): use RFC
|
|
exports.STRICT_URL_CHAR = [
|
|
'!', '"', '$', '%', '&', '\'',
|
|
'(', ')', '*', '+', ',', '-', '.', '/',
|
|
':', ';', '<', '=', '>',
|
|
'@', '[', '\\', ']', '^', '_',
|
|
'`',
|
|
'{', '|', '}', '~',
|
|
].concat(exports.ALPHANUM);
|
|
exports.URL_CHAR = exports.STRICT_URL_CHAR
|
|
.concat(['\t', '\f']);
|
|
// All characters with 0x80 bit set to 1
|
|
for (let i = 0x80; i <= 0xff; i++) {
|
|
exports.URL_CHAR.push(i);
|
|
}
|
|
exports.HEX = exports.NUM.concat(['a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F']);
|
|
/* Tokens as defined by rfc 2616. Also lowercases them.
|
|
* token = 1*<any CHAR except CTLs or separators>
|
|
* separators = "(" | ")" | "<" | ">" | "@"
|
|
* | "," | ";" | ":" | "\" | <">
|
|
* | "/" | "[" | "]" | "?" | "="
|
|
* | "{" | "}" | SP | HT
|
|
*/
|
|
exports.STRICT_TOKEN = [
|
|
'!', '#', '$', '%', '&', '\'',
|
|
'*', '+', '-', '.',
|
|
'^', '_', '`',
|
|
'|', '~',
|
|
].concat(exports.ALPHANUM);
|
|
exports.TOKEN = exports.STRICT_TOKEN.concat([' ']);
|
|
/*
|
|
* Verify that a char is a valid visible (printable) US-ASCII
|
|
* character or %x80-FF
|
|
*/
|
|
exports.HEADER_CHARS = ['\t'];
|
|
for (let i = 32; i <= 255; i++) {
|
|
if (i !== 127) {
|
|
exports.HEADER_CHARS.push(i);
|
|
}
|
|
}
|
|
// ',' = \x44
|
|
exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS.filter((c) => c !== 44);
|
|
exports.MAJOR = exports.NUM_MAP;
|
|
exports.MINOR = exports.MAJOR;
|
|
var HEADER_STATE;
|
|
(function (HEADER_STATE) {
|
|
HEADER_STATE[HEADER_STATE["GENERAL"] = 0] = "GENERAL";
|
|
HEADER_STATE[HEADER_STATE["CONNECTION"] = 1] = "CONNECTION";
|
|
HEADER_STATE[HEADER_STATE["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH";
|
|
HEADER_STATE[HEADER_STATE["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING";
|
|
HEADER_STATE[HEADER_STATE["UPGRADE"] = 4] = "UPGRADE";
|
|
HEADER_STATE[HEADER_STATE["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE";
|
|
HEADER_STATE[HEADER_STATE["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE";
|
|
HEADER_STATE[HEADER_STATE["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE";
|
|
HEADER_STATE[HEADER_STATE["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED";
|
|
})(HEADER_STATE = exports.HEADER_STATE || (exports.HEADER_STATE = {}));
|
|
exports.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,
|
|
};
|
|
//# sourceMappingURL=constants.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3870:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { Buffer } = __nccwpck_require__(4573)
|
|
|
|
module.exports = Buffer.from('AGFzbQEAAAABJwdgAX8Bf2ADf39/AX9gAX8AYAJ/fwBgBH9/f38Bf2AAAGADf39/AALLAQgDZW52GHdhc21fb25faGVhZGVyc19jb21wbGV0ZQAEA2VudhV3YXNtX29uX21lc3NhZ2VfYmVnaW4AAANlbnYLd2FzbV9vbl91cmwAAQNlbnYOd2FzbV9vbl9zdGF0dXMAAQNlbnYUd2FzbV9vbl9oZWFkZXJfZmllbGQAAQNlbnYUd2FzbV9vbl9oZWFkZXJfdmFsdWUAAQNlbnYMd2FzbV9vbl9ib2R5AAEDZW52GHdhc21fb25fbWVzc2FnZV9jb21wbGV0ZQAAAy0sBQYAAAIAAAAAAAACAQIAAgICAAADAAAAAAMDAwMBAQEBAQEBAQEAAAIAAAAEBQFwARISBQMBAAIGCAF/AUGA1AQLB9EFIgZtZW1vcnkCAAtfaW5pdGlhbGl6ZQAIGV9faW5kaXJlY3RfZnVuY3Rpb25fdGFibGUBAAtsbGh0dHBfaW5pdAAJGGxsaHR0cF9zaG91bGRfa2VlcF9hbGl2ZQAvDGxsaHR0cF9hbGxvYwALBm1hbGxvYwAxC2xsaHR0cF9mcmVlAAwEZnJlZQAMD2xsaHR0cF9nZXRfdHlwZQANFWxsaHR0cF9nZXRfaHR0cF9tYWpvcgAOFWxsaHR0cF9nZXRfaHR0cF9taW5vcgAPEWxsaHR0cF9nZXRfbWV0aG9kABAWbGxodHRwX2dldF9zdGF0dXNfY29kZQAREmxsaHR0cF9nZXRfdXBncmFkZQASDGxsaHR0cF9yZXNldAATDmxsaHR0cF9leGVjdXRlABQUbGxodHRwX3NldHRpbmdzX2luaXQAFQ1sbGh0dHBfZmluaXNoABYMbGxodHRwX3BhdXNlABcNbGxodHRwX3Jlc3VtZQAYG2xsaHR0cF9yZXN1bWVfYWZ0ZXJfdXBncmFkZQAZEGxsaHR0cF9nZXRfZXJybm8AGhdsbGh0dHBfZ2V0X2Vycm9yX3JlYXNvbgAbF2xsaHR0cF9zZXRfZXJyb3JfcmVhc29uABwUbGxodHRwX2dldF9lcnJvcl9wb3MAHRFsbGh0dHBfZXJybm9fbmFtZQAeEmxsaHR0cF9tZXRob2RfbmFtZQAfEmxsaHR0cF9zdGF0dXNfbmFtZQAgGmxsaHR0cF9zZXRfbGVuaWVudF9oZWFkZXJzACEhbGxodHRwX3NldF9sZW5pZW50X2NodW5rZWRfbGVuZ3RoACIdbGxodHRwX3NldF9sZW5pZW50X2tlZXBfYWxpdmUAIyRsbGh0dHBfc2V0X2xlbmllbnRfdHJhbnNmZXJfZW5jb2RpbmcAJBhsbGh0dHBfbWVzc2FnZV9uZWVkc19lb2YALgkXAQBBAQsRAQIDBAUKBgcrLSwqKSglJyYK07MCLBYAQYjQACgCAARAAAtBiNAAQQE2AgALFAAgABAwIAAgAjYCOCAAIAE6ACgLFAAgACAALwEyIAAtAC4gABAvEAALHgEBf0HAABAyIgEQMCABQYAINgI4IAEgADoAKCABC48MAQd/AkAgAEUNACAAQQhrIgEgAEEEaygCACIAQXhxIgRqIQUCQCAAQQFxDQAgAEEDcUUNASABIAEoAgAiAGsiAUGc0AAoAgBJDQEgACAEaiEEAkACQEGg0AAoAgAgAUcEQCAAQf8BTQRAIABBA3YhAyABKAIIIgAgASgCDCICRgRAQYzQAEGM0AAoAgBBfiADd3E2AgAMBQsgAiAANgIIIAAgAjYCDAwECyABKAIYIQYgASABKAIMIgBHBEAgACABKAIIIgI2AgggAiAANgIMDAMLIAFBFGoiAygCACICRQRAIAEoAhAiAkUNAiABQRBqIQMLA0AgAyEHIAIiAEEUaiIDKAIAIgINACAAQRBqIQMgACgCECICDQALIAdBADYCAAwCCyAFKAIEIgBBA3FBA0cNAiAFIABBfnE2AgRBlNAAIAQ2AgAgBSAENgIAIAEgBEEBcjYCBAwDC0EAIQALIAZFDQACQCABKAIcIgJBAnRBvNIAaiIDKAIAIAFGBEAgAyAANgIAIAANAUGQ0ABBkNAAKAIAQX4gAndxNgIADAILIAZBEEEUIAYoAhAgAUYbaiAANgIAIABFDQELIAAgBjYCGCABKAIQIgIEQCAAIAI2AhAgAiAANgIYCyABQRRqKAIAIgJFDQAgAEEUaiACNgIAIAIgADYCGAsgASAFTw0AIAUoAgQiAEEBcUUNAAJAAkACQAJAIABBAnFFBEBBpNAAKAIAIAVGBEBBpNAAIAE2AgBBmNAAQZjQACgCACAEaiIANgIAIAEgAEEBcjYCBCABQaDQACgCAEcNBkGU0ABBADYCAEGg0ABBADYCAAwGC0Gg0AAoAgAgBUYEQEGg0AAgATYCAEGU0ABBlNAAKAIAIARqIgA2AgAgASAAQQFyNgIEIAAgAWogADYCAAwGCyAAQXhxIARqIQQgAEH/AU0EQCAAQQN2IQMgBSgCCCIAIAUoAgwiAkYEQEGM0ABBjNAAKAIAQX4gA3dxNgIADAULIAIgADYCCCAAIAI2AgwMBAsgBSgCGCEGIAUgBSgCDCIARwRAQZzQACgCABogACAFKAIIIgI2AgggAiAANgIMDAMLIAVBFGoiAygCACICRQRAIAUoAhAiAkUNAiAFQRBqIQMLA0AgAyEHIAIiAEEUaiIDKAIAIgINACAAQRBqIQMgACgCECICDQALIAdBADYCAAwCCyAFIABBfnE2AgQgASAEaiAENgIAIAEgBEEBcjYCBAwDC0EAIQALIAZFDQACQCAFKAIcIgJBAnRBvNIAaiIDKAIAIAVGBEAgAyAANgIAIAANAUGQ0ABBkNAAKAIAQX4gAndxNgIADAILIAZBEEEUIAYoAhAgBUYbaiAANgIAIABFDQELIAAgBjYCGCAFKAIQIgIEQCAAIAI2AhAgAiAANgIYCyAFQRRqKAIAIgJFDQAgAEEUaiACNgIAIAIgADYCGAsgASAEaiAENgIAIAEgBEEBcjYCBCABQaDQACgCAEcNAEGU0AAgBDYCAAwBCyAEQf8BTQRAIARBeHFBtNAAaiEAAn9BjNAAKAIAIgJBASAEQQN2dCIDcUUEQEGM0AAgAiADcjYCACAADAELIAAoAggLIgIgATYCDCAAIAE2AgggASAANgIMIAEgAjYCCAwBC0EfIQIgBEH///8HTQRAIARBJiAEQQh2ZyIAa3ZBAXEgAEEBdGtBPmohAgsgASACNgIcIAFCADcCECACQQJ0QbzSAGohAAJAQZDQACgCACIDQQEgAnQiB3FFBEAgACABNgIAQZDQACADIAdyNgIAIAEgADYCGCABIAE2AgggASABNgIMDAELIARBGSACQQF2a0EAIAJBH0cbdCECIAAoAgAhAAJAA0AgACIDKAIEQXhxIARGDQEgAkEddiEAIAJBAXQhAiADIABBBHFqQRBqIgcoAgAiAA0ACyAHIAE2AgAgASADNgIYIAEgATYCDCABIAE2AggMAQsgAygCCCIAIAE2AgwgAyABNgIIIAFBADYCGCABIAM2AgwgASAANgIIC0Gs0ABBrNAAKAIAQQFrIgBBfyAAGzYCAAsLBwAgAC0AKAsHACAALQAqCwcAIAAtACsLBwAgAC0AKQsHACAALwEyCwcAIAAtAC4LQAEEfyAAKAIYIQEgAC0ALSECIAAtACghAyAAKAI4IQQgABAwIAAgBDYCOCAAIAM6ACggACACOgAtIAAgATYCGAu74gECB38DfiABIAJqIQQCQCAAIgIoAgwiAA0AIAIoAgQEQCACIAE2AgQLIwBBEGsiCCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAIoAhwiA0EBaw7dAdoBAdkBAgMEBQYHCAkKCwwNDtgBDxDXARES1gETFBUWFxgZGhvgAd8BHB0e1QEfICEiIyQl1AEmJygpKiss0wHSAS0u0QHQAS8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRtsBR0hJSs8BzgFLzQFMzAFNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AAYEBggGDAYQBhQGGAYcBiAGJAYoBiwGMAY0BjgGPAZABkQGSAZMBlAGVAZYBlwGYAZkBmgGbAZwBnQGeAZ8BoAGhAaIBowGkAaUBpgGnAagBqQGqAasBrAGtAa4BrwGwAbEBsgGzAbQBtQG2AbcBywHKAbgByQG5AcgBugG7AbwBvQG+Ab8BwAHBAcIBwwHEAcUBxgEA3AELQQAMxgELQQ4MxQELQQ0MxAELQQ8MwwELQRAMwgELQRMMwQELQRQMwAELQRUMvwELQRYMvgELQRgMvQELQRkMvAELQRoMuwELQRsMugELQRwMuQELQR0MuAELQQgMtwELQR4MtgELQSAMtQELQR8MtAELQQcMswELQSEMsgELQSIMsQELQSMMsAELQSQMrwELQRIMrgELQREMrQELQSUMrAELQSYMqwELQScMqgELQSgMqQELQcMBDKgBC0EqDKcBC0ErDKYBC0EsDKUBC0EtDKQBC0EuDKMBC0EvDKIBC0HEAQyhAQtBMAygAQtBNAyfAQtBDAyeAQtBMQydAQtBMgycAQtBMwybAQtBOQyaAQtBNQyZAQtBxQEMmAELQQsMlwELQToMlgELQTYMlQELQQoMlAELQTcMkwELQTgMkgELQTwMkQELQTsMkAELQT0MjwELQQkMjgELQSkMjQELQT4MjAELQT8MiwELQcAADIoBC0HBAAyJAQtBwgAMiAELQcMADIcBC0HEAAyGAQtBxQAMhQELQcYADIQBC0EXDIMBC0HHAAyCAQtByAAMgQELQckADIABC0HKAAx/C0HLAAx+C0HNAAx9C0HMAAx8C0HOAAx7C0HPAAx6C0HQAAx5C0HRAAx4C0HSAAx3C0HTAAx2C0HUAAx1C0HWAAx0C0HVAAxzC0EGDHILQdcADHELQQUMcAtB2AAMbwtBBAxuC0HZAAxtC0HaAAxsC0HbAAxrC0HcAAxqC0EDDGkLQd0ADGgLQd4ADGcLQd8ADGYLQeEADGULQeAADGQLQeIADGMLQeMADGILQQIMYQtB5AAMYAtB5QAMXwtB5gAMXgtB5wAMXQtB6AAMXAtB6QAMWwtB6gAMWgtB6wAMWQtB7AAMWAtB7QAMVwtB7gAMVgtB7wAMVQtB8AAMVAtB8QAMUwtB8gAMUgtB8wAMUQtB9AAMUAtB9QAMTwtB9gAMTgtB9wAMTQtB+AAMTAtB+QAMSwtB+gAMSgtB+wAMSQtB/AAMSAtB/QAMRwtB/gAMRgtB/wAMRQtBgAEMRAtBgQEMQwtBggEMQgtBgwEMQQtBhAEMQAtBhQEMPwtBhgEMPgtBhwEMPQtBiAEMPAtBiQEMOwtBigEMOgtBiwEMOQtBjAEMOAtBjQEMNwtBjgEMNgtBjwEMNQtBkAEMNAtBkQEMMwtBkgEMMgtBkwEMMQtBlAEMMAtBlQEMLwtBlgEMLgtBlwEMLQtBmAEMLAtBmQEMKwtBmgEMKgtBmwEMKQtBnAEMKAtBnQEMJwtBngEMJgtBnwEMJQtBoAEMJAtBoQEMIwtBogEMIgtBowEMIQtBpAEMIAtBpQEMHwtBpgEMHgtBpwEMHQtBqAEMHAtBqQEMGwtBqgEMGgtBqwEMGQtBrAEMGAtBrQEMFwtBrgEMFgtBAQwVC0GvAQwUC0GwAQwTC0GxAQwSC0GzAQwRC0GyAQwQC0G0AQwPC0G1AQwOC0G2AQwNC0G3AQwMC0G4AQwLC0G5AQwKC0G6AQwJC0G7AQwIC0HGAQwHC0G8AQwGC0G9AQwFC0G+AQwEC0G/AQwDC0HAAQwCC0HCAQwBC0HBAQshAwNAAkACQAJAAkACQAJAAkACQAJAIAICfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAgJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADDsYBAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHyAhIyUmKCorLC8wMTIzNDU2Nzk6Ozw9lANAQkRFRklLTk9QUVJTVFVWWFpbXF1eX2BhYmNkZWZnaGpsb3Bxc3V2eHl6e3x/gAGBAYIBgwGEAYUBhgGHAYgBiQGKAYsBjAGNAY4BjwGQAZEBkgGTAZQBlQGWAZcBmAGZAZoBmwGcAZ0BngGfAaABoQGiAaMBpAGlAaYBpwGoAakBqgGrAawBrQGuAa8BsAGxAbIBswG0AbUBtgG3AbgBuQG6AbsBvAG9Ab4BvwHAAcEBwgHDAcQBxQHGAccByAHJAcsBzAHNAc4BzwGKA4kDiAOHA4QDgwOAA/sC+gL5AvgC9wL0AvMC8gLLAsECsALZAQsgASAERw3wAkHdASEDDLMDCyABIARHDcgBQcMBIQMMsgMLIAEgBEcNe0H3ACEDDLEDCyABIARHDXBB7wAhAwywAwsgASAERw1pQeoAIQMMrwMLIAEgBEcNZUHoACEDDK4DCyABIARHDWJB5gAhAwytAwsgASAERw0aQRghAwysAwsgASAERw0VQRIhAwyrAwsgASAERw1CQcUAIQMMqgMLIAEgBEcNNEE/IQMMqQMLIAEgBEcNMkE8IQMMqAMLIAEgBEcNK0ExIQMMpwMLIAItAC5BAUYNnwMMwQILQQAhAAJAAkACQCACLQAqRQ0AIAItACtFDQAgAi8BMCIDQQJxRQ0BDAILIAIvATAiA0EBcUUNAQtBASEAIAItAChBAUYNACACLwEyIgVB5ABrQeQASQ0AIAVBzAFGDQAgBUGwAkYNACADQcAAcQ0AQQAhACADQYgEcUGABEYNACADQShxQQBHIQALIAJBADsBMCACQQA6AC8gAEUN3wIgAkIANwMgDOACC0EAIQACQCACKAI4IgNFDQAgAygCLCIDRQ0AIAIgAxEAACEACyAARQ3MASAAQRVHDd0CIAJBBDYCHCACIAE2AhQgAkGwGDYCECACQRU2AgxBACEDDKQDCyABIARGBEBBBiEDDKQDCyABQQFqIQFBACEAAkAgAigCOCIDRQ0AIAMoAlQiA0UNACACIAMRAAAhAAsgAA3ZAgwcCyACQgA3AyBBEiEDDIkDCyABIARHDRZBHSEDDKEDCyABIARHBEAgAUEBaiEBQRAhAwyIAwtBByEDDKADCyACIAIpAyAiCiAEIAFrrSILfSIMQgAgCiAMWhs3AyAgCiALWA3UAkEIIQMMnwMLIAEgBEcEQCACQQk2AgggAiABNgIEQRQhAwyGAwtBCSEDDJ4DCyACKQMgQgBSDccBIAIgAi8BMEGAAXI7ATAMQgsgASAERw0/QdAAIQMMnAMLIAEgBEYEQEELIQMMnAMLIAFBAWohAUEAIQACQCACKAI4IgNFDQAgAygCUCIDRQ0AIAIgAxEAACEACyAADc8CDMYBC0EAIQACQCACKAI4IgNFDQAgAygCSCIDRQ0AIAIgAxEAACEACyAARQ3GASAAQRVHDc0CIAJBCzYCHCACIAE2AhQgAkGCGTYCECACQRU2AgxBACEDDJoDC0EAIQACQCACKAI4IgNFDQAgAygCSCIDRQ0AIAIgAxEAACEACyAARQ0MIABBFUcNygIgAkEaNgIcIAIgATYCFCACQYIZNgIQIAJBFTYCDEEAIQMMmQMLQQAhAAJAIAIoAjgiA0UNACADKAJMIgNFDQAgAiADEQAAIQALIABFDcQBIABBFUcNxwIgAkELNgIcIAIgATYCFCACQZEXNgIQIAJBFTYCDEEAIQMMmAMLIAEgBEYEQEEPIQMMmAMLIAEtAAAiAEE7Rg0HIABBDUcNxAIgAUEBaiEBDMMBC0EAIQACQCACKAI4IgNFDQAgAygCTCIDRQ0AIAIgAxEAACEACyAARQ3DASAAQRVHDcICIAJBDzYCHCACIAE2AhQgAkGRFzYCECACQRU2AgxBACEDDJYDCwNAIAEtAABB8DVqLQAAIgBBAUcEQCAAQQJHDcECIAIoAgQhAEEAIQMgAkEANgIEIAIgACABQQFqIgEQLSIADcICDMUBCyAEIAFBAWoiAUcNAAtBEiEDDJUDC0EAIQACQCACKAI4IgNFDQAgAygCTCIDRQ0AIAIgAxEAACEACyAARQ3FASAAQRVHDb0CIAJBGzYCHCACIAE2AhQgAkGRFzYCECACQRU2AgxBACEDDJQDCyABIARGBEBBFiEDDJQDCyACQQo2AgggAiABNgIEQQAhAAJAIAIoAjgiA0UNACADKAJIIgNFDQAgAiADEQAAIQALIABFDcIBIABBFUcNuQIgAkEVNgIcIAIgATYCFCACQYIZNgIQIAJBFTYCDEEAIQMMkwMLIAEgBEcEQANAIAEtAABB8DdqLQAAIgBBAkcEQAJAIABBAWsOBMQCvQIAvgK9AgsgAUEBaiEBQQghAwz8AgsgBCABQQFqIgFHDQALQRUhAwyTAwtBFSEDDJIDCwNAIAEtAABB8DlqLQAAIgBBAkcEQCAAQQFrDgTFArcCwwK4ArcCCyAEIAFBAWoiAUcNAAtBGCEDDJEDCyABIARHBEAgAkELNgIIIAIgATYCBEEHIQMM+AILQRkhAwyQAwsgAUEBaiEBDAILIAEgBEYEQEEaIQMMjwMLAkAgAS0AAEENaw4UtQG/Ab8BvwG/Ab8BvwG/Ab8BvwG/Ab8BvwG/Ab8BvwG/Ab8BvwEAvwELQQAhAyACQQA2AhwgAkGvCzYCECACQQI2AgwgAiABQQFqNgIUDI4DCyABIARGBEBBGyEDDI4DCyABLQAAIgBBO0cEQCAAQQ1HDbECIAFBAWohAQy6AQsgAUEBaiEBC0EiIQMM8wILIAEgBEYEQEEcIQMMjAMLQgAhCgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEwaw43wQLAAgABAgMEBQYH0AHQAdAB0AHQAdAB0AEICQoLDA3QAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdABDg8QERIT0AELQgIhCgzAAgtCAyEKDL8CC0IEIQoMvgILQgUhCgy9AgtCBiEKDLwCC0IHIQoMuwILQgghCgy6AgtCCSEKDLkCC0IKIQoMuAILQgshCgy3AgtCDCEKDLYCC0INIQoMtQILQg4hCgy0AgtCDyEKDLMCC0IKIQoMsgILQgshCgyxAgtCDCEKDLACC0INIQoMrwILQg4hCgyuAgtCDyEKDK0CC0IAIQoCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBMGsON8ACvwIAAQIDBAUGB74CvgK+Ar4CvgK+Ar4CCAkKCwwNvgK+Ar4CvgK+Ar4CvgK+Ar4CvgK+Ar4CvgK+Ar4CvgK+Ar4CvgK+Ar4CvgK+Ar4CvgK+Ag4PEBESE74CC0ICIQoMvwILQgMhCgy+AgtCBCEKDL0CC0IFIQoMvAILQgYhCgy7AgtCByEKDLoCC0IIIQoMuQILQgkhCgy4AgtCCiEKDLcCC0ILIQoMtgILQgwhCgy1AgtCDSEKDLQCC0IOIQoMswILQg8hCgyyAgtCCiEKDLECC0ILIQoMsAILQgwhCgyvAgtCDSEKDK4CC0IOIQoMrQILQg8hCgysAgsgAiACKQMgIgogBCABa60iC30iDEIAIAogDFobNwMgIAogC1gNpwJBHyEDDIkDCyABIARHBEAgAkEJNgIIIAIgATYCBEElIQMM8AILQSAhAwyIAwtBASEFIAIvATAiA0EIcUUEQCACKQMgQgBSIQULAkAgAi0ALgRAQQEhACACLQApQQVGDQEgA0HAAHFFIAVxRQ0BC0EAIQAgA0HAAHENAEECIQAgA0EIcQ0AIANBgARxBEACQCACLQAoQQFHDQAgAi0ALUEKcQ0AQQUhAAwCC0EEIQAMAQsgA0EgcUUEQAJAIAItAChBAUYNACACLwEyIgBB5ABrQeQASQ0AIABBzAFGDQAgAEGwAkYNAEEEIQAgA0EocUUNAiADQYgEcUGABEYNAgtBACEADAELQQBBAyACKQMgUBshAAsgAEEBaw4FvgIAsAEBpAKhAgtBESEDDO0CCyACQQE6AC8MhAMLIAEgBEcNnQJBJCEDDIQDCyABIARHDRxBxgAhAwyDAwtBACEAAkAgAigCOCIDRQ0AIAMoAkQiA0UNACACIAMRAAAhAAsgAEUNJyAAQRVHDZgCIAJB0AA2AhwgAiABNgIUIAJBkRg2AhAgAkEVNgIMQQAhAwyCAwsgASAERgRAQSghAwyCAwtBACEDIAJBADYCBCACQQw2AgggAiABIAEQKiIARQ2UAiACQSc2AhwgAiABNgIUIAIgADYCDAyBAwsgASAERgRAQSkhAwyBAwsgAS0AACIAQSBGDRMgAEEJRw2VAiABQQFqIQEMFAsgASAERwRAIAFBAWohAQwWC0EqIQMM/wILIAEgBEYEQEErIQMM/wILIAEtAAAiAEEJRyAAQSBHcQ2QAiACLQAsQQhHDd0CIAJBADoALAzdAgsgASAERgRAQSwhAwz+AgsgAS0AAEEKRw2OAiABQQFqIQEMsAELIAEgBEcNigJBLyEDDPwCCwNAIAEtAAAiAEEgRwRAIABBCmsOBIQCiAKIAoQChgILIAQgAUEBaiIBRw0AC0ExIQMM+wILQTIhAyABIARGDfoCIAIoAgAiACAEIAFraiEHIAEgAGtBA2ohBgJAA0AgAEHwO2otAAAgAS0AACIFQSByIAUgBUHBAGtB/wFxQRpJG0H/AXFHDQEgAEEDRgRAQQYhAQziAgsgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAc2AgAM+wILIAJBADYCAAyGAgtBMyEDIAQgASIARg35AiAEIAFrIAIoAgAiAWohByAAIAFrQQhqIQYCQANAIAFB9DtqLQAAIAAtAAAiBUEgciAFIAVBwQBrQf8BcUEaSRtB/wFxRw0BIAFBCEYEQEEFIQEM4QILIAFBAWohASAEIABBAWoiAEcNAAsgAiAHNgIADPoCCyACQQA2AgAgACEBDIUCC0E0IQMgBCABIgBGDfgCIAQgAWsgAigCACIBaiEHIAAgAWtBBWohBgJAA0AgAUHQwgBqLQAAIAAtAAAiBUEgciAFIAVBwQBrQf8BcUEaSRtB/wFxRw0BIAFBBUYEQEEHIQEM4AILIAFBAWohASAEIABBAWoiAEcNAAsgAiAHNgIADPkCCyACQQA2AgAgACEBDIQCCyABIARHBEADQCABLQAAQYA+ai0AACIAQQFHBEAgAEECRg0JDIECCyAEIAFBAWoiAUcNAAtBMCEDDPgCC0EwIQMM9wILIAEgBEcEQANAIAEtAAAiAEEgRwRAIABBCmsOBP8B/gH+Af8B/gELIAQgAUEBaiIBRw0AC0E4IQMM9wILQTghAwz2AgsDQCABLQAAIgBBIEcgAEEJR3EN9gEgBCABQQFqIgFHDQALQTwhAwz1AgsDQCABLQAAIgBBIEcEQAJAIABBCmsOBPkBBAT5AQALIABBLEYN9QEMAwsgBCABQQFqIgFHDQALQT8hAwz0AgtBwAAhAyABIARGDfMCIAIoAgAiACAEIAFraiEFIAEgAGtBBmohBgJAA0AgAEGAQGstAAAgAS0AAEEgckcNASAAQQZGDdsCIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADPQCCyACQQA2AgALQTYhAwzZAgsgASAERgRAQcEAIQMM8gILIAJBDDYCCCACIAE2AgQgAi0ALEEBaw4E+wHuAewB6wHUAgsgAUEBaiEBDPoBCyABIARHBEADQAJAIAEtAAAiAEEgciAAIABBwQBrQf8BcUEaSRtB/wFxIgBBCUYNACAAQSBGDQACQAJAAkACQCAAQeMAaw4TAAMDAwMDAwMBAwMDAwMDAwMDAgMLIAFBAWohAUExIQMM3AILIAFBAWohAUEyIQMM2wILIAFBAWohAUEzIQMM2gILDP4BCyAEIAFBAWoiAUcNAAtBNSEDDPACC0E1IQMM7wILIAEgBEcEQANAIAEtAABBgDxqLQAAQQFHDfcBIAQgAUEBaiIBRw0AC0E9IQMM7wILQT0hAwzuAgtBACEAAkAgAigCOCIDRQ0AIAMoAkAiA0UNACACIAMRAAAhAAsgAEUNASAAQRVHDeYBIAJBwgA2AhwgAiABNgIUIAJB4xg2AhAgAkEVNgIMQQAhAwztAgsgAUEBaiEBC0E8IQMM0gILIAEgBEYEQEHCACEDDOsCCwJAA0ACQCABLQAAQQlrDhgAAswCzALRAswCzALMAswCzALMAswCzALMAswCzALMAswCzALMAswCzALMAgDMAgsgBCABQQFqIgFHDQALQcIAIQMM6wILIAFBAWohASACLQAtQQFxRQ3+AQtBLCEDDNACCyABIARHDd4BQcQAIQMM6AILA0AgAS0AAEGQwABqLQAAQQFHDZwBIAQgAUEBaiIBRw0AC0HFACEDDOcCCyABLQAAIgBBIEYN/gEgAEE6Rw3AAiACKAIEIQBBACEDIAJBADYCBCACIAAgARApIgAN3gEM3QELQccAIQMgBCABIgBGDeUCIAQgAWsgAigCACIBaiEHIAAgAWtBBWohBgNAIAFBkMIAai0AACAALQAAIgVBIHIgBSAFQcEAa0H/AXFBGkkbQf8BcUcNvwIgAUEFRg3CAiABQQFqIQEgBCAAQQFqIgBHDQALIAIgBzYCAAzlAgtByAAhAyAEIAEiAEYN5AIgBCABayACKAIAIgFqIQcgACABa0EJaiEGA0AgAUGWwgBqLQAAIAAtAAAiBUEgciAFIAVBwQBrQf8BcUEaSRtB/wFxRw2+AkECIAFBCUYNwgIaIAFBAWohASAEIABBAWoiAEcNAAsgAiAHNgIADOQCCyABIARGBEBByQAhAwzkAgsCQAJAIAEtAAAiAEEgciAAIABBwQBrQf8BcUEaSRtB/wFxQe4Aaw4HAL8CvwK/Ar8CvwIBvwILIAFBAWohAUE+IQMMywILIAFBAWohAUE/IQMMygILQcoAIQMgBCABIgBGDeICIAQgAWsgAigCACIBaiEGIAAgAWtBAWohBwNAIAFBoMIAai0AACAALQAAIgVBIHIgBSAFQcEAa0H/AXFBGkkbQf8BcUcNvAIgAUEBRg2+AiABQQFqIQEgBCAAQQFqIgBHDQALIAIgBjYCAAziAgtBywAhAyAEIAEiAEYN4QIgBCABayACKAIAIgFqIQcgACABa0EOaiEGA0AgAUGiwgBqLQAAIAAtAAAiBUEgciAFIAVBwQBrQf8BcUEaSRtB/wFxRw27AiABQQ5GDb4CIAFBAWohASAEIABBAWoiAEcNAAsgAiAHNgIADOECC0HMACEDIAQgASIARg3gAiAEIAFrIAIoAgAiAWohByAAIAFrQQ9qIQYDQCABQcDCAGotAAAgAC0AACIFQSByIAUgBUHBAGtB/wFxQRpJG0H/AXFHDboCQQMgAUEPRg2+AhogAUEBaiEBIAQgAEEBaiIARw0ACyACIAc2AgAM4AILQc0AIQMgBCABIgBGDd8CIAQgAWsgAigCACIBaiEHIAAgAWtBBWohBgNAIAFB0MIAai0AACAALQAAIgVBIHIgBSAFQcEAa0H/AXFBGkkbQf8BcUcNuQJBBCABQQVGDb0CGiABQQFqIQEgBCAAQQFqIgBHDQALIAIgBzYCAAzfAgsgASAERgRAQc4AIQMM3wILAkACQAJAAkAgAS0AACIAQSByIAAgAEHBAGtB/wFxQRpJG0H/AXFB4wBrDhMAvAK8ArwCvAK8ArwCvAK8ArwCvAK8ArwCAbwCvAK8AgIDvAILIAFBAWohAUHBACEDDMgCCyABQQFqIQFBwgAhAwzHAgsgAUEBaiEBQcMAIQMMxgILIAFBAWohAUHEACEDDMUCCyABIARHBEAgAkENNgIIIAIgATYCBEHFACEDDMUCC0HPACEDDN0CCwJAAkAgAS0AAEEKaw4EAZABkAEAkAELIAFBAWohAQtBKCEDDMMCCyABIARGBEBB0QAhAwzcAgsgAS0AAEEgRw0AIAFBAWohASACLQAtQQFxRQ3QAQtBFyEDDMECCyABIARHDcsBQdIAIQMM2QILQdMAIQMgASAERg3YAiACKAIAIgAgBCABa2ohBiABIABrQQFqIQUDQCABLQAAIABB1sIAai0AAEcNxwEgAEEBRg3KASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBjYCAAzYAgsgASAERgRAQdUAIQMM2AILIAEtAABBCkcNwgEgAUEBaiEBDMoBCyABIARGBEBB1gAhAwzXAgsCQAJAIAEtAABBCmsOBADDAcMBAcMBCyABQQFqIQEMygELIAFBAWohAUHKACEDDL0CC0EAIQACQCACKAI4IgNFDQAgAygCPCIDRQ0AIAIgAxEAACEACyAADb8BQc0AIQMMvAILIAItAClBIkYNzwIMiQELIAQgASIFRgRAQdsAIQMM1AILQQAhAEEBIQFBASEGQQAhAwJAAn8CQAJAAkACQAJAAkACQCAFLQAAQTBrDgrFAcQBAAECAwQFBgjDAQtBAgwGC0EDDAULQQQMBAtBBQwDC0EGDAILQQcMAQtBCAshA0EAIQFBACEGDL0BC0EJIQNBASEAQQAhAUEAIQYMvAELIAEgBEYEQEHdACEDDNMCCyABLQAAQS5HDbgBIAFBAWohAQyIAQsgASAERw22AUHfACEDDNECCyABIARHBEAgAkEONgIIIAIgATYCBEHQACEDDLgCC0HgACEDDNACC0HhACEDIAEgBEYNzwIgAigCACIAIAQgAWtqIQUgASAAa0EDaiEGA0AgAS0AACAAQeLCAGotAABHDbEBIABBA0YNswEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMzwILQeIAIQMgASAERg3OAiACKAIAIgAgBCABa2ohBSABIABrQQJqIQYDQCABLQAAIABB5sIAai0AAEcNsAEgAEECRg2vASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAzOAgtB4wAhAyABIARGDc0CIAIoAgAiACAEIAFraiEFIAEgAGtBA2ohBgNAIAEtAAAgAEHpwgBqLQAARw2vASAAQQNGDa0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADM0CCyABIARGBEBB5QAhAwzNAgsgAUEBaiEBQQAhAAJAIAIoAjgiA0UNACADKAIwIgNFDQAgAiADEQAAIQALIAANqgFB1gAhAwyzAgsgASAERwRAA0AgAS0AACIAQSBHBEACQAJAAkAgAEHIAGsOCwABswGzAbMBswGzAbMBswGzAQKzAQsgAUEBaiEBQdIAIQMMtwILIAFBAWohAUHTACEDDLYCCyABQQFqIQFB1AAhAwy1AgsgBCABQQFqIgFHDQALQeQAIQMMzAILQeQAIQMMywILA0AgAS0AAEHwwgBqLQAAIgBBAUcEQCAAQQJrDgOnAaYBpQGkAQsgBCABQQFqIgFHDQALQeYAIQMMygILIAFBAWogASAERw0CGkHnACEDDMkCCwNAIAEtAABB8MQAai0AACIAQQFHBEACQCAAQQJrDgSiAaEBoAEAnwELQdcAIQMMsQILIAQgAUEBaiIBRw0AC0HoACEDDMgCCyABIARGBEBB6QAhAwzIAgsCQCABLQAAIgBBCmsOGrcBmwGbAbQBmwGbAZsBmwGbAZsBmwGbAZsBmwGbAZsBmwGbAZsBmwGbAZsBpAGbAZsBAJkBCyABQQFqCyEBQQYhAwytAgsDQCABLQAAQfDGAGotAABBAUcNfSAEIAFBAWoiAUcNAAtB6gAhAwzFAgsgAUEBaiABIARHDQIaQesAIQMMxAILIAEgBEYEQEHsACEDDMQCCyABQQFqDAELIAEgBEYEQEHtACEDDMMCCyABQQFqCyEBQQQhAwyoAgsgASAERgRAQe4AIQMMwQILAkACQAJAIAEtAABB8MgAai0AAEEBaw4HkAGPAY4BAHwBAo0BCyABQQFqIQEMCwsgAUEBagyTAQtBACEDIAJBADYCHCACQZsSNgIQIAJBBzYCDCACIAFBAWo2AhQMwAILAkADQCABLQAAQfDIAGotAAAiAEEERwRAAkACQCAAQQFrDgeUAZMBkgGNAQAEAY0BC0HaACEDDKoCCyABQQFqIQFB3AAhAwypAgsgBCABQQFqIgFHDQALQe8AIQMMwAILIAFBAWoMkQELIAQgASIARgRAQfAAIQMMvwILIAAtAABBL0cNASAAQQFqIQEMBwsgBCABIgBGBEBB8QAhAwy+AgsgAC0AACIBQS9GBEAgAEEBaiEBQd0AIQMMpQILIAFBCmsiA0EWSw0AIAAhAUEBIAN0QYmAgAJxDfkBC0EAIQMgAkEANgIcIAIgADYCFCACQYwcNgIQIAJBBzYCDAy8AgsgASAERwRAIAFBAWohAUHeACEDDKMCC0HyACEDDLsCCyABIARGBEBB9AAhAwy7AgsCQCABLQAAQfDMAGotAABBAWsOA/cBcwCCAQtB4QAhAwyhAgsgASAERwRAA0AgAS0AAEHwygBqLQAAIgBBA0cEQAJAIABBAWsOAvkBAIUBC0HfACEDDKMCCyAEIAFBAWoiAUcNAAtB8wAhAwy6AgtB8wAhAwy5AgsgASAERwRAIAJBDzYCCCACIAE2AgRB4AAhAwygAgtB9QAhAwy4AgsgASAERgRAQfYAIQMMuAILIAJBDzYCCCACIAE2AgQLQQMhAwydAgsDQCABLQAAQSBHDY4CIAQgAUEBaiIBRw0AC0H3ACEDDLUCCyABIARGBEBB+AAhAwy1AgsgAS0AAEEgRw16IAFBAWohAQxbC0EAIQACQCACKAI4IgNFDQAgAygCOCIDRQ0AIAIgAxEAACEACyAADXgMgAILIAEgBEYEQEH6ACEDDLMCCyABLQAAQcwARw10IAFBAWohAUETDHYLQfsAIQMgASAERg2xAiACKAIAIgAgBCABa2ohBSABIABrQQVqIQYDQCABLQAAIABB8M4Aai0AAEcNcyAAQQVGDXUgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMsQILIAEgBEYEQEH8ACEDDLECCwJAAkAgAS0AAEHDAGsODAB0dHR0dHR0dHR0AXQLIAFBAWohAUHmACEDDJgCCyABQQFqIQFB5wAhAwyXAgtB/QAhAyABIARGDa8CIAIoAgAiACAEIAFraiEFIAEgAGtBAmohBgJAA0AgAS0AACAAQe3PAGotAABHDXIgAEECRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADLACCyACQQA2AgAgBkEBaiEBQRAMcwtB/gAhAyABIARGDa4CIAIoAgAiACAEIAFraiEFIAEgAGtBBWohBgJAA0AgAS0AACAAQfbOAGotAABHDXEgAEEFRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADK8CCyACQQA2AgAgBkEBaiEBQRYMcgtB/wAhAyABIARGDa0CIAIoAgAiACAEIAFraiEFIAEgAGtBA2ohBgJAA0AgAS0AACAAQfzOAGotAABHDXAgAEEDRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADK4CCyACQQA2AgAgBkEBaiEBQQUMcQsgASAERgRAQYABIQMMrQILIAEtAABB2QBHDW4gAUEBaiEBQQgMcAsgASAERgRAQYEBIQMMrAILAkACQCABLQAAQc4Aaw4DAG8BbwsgAUEBaiEBQesAIQMMkwILIAFBAWohAUHsACEDDJICCyABIARGBEBBggEhAwyrAgsCQAJAIAEtAABByABrDggAbm5ubm5uAW4LIAFBAWohAUHqACEDDJICCyABQQFqIQFB7QAhAwyRAgtBgwEhAyABIARGDakCIAIoAgAiACAEIAFraiEFIAEgAGtBAmohBgJAA0AgAS0AACAAQYDPAGotAABHDWwgAEECRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADKoCCyACQQA2AgAgBkEBaiEBQQAMbQtBhAEhAyABIARGDagCIAIoAgAiACAEIAFraiEFIAEgAGtBBGohBgJAA0AgAS0AACAAQYPPAGotAABHDWsgAEEERg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADKkCCyACQQA2AgAgBkEBaiEBQSMMbAsgASAERgRAQYUBIQMMqAILAkACQCABLQAAQcwAaw4IAGtra2trawFrCyABQQFqIQFB7wAhAwyPAgsgAUEBaiEBQfAAIQMMjgILIAEgBEYEQEGGASEDDKcCCyABLQAAQcUARw1oIAFBAWohAQxgC0GHASEDIAEgBEYNpQIgAigCACIAIAQgAWtqIQUgASAAa0EDaiEGAkADQCABLQAAIABBiM8Aai0AAEcNaCAAQQNGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMpgILIAJBADYCACAGQQFqIQFBLQxpC0GIASEDIAEgBEYNpAIgAigCACIAIAQgAWtqIQUgASAAa0EIaiEGAkADQCABLQAAIABB0M8Aai0AAEcNZyAAQQhGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMpQILIAJBADYCACAGQQFqIQFBKQxoCyABIARGBEBBiQEhAwykAgtBASABLQAAQd8ARw1nGiABQQFqIQEMXgtBigEhAyABIARGDaICIAIoAgAiACAEIAFraiEFIAEgAGtBAWohBgNAIAEtAAAgAEGMzwBqLQAARw1kIABBAUYN+gEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMogILQYsBIQMgASAERg2hAiACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEGOzwBqLQAARw1kIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyiAgsgAkEANgIAIAZBAWohAUECDGULQYwBIQMgASAERg2gAiACKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEHwzwBqLQAARw1jIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyhAgsgAkEANgIAIAZBAWohAUEfDGQLQY0BIQMgASAERg2fAiACKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEHyzwBqLQAARw1iIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAygAgsgAkEANgIAIAZBAWohAUEJDGMLIAEgBEYEQEGOASEDDJ8CCwJAAkAgAS0AAEHJAGsOBwBiYmJiYgFiCyABQQFqIQFB+AAhAwyGAgsgAUEBaiEBQfkAIQMMhQILQY8BIQMgASAERg2dAiACKAIAIgAgBCABa2ohBSABIABrQQVqIQYCQANAIAEtAAAgAEGRzwBqLQAARw1gIABBBUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyeAgsgAkEANgIAIAZBAWohAUEYDGELQZABIQMgASAERg2cAiACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEGXzwBqLQAARw1fIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAydAgsgAkEANgIAIAZBAWohAUEXDGALQZEBIQMgASAERg2bAiACKAIAIgAgBCABa2ohBSABIABrQQZqIQYCQANAIAEtAAAgAEGazwBqLQAARw1eIABBBkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAycAgsgAkEANgIAIAZBAWohAUEVDF8LQZIBIQMgASAERg2aAiACKAIAIgAgBCABa2ohBSABIABrQQVqIQYCQANAIAEtAAAgAEGhzwBqLQAARw1dIABBBUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAybAgsgAkEANgIAIAZBAWohAUEeDF4LIAEgBEYEQEGTASEDDJoCCyABLQAAQcwARw1bIAFBAWohAUEKDF0LIAEgBEYEQEGUASEDDJkCCwJAAkAgAS0AAEHBAGsODwBcXFxcXFxcXFxcXFxcAVwLIAFBAWohAUH+ACEDDIACCyABQQFqIQFB/wAhAwz/AQsgASAERgRAQZUBIQMMmAILAkACQCABLQAAQcEAaw4DAFsBWwsgAUEBaiEBQf0AIQMM/wELIAFBAWohAUGAASEDDP4BC0GWASEDIAEgBEYNlgIgAigCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABBp88Aai0AAEcNWSAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMlwILIAJBADYCACAGQQFqIQFBCwxaCyABIARGBEBBlwEhAwyWAgsCQAJAAkACQCABLQAAQS1rDiMAW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1sBW1tbW1sCW1tbA1sLIAFBAWohAUH7ACEDDP8BCyABQQFqIQFB/AAhAwz+AQsgAUEBaiEBQYEBIQMM/QELIAFBAWohAUGCASEDDPwBC0GYASEDIAEgBEYNlAIgAigCACIAIAQgAWtqIQUgASAAa0EEaiEGAkADQCABLQAAIABBqc8Aai0AAEcNVyAAQQRGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMlQILIAJBADYCACAGQQFqIQFBGQxYC0GZASEDIAEgBEYNkwIgAigCACIAIAQgAWtqIQUgASAAa0EFaiEGAkADQCABLQAAIABBrs8Aai0AAEcNViAAQQVGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMlAILIAJBADYCACAGQQFqIQFBBgxXC0GaASEDIAEgBEYNkgIgAigCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABBtM8Aai0AAEcNVSAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMkwILIAJBADYCACAGQQFqIQFBHAxWC0GbASEDIAEgBEYNkQIgAigCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABBts8Aai0AAEcNVCAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMkgILIAJBADYCACAGQQFqIQFBJwxVCyABIARGBEBBnAEhAwyRAgsCQAJAIAEtAABB1ABrDgIAAVQLIAFBAWohAUGGASEDDPgBCyABQQFqIQFBhwEhAwz3AQtBnQEhAyABIARGDY8CIAIoAgAiACAEIAFraiEFIAEgAGtBAWohBgJAA0AgAS0AACAAQbjPAGotAABHDVIgAEEBRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADJACCyACQQA2AgAgBkEBaiEBQSYMUwtBngEhAyABIARGDY4CIAIoAgAiACAEIAFraiEFIAEgAGtBAWohBgJAA0AgAS0AACAAQbrPAGotAABHDVEgAEEBRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADI8CCyACQQA2AgAgBkEBaiEBQQMMUgtBnwEhAyABIARGDY0CIAIoAgAiACAEIAFraiEFIAEgAGtBAmohBgJAA0AgAS0AACAAQe3PAGotAABHDVAgAEECRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADI4CCyACQQA2AgAgBkEBaiEBQQwMUQtBoAEhAyABIARGDYwCIAIoAgAiACAEIAFraiEFIAEgAGtBA2ohBgJAA0AgAS0AACAAQbzPAGotAABHDU8gAEEDRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADI0CCyACQQA2AgAgBkEBaiEBQQ0MUAsgASAERgRAQaEBIQMMjAILAkACQCABLQAAQcYAaw4LAE9PT09PT09PTwFPCyABQQFqIQFBiwEhAwzzAQsgAUEBaiEBQYwBIQMM8gELIAEgBEYEQEGiASEDDIsCCyABLQAAQdAARw1MIAFBAWohAQxGCyABIARGBEBBowEhAwyKAgsCQAJAIAEtAABByQBrDgcBTU1NTU0ATQsgAUEBaiEBQY4BIQMM8QELIAFBAWohAUEiDE0LQaQBIQMgASAERg2IAiACKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEHAzwBqLQAARw1LIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyJAgsgAkEANgIAIAZBAWohAUEdDEwLIAEgBEYEQEGlASEDDIgCCwJAAkAgAS0AAEHSAGsOAwBLAUsLIAFBAWohAUGQASEDDO8BCyABQQFqIQFBBAxLCyABIARGBEBBpgEhAwyHAgsCQAJAAkACQAJAIAEtAABBwQBrDhUATU1NTU1NTU1NTQFNTQJNTQNNTQRNCyABQQFqIQFBiAEhAwzxAQsgAUEBaiEBQYkBIQMM8AELIAFBAWohAUGKASEDDO8BCyABQQFqIQFBjwEhAwzuAQsgAUEBaiEBQZEBIQMM7QELQacBIQMgASAERg2FAiACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEHtzwBqLQAARw1IIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyGAgsgAkEANgIAIAZBAWohAUERDEkLQagBIQMgASAERg2EAiACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEHCzwBqLQAARw1HIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyFAgsgAkEANgIAIAZBAWohAUEsDEgLQakBIQMgASAERg2DAiACKAIAIgAgBCABa2ohBSABIABrQQRqIQYCQANAIAEtAAAgAEHFzwBqLQAARw1GIABBBEYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyEAgsgAkEANgIAIAZBAWohAUErDEcLQaoBIQMgASAERg2CAiACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEHKzwBqLQAARw1FIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyDAgsgAkEANgIAIAZBAWohAUEUDEYLIAEgBEYEQEGrASEDDIICCwJAAkACQAJAIAEtAABBwgBrDg8AAQJHR0dHR0dHR0dHRwNHCyABQQFqIQFBkwEhAwzrAQsgAUEBaiEBQZQBIQMM6gELIAFBAWohAUGVASEDDOkBCyABQQFqIQFBlgEhAwzoAQsgASAERgRAQawBIQMMgQILIAEtAABBxQBHDUIgAUEBaiEBDD0LQa0BIQMgASAERg3/ASACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEHNzwBqLQAARw1CIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyAAgsgAkEANgIAIAZBAWohAUEODEMLIAEgBEYEQEGuASEDDP8BCyABLQAAQdAARw1AIAFBAWohAUElDEILQa8BIQMgASAERg39ASACKAIAIgAgBCABa2ohBSABIABrQQhqIQYCQANAIAEtAAAgAEHQzwBqLQAARw1AIABBCEYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAz+AQsgAkEANgIAIAZBAWohAUEqDEELIAEgBEYEQEGwASEDDP0BCwJAAkAgAS0AAEHVAGsOCwBAQEBAQEBAQEABQAsgAUEBaiEBQZoBIQMM5AELIAFBAWohAUGbASEDDOMBCyABIARGBEBBsQEhAwz8AQsCQAJAIAEtAABBwQBrDhQAPz8/Pz8/Pz8/Pz8/Pz8/Pz8/AT8LIAFBAWohAUGZASEDDOMBCyABQQFqIQFBnAEhAwziAQtBsgEhAyABIARGDfoBIAIoAgAiACAEIAFraiEFIAEgAGtBA2ohBgJAA0AgAS0AACAAQdnPAGotAABHDT0gAEEDRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADPsBCyACQQA2AgAgBkEBaiEBQSEMPgtBswEhAyABIARGDfkBIAIoAgAiACAEIAFraiEFIAEgAGtBBmohBgJAA0AgAS0AACAAQd3PAGotAABHDTwgAEEGRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADPoBCyACQQA2AgAgBkEBaiEBQRoMPQsgASAERgRAQbQBIQMM+QELAkACQAJAIAEtAABBxQBrDhEAPT09PT09PT09AT09PT09Aj0LIAFBAWohAUGdASEDDOEBCyABQQFqIQFBngEhAwzgAQsgAUEBaiEBQZ8BIQMM3wELQbUBIQMgASAERg33ASACKAIAIgAgBCABa2ohBSABIABrQQVqIQYCQANAIAEtAAAgAEHkzwBqLQAARw06IABBBUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAz4AQsgAkEANgIAIAZBAWohAUEoDDsLQbYBIQMgASAERg32ASACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEHqzwBqLQAARw05IABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAz3AQsgAkEANgIAIAZBAWohAUEHDDoLIAEgBEYEQEG3ASEDDPYBCwJAAkAgAS0AAEHFAGsODgA5OTk5OTk5OTk5OTkBOQsgAUEBaiEBQaEBIQMM3QELIAFBAWohAUGiASEDDNwBC0G4ASEDIAEgBEYN9AEgAigCACIAIAQgAWtqIQUgASAAa0ECaiEGAkADQCABLQAAIABB7c8Aai0AAEcNNyAAQQJGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAM9QELIAJBADYCACAGQQFqIQFBEgw4C0G5ASEDIAEgBEYN8wEgAigCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABB8M8Aai0AAEcNNiAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAM9AELIAJBADYCACAGQQFqIQFBIAw3C0G6ASEDIAEgBEYN8gEgAigCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABB8s8Aai0AAEcNNSAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAM8wELIAJBADYCACAGQQFqIQFBDww2CyABIARGBEBBuwEhAwzyAQsCQAJAIAEtAABByQBrDgcANTU1NTUBNQsgAUEBaiEBQaUBIQMM2QELIAFBAWohAUGmASEDDNgBC0G8ASEDIAEgBEYN8AEgAigCACIAIAQgAWtqIQUgASAAa0EHaiEGAkADQCABLQAAIABB9M8Aai0AAEcNMyAAQQdGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAM8QELIAJBADYCACAGQQFqIQFBGww0CyABIARGBEBBvQEhAwzwAQsCQAJAAkAgAS0AAEHCAGsOEgA0NDQ0NDQ0NDQBNDQ0NDQ0AjQLIAFBAWohAUGkASEDDNgBCyABQQFqIQFBpwEhAwzXAQsgAUEBaiEBQagBIQMM1gELIAEgBEYEQEG+ASEDDO8BCyABLQAAQc4ARw0wIAFBAWohAQwsCyABIARGBEBBvwEhAwzuAQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQcEAaw4VAAECAz8EBQY/Pz8HCAkKCz8MDQ4PPwsgAUEBaiEBQegAIQMM4wELIAFBAWohAUHpACEDDOIBCyABQQFqIQFB7gAhAwzhAQsgAUEBaiEBQfIAIQMM4AELIAFBAWohAUHzACEDDN8BCyABQQFqIQFB9gAhAwzeAQsgAUEBaiEBQfcAIQMM3QELIAFBAWohAUH6ACEDDNwBCyABQQFqIQFBgwEhAwzbAQsgAUEBaiEBQYQBIQMM2gELIAFBAWohAUGFASEDDNkBCyABQQFqIQFBkgEhAwzYAQsgAUEBaiEBQZgBIQMM1wELIAFBAWohAUGgASEDDNYBCyABQQFqIQFBowEhAwzVAQsgAUEBaiEBQaoBIQMM1AELIAEgBEcEQCACQRA2AgggAiABNgIEQasBIQMM1AELQcABIQMM7AELQQAhAAJAIAIoAjgiA0UNACADKAI0IgNFDQAgAiADEQAAIQALIABFDV4gAEEVRw0HIAJB0QA2AhwgAiABNgIUIAJBsBc2AhAgAkEVNgIMQQAhAwzrAQsgAUEBaiABIARHDQgaQcIBIQMM6gELA0ACQCABLQAAQQprDgQIAAALAAsgBCABQQFqIgFHDQALQcMBIQMM6QELIAEgBEcEQCACQRE2AgggAiABNgIEQQEhAwzQAQtBxAEhAwzoAQsgASAERgRAQcUBIQMM6AELAkACQCABLQAAQQprDgQBKCgAKAsgAUEBagwJCyABQQFqDAULIAEgBEYEQEHGASEDDOcBCwJAAkAgAS0AAEEKaw4XAQsLAQsLCwsLCwsLCwsLCwsLCwsLCwALCyABQQFqIQELQbABIQMMzQELIAEgBEYEQEHIASEDDOYBCyABLQAAQSBHDQkgAkEAOwEyIAFBAWohAUGzASEDDMwBCwNAIAEhAAJAIAEgBEcEQCABLQAAQTBrQf8BcSIDQQpJDQEMJwtBxwEhAwzmAQsCQCACLwEyIgFBmTNLDQAgAiABQQpsIgU7ATIgBUH+/wNxIANB//8Dc0sNACAAQQFqIQEgAiADIAVqIgM7ATIgA0H//wNxQegHSQ0BCwtBACEDIAJBADYCHCACQcEJNgIQIAJBDTYCDCACIABBAWo2AhQM5AELIAJBADYCHCACIAE2AhQgAkHwDDYCECACQRs2AgxBACEDDOMBCyACKAIEIQAgAkEANgIEIAIgACABECYiAA0BIAFBAWoLIQFBrQEhAwzIAQsgAkHBATYCHCACIAA2AgwgAiABQQFqNgIUQQAhAwzgAQsgAigCBCEAIAJBADYCBCACIAAgARAmIgANASABQQFqCyEBQa4BIQMMxQELIAJBwgE2AhwgAiAANgIMIAIgAUEBajYCFEEAIQMM3QELIAJBADYCHCACIAE2AhQgAkGXCzYCECACQQ02AgxBACEDDNwBCyACQQA2AhwgAiABNgIUIAJB4xA2AhAgAkEJNgIMQQAhAwzbAQsgAkECOgAoDKwBC0EAIQMgAkEANgIcIAJBrws2AhAgAkECNgIMIAIgAUEBajYCFAzZAQtBAiEDDL8BC0ENIQMMvgELQSYhAwy9AQtBFSEDDLwBC0EWIQMMuwELQRghAwy6AQtBHCEDDLkBC0EdIQMMuAELQSAhAwy3AQtBISEDDLYBC0EjIQMMtQELQcYAIQMMtAELQS4hAwyzAQtBPSEDDLIBC0HLACEDDLEBC0HOACEDDLABC0HYACEDDK8BC0HZACEDDK4BC0HbACEDDK0BC0HxACEDDKwBC0H0ACEDDKsBC0GNASEDDKoBC0GXASEDDKkBC0GpASEDDKgBC0GvASEDDKcBC0GxASEDDKYBCyACQQA2AgALQQAhAyACQQA2AhwgAiABNgIUIAJB8Rs2AhAgAkEGNgIMDL0BCyACQQA2AgAgBkEBaiEBQSQLOgApIAIoAgQhACACQQA2AgQgAiAAIAEQJyIARQRAQeUAIQMMowELIAJB+QA2AhwgAiABNgIUIAIgADYCDEEAIQMMuwELIABBFUcEQCACQQA2AhwgAiABNgIUIAJBzA42AhAgAkEgNgIMQQAhAwy7AQsgAkH4ADYCHCACIAE2AhQgAkHKGDYCECACQRU2AgxBACEDDLoBCyACQQA2AhwgAiABNgIUIAJBjhs2AhAgAkEGNgIMQQAhAwy5AQsgAkEANgIcIAIgATYCFCACQf4RNgIQIAJBBzYCDEEAIQMMuAELIAJBADYCHCACIAE2AhQgAkGMHDYCECACQQc2AgxBACEDDLcBCyACQQA2AhwgAiABNgIUIAJBww82AhAgAkEHNgIMQQAhAwy2AQsgAkEANgIcIAIgATYCFCACQcMPNgIQIAJBBzYCDEEAIQMMtQELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0RIAJB5QA2AhwgAiABNgIUIAIgADYCDEEAIQMMtAELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0gIAJB0wA2AhwgAiABNgIUIAIgADYCDEEAIQMMswELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0iIAJB0gA2AhwgAiABNgIUIAIgADYCDEEAIQMMsgELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0OIAJB5QA2AhwgAiABNgIUIAIgADYCDEEAIQMMsQELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0dIAJB0wA2AhwgAiABNgIUIAIgADYCDEEAIQMMsAELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0fIAJB0gA2AhwgAiABNgIUIAIgADYCDEEAIQMMrwELIABBP0cNASABQQFqCyEBQQUhAwyUAQtBACEDIAJBADYCHCACIAE2AhQgAkH9EjYCECACQQc2AgwMrAELIAJBADYCHCACIAE2AhQgAkHcCDYCECACQQc2AgxBACEDDKsBCyACKAIEIQAgAkEANgIEIAIgACABECUiAEUNByACQeUANgIcIAIgATYCFCACIAA2AgxBACEDDKoBCyACKAIEIQAgAkEANgIEIAIgACABECUiAEUNFiACQdMANgIcIAIgATYCFCACIAA2AgxBACEDDKkBCyACKAIEIQAgAkEANgIEIAIgACABECUiAEUNGCACQdIANgIcIAIgATYCFCACIAA2AgxBACEDDKgBCyACQQA2AhwgAiABNgIUIAJBxgo2AhAgAkEHNgIMQQAhAwynAQsgAigCBCEAIAJBADYCBCACIAAgARAlIgBFDQMgAkHlADYCHCACIAE2AhQgAiAANgIMQQAhAwymAQsgAigCBCEAIAJBADYCBCACIAAgARAlIgBFDRIgAkHTADYCHCACIAE2AhQgAiAANgIMQQAhAwylAQsgAigCBCEAIAJBADYCBCACIAAgARAlIgBFDRQgAkHSADYCHCACIAE2AhQgAiAANgIMQQAhAwykAQsgAigCBCEAIAJBADYCBCACIAAgARAlIgBFDQAgAkHlADYCHCACIAE2AhQgAiAANgIMQQAhAwyjAQtB1QAhAwyJAQsgAEEVRwRAIAJBADYCHCACIAE2AhQgAkG5DTYCECACQRo2AgxBACEDDKIBCyACQeQANgIcIAIgATYCFCACQeMXNgIQIAJBFTYCDEEAIQMMoQELIAJBADYCACAGQQFqIQEgAi0AKSIAQSNrQQtJDQQCQCAAQQZLDQBBASAAdEHKAHFFDQAMBQtBACEDIAJBADYCHCACIAE2AhQgAkH3CTYCECACQQg2AgwMoAELIAJBADYCACAGQQFqIQEgAi0AKUEhRg0DIAJBADYCHCACIAE2AhQgAkGbCjYCECACQQg2AgxBACEDDJ8BCyACQQA2AgALQQAhAyACQQA2AhwgAiABNgIUIAJBkDM2AhAgAkEINgIMDJ0BCyACQQA2AgAgBkEBaiEBIAItAClBI0kNACACQQA2AhwgAiABNgIUIAJB0wk2AhAgAkEINgIMQQAhAwycAQtB0QAhAwyCAQsgAS0AAEEwayIAQf8BcUEKSQRAIAIgADoAKiABQQFqIQFBzwAhAwyCAQsgAigCBCEAIAJBADYCBCACIAAgARAoIgBFDYYBIAJB3gA2AhwgAiABNgIUIAIgADYCDEEAIQMMmgELIAIoAgQhACACQQA2AgQgAiAAIAEQKCIARQ2GASACQdwANgIcIAIgATYCFCACIAA2AgxBACEDDJkBCyACKAIEIQAgAkEANgIEIAIgACAFECgiAEUEQCAFIQEMhwELIAJB2gA2AhwgAiAFNgIUIAIgADYCDAyYAQtBACEBQQEhAwsgAiADOgArIAVBAWohAwJAAkACQCACLQAtQRBxDQACQAJAAkAgAi0AKg4DAQACBAsgBkUNAwwCCyAADQEMAgsgAUUNAQsgAigCBCEAIAJBADYCBCACIAAgAxAoIgBFBEAgAyEBDAILIAJB2AA2AhwgAiADNgIUIAIgADYCDEEAIQMMmAELIAIoAgQhACACQQA2AgQgAiAAIAMQKCIARQRAIAMhAQyHAQsgAkHZADYCHCACIAM2AhQgAiAANgIMQQAhAwyXAQtBzAAhAwx9CyAAQRVHBEAgAkEANgIcIAIgATYCFCACQZQNNgIQIAJBITYCDEEAIQMMlgELIAJB1wA2AhwgAiABNgIUIAJByRc2AhAgAkEVNgIMQQAhAwyVAQtBACEDIAJBADYCHCACIAE2AhQgAkGAETYCECACQQk2AgwMlAELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0AIAJB0wA2AhwgAiABNgIUIAIgADYCDEEAIQMMkwELQckAIQMMeQsgAkEANgIcIAIgATYCFCACQcEoNgIQIAJBBzYCDCACQQA2AgBBACEDDJEBCyACKAIEIQBBACEDIAJBADYCBCACIAAgARAlIgBFDQAgAkHSADYCHCACIAE2AhQgAiAANgIMDJABC0HIACEDDHYLIAJBADYCACAFIQELIAJBgBI7ASogAUEBaiEBQQAhAAJAIAIoAjgiA0UNACADKAIwIgNFDQAgAiADEQAAIQALIAANAQtBxwAhAwxzCyAAQRVGBEAgAkHRADYCHCACIAE2AhQgAkHjFzYCECACQRU2AgxBACEDDIwBC0EAIQMgAkEANgIcIAIgATYCFCACQbkNNgIQIAJBGjYCDAyLAQtBACEDIAJBADYCHCACIAE2AhQgAkGgGTYCECACQR42AgwMigELIAEtAABBOkYEQCACKAIEIQBBACEDIAJBADYCBCACIAAgARApIgBFDQEgAkHDADYCHCACIAA2AgwgAiABQQFqNgIUDIoBC0EAIQMgAkEANgIcIAIgATYCFCACQbERNgIQIAJBCjYCDAyJAQsgAUEBaiEBQTshAwxvCyACQcMANgIcIAIgADYCDCACIAFBAWo2AhQMhwELQQAhAyACQQA2AhwgAiABNgIUIAJB8A42AhAgAkEcNgIMDIYBCyACIAIvATBBEHI7ATAMZgsCQCACLwEwIgBBCHFFDQAgAi0AKEEBRw0AIAItAC1BCHFFDQMLIAIgAEH3+wNxQYAEcjsBMAwECyABIARHBEACQANAIAEtAABBMGsiAEH/AXFBCk8EQEE1IQMMbgsgAikDICIKQpmz5syZs+bMGVYNASACIApCCn4iCjcDICAKIACtQv8BgyILQn+FVg0BIAIgCiALfDcDICAEIAFBAWoiAUcNAAtBOSEDDIUBCyACKAIEIQBBACEDIAJBADYCBCACIAAgAUEBaiIBECoiAA0MDHcLQTkhAwyDAQsgAi0AMEEgcQ0GQcUBIQMMaQtBACEDIAJBADYCBCACIAEgARAqIgBFDQQgAkE6NgIcIAIgADYCDCACIAFBAWo2AhQMgQELIAItAChBAUcNACACLQAtQQhxRQ0BC0E3IQMMZgsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEQKiIABEAgAkE7NgIcIAIgADYCDCACIAFBAWo2AhQMfwsgAUEBaiEBDG4LIAJBCDoALAwECyABQQFqIQEMbQtBACEDIAJBADYCHCACIAE2AhQgAkHkEjYCECACQQQ2AgwMewsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEQKiIARQ1sIAJBNzYCHCACIAE2AhQgAiAANgIMDHoLIAIgAi8BMEEgcjsBMAtBMCEDDF8LIAJBNjYCHCACIAE2AhQgAiAANgIMDHcLIABBLEcNASABQQFqIQBBASEBAkACQAJAAkACQCACLQAsQQVrDgQDAQIEAAsgACEBDAQLQQIhAQwBC0EEIQELIAJBAToALCACIAIvATAgAXI7ATAgACEBDAELIAIgAi8BMEEIcjsBMCAAIQELQTkhAwxcCyACQQA6ACwLQTQhAwxaCyABIARGBEBBLSEDDHMLAkACQANAAkAgAS0AAEEKaw4EAgAAAwALIAQgAUEBaiIBRw0AC0EtIQMMdAsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEQKiIARQ0CIAJBLDYCHCACIAE2AhQgAiAANgIMDHMLIAIoAgQhAEEAIQMgAkEANgIEIAIgACABECoiAEUEQCABQQFqIQEMAgsgAkEsNgIcIAIgADYCDCACIAFBAWo2AhQMcgsgAS0AAEENRgRAIAIoAgQhAEEAIQMgAkEANgIEIAIgACABECoiAEUEQCABQQFqIQEMAgsgAkEsNgIcIAIgADYCDCACIAFBAWo2AhQMcgsgAi0ALUEBcQRAQcQBIQMMWQsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEQKiIADQEMZQtBLyEDDFcLIAJBLjYCHCACIAE2AhQgAiAANgIMDG8LQQAhAyACQQA2AhwgAiABNgIUIAJB8BQ2AhAgAkEDNgIMDG4LQQEhAwJAAkACQAJAIAItACxBBWsOBAMBAgAECyACIAIvATBBCHI7ATAMAwtBAiEDDAELQQQhAwsgAkEBOgAsIAIgAi8BMCADcjsBMAtBKiEDDFMLQQAhAyACQQA2AhwgAiABNgIUIAJB4Q82AhAgAkEKNgIMDGsLQQEhAwJAAkACQAJAAkACQCACLQAsQQJrDgcFBAQDAQIABAsgAiACLwEwQQhyOwEwDAMLQQIhAwwBC0EEIQMLIAJBAToALCACIAIvATAgA3I7ATALQSshAwxSC0EAIQMgAkEANgIcIAIgATYCFCACQasSNgIQIAJBCzYCDAxqC0EAIQMgAkEANgIcIAIgATYCFCACQf0NNgIQIAJBHTYCDAxpCyABIARHBEADQCABLQAAQSBHDUggBCABQQFqIgFHDQALQSUhAwxpC0ElIQMMaAsgAi0ALUEBcQRAQcMBIQMMTwsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEQKSIABEAgAkEmNgIcIAIgADYCDCACIAFBAWo2AhQMaAsgAUEBaiEBDFwLIAFBAWohASACLwEwIgBBgAFxBEBBACEAAkAgAigCOCIDRQ0AIAMoAlQiA0UNACACIAMRAAAhAAsgAEUNBiAAQRVHDR8gAkEFNgIcIAIgATYCFCACQfkXNgIQIAJBFTYCDEEAIQMMZwsCQCAAQaAEcUGgBEcNACACLQAtQQJxDQBBACEDIAJBADYCHCACIAE2AhQgAkGWEzYCECACQQQ2AgwMZwsgAgJ/IAIvATBBFHFBFEYEQEEBIAItAChBAUYNARogAi8BMkHlAEYMAQsgAi0AKUEFRgs6AC5BACEAAkAgAigCOCIDRQ0AIAMoAiQiA0UNACACIAMRAAAhAAsCQAJAAkACQAJAIAAOFgIBAAQEBAQEBAQEBAQEBAQEBAQEBAMECyACQQE6AC4LIAIgAi8BMEHAAHI7ATALQSchAwxPCyACQSM2AhwgAiABNgIUIAJBpRY2AhAgAkEVNgIMQQAhAwxnC0EAIQMgAkEANgIcIAIgATYCFCACQdULNgIQIAJBETYCDAxmC0EAIQACQCACKAI4IgNFDQAgAygCLCIDRQ0AIAIgAxEAACEACyAADQELQQ4hAwxLCyAAQRVGBEAgAkECNgIcIAIgATYCFCACQbAYNgIQIAJBFTYCDEEAIQMMZAtBACEDIAJBADYCHCACIAE2AhQgAkGnDjYCECACQRI2AgwMYwtBACEDIAJBADYCHCACIAE2AhQgAkGqHDYCECACQQ82AgwMYgsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEgCqdqIgEQKyIARQ0AIAJBBTYCHCACIAE2AhQgAiAANgIMDGELQQ8hAwxHC0EAIQMgAkEANgIcIAIgATYCFCACQc0TNgIQIAJBDDYCDAxfC0IBIQoLIAFBAWohAQJAIAIpAyAiC0L//////////w9YBEAgAiALQgSGIAqENwMgDAELQQAhAyACQQA2AhwgAiABNgIUIAJBrQk2AhAgAkEMNgIMDF4LQSQhAwxEC0EAIQMgAkEANgIcIAIgATYCFCACQc0TNgIQIAJBDDYCDAxcCyACKAIEIQBBACEDIAJBADYCBCACIAAgARAsIgBFBEAgAUEBaiEBDFILIAJBFzYCHCACIAA2AgwgAiABQQFqNgIUDFsLIAIoAgQhAEEAIQMgAkEANgIEAkAgAiAAIAEQLCIARQRAIAFBAWohAQwBCyACQRY2AhwgAiAANgIMIAIgAUEBajYCFAxbC0EfIQMMQQtBACEDIAJBADYCHCACIAE2AhQgAkGaDzYCECACQSI2AgwMWQsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEQLSIARQRAIAFBAWohAQxQCyACQRQ2AhwgAiAANgIMIAIgAUEBajYCFAxYCyACKAIEIQBBACEDIAJBADYCBAJAIAIgACABEC0iAEUEQCABQQFqIQEMAQsgAkETNgIcIAIgADYCDCACIAFBAWo2AhQMWAtBHiEDDD4LQQAhAyACQQA2AhwgAiABNgIUIAJBxgw2AhAgAkEjNgIMDFYLIAIoAgQhAEEAIQMgAkEANgIEIAIgACABEC0iAEUEQCABQQFqIQEMTgsgAkERNgIcIAIgADYCDCACIAFBAWo2AhQMVQsgAkEQNgIcIAIgATYCFCACIAA2AgwMVAtBACEDIAJBADYCHCACIAE2AhQgAkHGDDYCECACQSM2AgwMUwtBACEDIAJBADYCHCACIAE2AhQgAkHAFTYCECACQQI2AgwMUgsgAigCBCEAQQAhAyACQQA2AgQCQCACIAAgARAtIgBFBEAgAUEBaiEBDAELIAJBDjYCHCACIAA2AgwgAiABQQFqNgIUDFILQRshAww4C0EAIQMgAkEANgIcIAIgATYCFCACQcYMNgIQIAJBIzYCDAxQCyACKAIEIQBBACEDIAJBADYCBAJAIAIgACABECwiAEUEQCABQQFqIQEMAQsgAkENNgIcIAIgADYCDCACIAFBAWo2AhQMUAtBGiEDDDYLQQAhAyACQQA2AhwgAiABNgIUIAJBmg82AhAgAkEiNgIMDE4LIAIoAgQhAEEAIQMgAkEANgIEAkAgAiAAIAEQLCIARQRAIAFBAWohAQwBCyACQQw2AhwgAiAANgIMIAIgAUEBajYCFAxOC0EZIQMMNAtBACEDIAJBADYCHCACIAE2AhQgAkGaDzYCECACQSI2AgwMTAsgAEEVRwRAQQAhAyACQQA2AhwgAiABNgIUIAJBgww2AhAgAkETNgIMDEwLIAJBCjYCHCACIAE2AhQgAkHkFjYCECACQRU2AgxBACEDDEsLIAIoAgQhAEEAIQMgAkEANgIEIAIgACABIAqnaiIBECsiAARAIAJBBzYCHCACIAE2AhQgAiAANgIMDEsLQRMhAwwxCyAAQRVHBEBBACEDIAJBADYCHCACIAE2AhQgAkHaDTYCECACQRQ2AgwMSgsgAkEeNgIcIAIgATYCFCACQfkXNgIQIAJBFTYCDEEAIQMMSQtBACEAAkAgAigCOCIDRQ0AIAMoAiwiA0UNACACIAMRAAAhAAsgAEUNQSAAQRVGBEAgAkEDNgIcIAIgATYCFCACQbAYNgIQIAJBFTYCDEEAIQMMSQtBACEDIAJBADYCHCACIAE2AhQgAkGnDjYCECACQRI2AgwMSAtBACEDIAJBADYCHCACIAE2AhQgAkHaDTYCECACQRQ2AgwMRwtBACEDIAJBADYCHCACIAE2AhQgAkGnDjYCECACQRI2AgwMRgsgAkEAOgAvIAItAC1BBHFFDT8LIAJBADoALyACQQE6ADRBACEDDCsLQQAhAyACQQA2AhwgAkHkETYCECACQQc2AgwgAiABQQFqNgIUDEMLAkADQAJAIAEtAABBCmsOBAACAgACCyAEIAFBAWoiAUcNAAtB3QEhAwxDCwJAAkAgAi0ANEEBRw0AQQAhAAJAIAIoAjgiA0UNACADKAJYIgNFDQAgAiADEQAAIQALIABFDQAgAEEVRw0BIAJB3AE2AhwgAiABNgIUIAJB1RY2AhAgAkEVNgIMQQAhAwxEC0HBASEDDCoLIAJBADYCHCACIAE2AhQgAkHpCzYCECACQR82AgxBACEDDEILAkACQCACLQAoQQFrDgIEAQALQcABIQMMKQtBuQEhAwwoCyACQQI6AC9BACEAAkAgAigCOCIDRQ0AIAMoAgAiA0UNACACIAMRAAAhAAsgAEUEQEHCASEDDCgLIABBFUcEQCACQQA2AhwgAiABNgIUIAJBpAw2AhAgAkEQNgIMQQAhAwxBCyACQdsBNgIcIAIgATYCFCACQfoWNgIQIAJBFTYCDEEAIQMMQAsgASAERgRAQdoBIQMMQAsgAS0AAEHIAEYNASACQQE6ACgLQawBIQMMJQtBvwEhAwwkCyABIARHBEAgAkEQNgIIIAIgATYCBEG+ASEDDCQLQdkBIQMMPAsgASAERgRAQdgBIQMMPAsgAS0AAEHIAEcNBCABQQFqIQFBvQEhAwwiCyABIARGBEBB1wEhAww7CwJAAkAgAS0AAEHFAGsOEAAFBQUFBQUFBQUFBQUFBQEFCyABQQFqIQFBuwEhAwwiCyABQQFqIQFBvAEhAwwhC0HWASEDIAEgBEYNOSACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEGD0ABqLQAARw0DIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAw6CyACKAIEIQAgAkIANwMAIAIgACAGQQFqIgEQJyIARQRAQcYBIQMMIQsgAkHVATYCHCACIAE2AhQgAiAANgIMQQAhAww5C0HUASEDIAEgBEYNOCACKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEGB0ABqLQAARw0CIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAw5CyACQYEEOwEoIAIoAgQhACACQgA3AwAgAiAAIAZBAWoiARAnIgANAwwCCyACQQA2AgALQQAhAyACQQA2AhwgAiABNgIUIAJB2Bs2AhAgAkEINgIMDDYLQboBIQMMHAsgAkHTATYCHCACIAE2AhQgAiAANgIMQQAhAww0C0EAIQACQCACKAI4IgNFDQAgAygCOCIDRQ0AIAIgAxEAACEACyAARQ0AIABBFUYNASACQQA2AhwgAiABNgIUIAJBzA42AhAgAkEgNgIMQQAhAwwzC0HkACEDDBkLIAJB+AA2AhwgAiABNgIUIAJByhg2AhAgAkEVNgIMQQAhAwwxC0HSASEDIAQgASIARg0wIAQgAWsgAigCACIBaiEFIAAgAWtBBGohBgJAA0AgAC0AACABQfzPAGotAABHDQEgAUEERg0DIAFBAWohASAEIABBAWoiAEcNAAsgAiAFNgIADDELIAJBADYCHCACIAA2AhQgAkGQMzYCECACQQg2AgwgAkEANgIAQQAhAwwwCyABIARHBEAgAkEONgIIIAIgATYCBEG3ASEDDBcLQdEBIQMMLwsgAkEANgIAIAZBAWohAQtBuAEhAwwUCyABIARGBEBB0AEhAwwtCyABLQAAQTBrIgBB/wFxQQpJBEAgAiAAOgAqIAFBAWohAUG2ASEDDBQLIAIoAgQhACACQQA2AgQgAiAAIAEQKCIARQ0UIAJBzwE2AhwgAiABNgIUIAIgADYCDEEAIQMMLAsgASAERgRAQc4BIQMMLAsCQCABLQAAQS5GBEAgAUEBaiEBDAELIAIoAgQhACACQQA2AgQgAiAAIAEQKCIARQ0VIAJBzQE2AhwgAiABNgIUIAIgADYCDEEAIQMMLAtBtQEhAwwSCyAEIAEiBUYEQEHMASEDDCsLQQAhAEEBIQFBASEGQQAhAwJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAIAUtAABBMGsOCgoJAAECAwQFBggLC0ECDAYLQQMMBQtBBAwEC0EFDAMLQQYMAgtBBwwBC0EICyEDQQAhAUEAIQYMAgtBCSEDQQEhAEEAIQFBACEGDAELQQAhAUEBIQMLIAIgAzoAKyAFQQFqIQMCQAJAIAItAC1BEHENAAJAAkACQCACLQAqDgMBAAIECyAGRQ0DDAILIAANAQwCCyABRQ0BCyACKAIEIQAgAkEANgIEIAIgACADECgiAEUEQCADIQEMAwsgAkHJATYCHCACIAM2AhQgAiAANgIMQQAhAwwtCyACKAIEIQAgAkEANgIEIAIgACADECgiAEUEQCADIQEMGAsgAkHKATYCHCACIAM2AhQgAiAANgIMQQAhAwwsCyACKAIEIQAgAkEANgIEIAIgACAFECgiAEUEQCAFIQEMFgsgAkHLATYCHCACIAU2AhQgAiAANgIMDCsLQbQBIQMMEQtBACEAAkAgAigCOCIDRQ0AIAMoAjwiA0UNACACIAMRAAAhAAsCQCAABEAgAEEVRg0BIAJBADYCHCACIAE2AhQgAkGUDTYCECACQSE2AgxBACEDDCsLQbIBIQMMEQsgAkHIATYCHCACIAE2AhQgAkHJFzYCECACQRU2AgxBACEDDCkLIAJBADYCACAGQQFqIQFB9QAhAwwPCyACLQApQQVGBEBB4wAhAwwPC0HiACEDDA4LIAAhASACQQA2AgALIAJBADoALEEJIQMMDAsgAkEANgIAIAdBAWohAUHAACEDDAsLQQELOgAsIAJBADYCACAGQQFqIQELQSkhAwwIC0E4IQMMBwsCQCABIARHBEADQCABLQAAQYA+ai0AACIAQQFHBEAgAEECRw0DIAFBAWohAQwFCyAEIAFBAWoiAUcNAAtBPiEDDCELQT4hAwwgCwsgAkEAOgAsDAELQQshAwwEC0E6IQMMAwsgAUEBaiEBQS0hAwwCCyACIAE6ACwgAkEANgIAIAZBAWohAUEMIQMMAQsgAkEANgIAIAZBAWohAUEKIQMMAAsAC0EAIQMgAkEANgIcIAIgATYCFCACQc0QNgIQIAJBCTYCDAwXC0EAIQMgAkEANgIcIAIgATYCFCACQekKNgIQIAJBCTYCDAwWC0EAIQMgAkEANgIcIAIgATYCFCACQbcQNgIQIAJBCTYCDAwVC0EAIQMgAkEANgIcIAIgATYCFCACQZwRNgIQIAJBCTYCDAwUC0EAIQMgAkEANgIcIAIgATYCFCACQc0QNgIQIAJBCTYCDAwTC0EAIQMgAkEANgIcIAIgATYCFCACQekKNgIQIAJBCTYCDAwSC0EAIQMgAkEANgIcIAIgATYCFCACQbcQNgIQIAJBCTYCDAwRC0EAIQMgAkEANgIcIAIgATYCFCACQZwRNgIQIAJBCTYCDAwQC0EAIQMgAkEANgIcIAIgATYCFCACQZcVNgIQIAJBDzYCDAwPC0EAIQMgAkEANgIcIAIgATYCFCACQZcVNgIQIAJBDzYCDAwOC0EAIQMgAkEANgIcIAIgATYCFCACQcASNgIQIAJBCzYCDAwNC0EAIQMgAkEANgIcIAIgATYCFCACQZUJNgIQIAJBCzYCDAwMC0EAIQMgAkEANgIcIAIgATYCFCACQeEPNgIQIAJBCjYCDAwLC0EAIQMgAkEANgIcIAIgATYCFCACQfsPNgIQIAJBCjYCDAwKC0EAIQMgAkEANgIcIAIgATYCFCACQfEZNgIQIAJBAjYCDAwJC0EAIQMgAkEANgIcIAIgATYCFCACQcQUNgIQIAJBAjYCDAwIC0EAIQMgAkEANgIcIAIgATYCFCACQfIVNgIQIAJBAjYCDAwHCyACQQI2AhwgAiABNgIUIAJBnBo2AhAgAkEWNgIMQQAhAwwGC0EBIQMMBQtB1AAhAyABIARGDQQgCEEIaiEJIAIoAgAhBQJAAkAgASAERwRAIAVB2MIAaiEHIAQgBWogAWshACAFQX9zQQpqIgUgAWohBgNAIAEtAAAgBy0AAEcEQEECIQcMAwsgBUUEQEEAIQcgBiEBDAMLIAVBAWshBSAHQQFqIQcgBCABQQFqIgFHDQALIAAhBSAEIQELIAlBATYCACACIAU2AgAMAQsgAkEANgIAIAkgBzYCAAsgCSABNgIEIAgoAgwhACAIKAIIDgMBBAIACwALIAJBADYCHCACQbUaNgIQIAJBFzYCDCACIABBAWo2AhRBACEDDAILIAJBADYCHCACIAA2AhQgAkHKGjYCECACQQk2AgxBACEDDAELIAEgBEYEQEEiIQMMAQsgAkEJNgIIIAIgATYCBEEhIQMLIAhBEGokACADRQRAIAIoAgwhAAwBCyACIAM2AhxBACEAIAIoAgQiAUUNACACIAEgBCACKAIIEQEAIgFFDQAgAiAENgIUIAIgATYCDCABIQALIAALvgIBAn8gAEEAOgAAIABB3ABqIgFBAWtBADoAACAAQQA6AAIgAEEAOgABIAFBA2tBADoAACABQQJrQQA6AAAgAEEAOgADIAFBBGtBADoAAEEAIABrQQNxIgEgAGoiAEEANgIAQdwAIAFrQXxxIgIgAGoiAUEEa0EANgIAAkAgAkEJSQ0AIABBADYCCCAAQQA2AgQgAUEIa0EANgIAIAFBDGtBADYCACACQRlJDQAgAEEANgIYIABBADYCFCAAQQA2AhAgAEEANgIMIAFBEGtBADYCACABQRRrQQA2AgAgAUEYa0EANgIAIAFBHGtBADYCACACIABBBHFBGHIiAmsiAUEgSQ0AIAAgAmohAANAIABCADcDGCAAQgA3AxAgAEIANwMIIABCADcDACAAQSBqIQAgAUEgayIBQR9LDQALCwtWAQF/AkAgACgCDA0AAkACQAJAAkAgAC0ALw4DAQADAgsgACgCOCIBRQ0AIAEoAiwiAUUNACAAIAERAAAiAQ0DC0EADwsACyAAQcMWNgIQQQ4hAQsgAQsaACAAKAIMRQRAIABB0Rs2AhAgAEEVNgIMCwsUACAAKAIMQRVGBEAgAEEANgIMCwsUACAAKAIMQRZGBEAgAEEANgIMCwsHACAAKAIMCwcAIAAoAhALCQAgACABNgIQCwcAIAAoAhQLFwAgAEEkTwRAAAsgAEECdEGgM2ooAgALFwAgAEEuTwRAAAsgAEECdEGwNGooAgALvwkBAX9B6yghAQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABB5ABrDvQDY2IAAWFhYWFhYQIDBAVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhBgcICQoLDA0OD2FhYWFhEGFhYWFhYWFhYWFhEWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYRITFBUWFxgZGhthYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2YTc4OTphYWFhYWFhYTthYWE8YWFhYT0+P2FhYWFhYWFhQGFhQWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYUJDREVGR0hJSktMTU5PUFFSU2FhYWFhYWFhVFVWV1hZWlthXF1hYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFeYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhX2BhC0HhJw8LQaQhDwtByywPC0H+MQ8LQcAkDwtBqyQPC0GNKA8LQeImDwtBgDAPC0G5Lw8LQdckDwtB7x8PC0HhHw8LQfofDwtB8iAPC0GoLw8LQa4yDwtBiDAPC0HsJw8LQYIiDwtBjh0PC0HQLg8LQcojDwtBxTIPC0HfHA8LQdIcDwtBxCAPC0HXIA8LQaIfDwtB7S4PC0GrMA8LQdQlDwtBzC4PC0H6Lg8LQfwrDwtB0jAPC0HxHQ8LQbsgDwtB9ysPC0GQMQ8LQdcxDwtBoi0PC0HUJw8LQeArDwtBnywPC0HrMQ8LQdUfDwtByjEPC0HeJQ8LQdQeDwtB9BwPC0GnMg8LQbEdDwtBoB0PC0G5MQ8LQbwwDwtBkiEPC0GzJg8LQeksDwtBrB4PC0HUKw8LQfcmDwtBgCYPC0GwIQ8LQf4eDwtBjSMPC0GJLQ8LQfciDwtBoDEPC0GuHw8LQcYlDwtB6B4PC0GTIg8LQcIvDwtBwx0PC0GLLA8LQeEdDwtBjS8PC0HqIQ8LQbQtDwtB0i8PC0HfMg8LQdIyDwtB8DAPC0GpIg8LQfkjDwtBmR4PC0G1LA8LQZswDwtBkjIPC0G2Kw8LQcIiDwtB+DIPC0GeJQ8LQdAiDwtBuh4PC0GBHg8LAAtB1iEhAQsgAQsWACAAIAAtAC1B/gFxIAFBAEdyOgAtCxkAIAAgAC0ALUH9AXEgAUEAR0EBdHI6AC0LGQAgACAALQAtQfsBcSABQQBHQQJ0cjoALQsZACAAIAAtAC1B9wFxIAFBAEdBA3RyOgAtCz4BAn8CQCAAKAI4IgNFDQAgAygCBCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABBxhE2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCCCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABB9go2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCDCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABB7Ro2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCECIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABBlRA2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCFCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABBqhs2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCGCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABB7RM2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCKCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABB9gg2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCHCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABBwhk2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCICIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABBlBQ2AhBBGCEECyAEC1kBAn8CQCAALQAoQQFGDQAgAC8BMiIBQeQAa0HkAEkNACABQcwBRg0AIAFBsAJGDQAgAC8BMCIAQcAAcQ0AQQEhAiAAQYgEcUGABEYNACAAQShxRSECCyACC4wBAQJ/AkACQAJAIAAtACpFDQAgAC0AK0UNACAALwEwIgFBAnFFDQEMAgsgAC8BMCIBQQFxRQ0BC0EBIQIgAC0AKEEBRg0AIAAvATIiAEHkAGtB5ABJDQAgAEHMAUYNACAAQbACRg0AIAFBwABxDQBBACECIAFBiARxQYAERg0AIAFBKHFBAEchAgsgAgtXACAAQRhqQgA3AwAgAEIANwMAIABBOGpCADcDACAAQTBqQgA3AwAgAEEoakIANwMAIABBIGpCADcDACAAQRBqQgA3AwAgAEEIakIANwMAIABB3QE2AhwLBgAgABAyC5otAQt/IwBBEGsiCiQAQaTQACgCACIJRQRAQeTTACgCACIFRQRAQfDTAEJ/NwIAQejTAEKAgISAgIDAADcCAEHk0wAgCkEIakFwcUHYqtWqBXMiBTYCAEH40wBBADYCAEHI0wBBADYCAAtBzNMAQYDUBDYCAEGc0ABBgNQENgIAQbDQACAFNgIAQazQAEF/NgIAQdDTAEGArAM2AgADQCABQcjQAGogAUG80ABqIgI2AgAgAiABQbTQAGoiAzYCACABQcDQAGogAzYCACABQdDQAGogAUHE0ABqIgM2AgAgAyACNgIAIAFB2NAAaiABQczQAGoiAjYCACACIAM2AgAgAUHU0ABqIAI2AgAgAUEgaiIBQYACRw0AC0GM1ARBwasDNgIAQajQAEH00wAoAgA2AgBBmNAAQcCrAzYCAEGk0ABBiNQENgIAQcz/B0E4NgIAQYjUBCEJCwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABB7AFNBEBBjNAAKAIAIgZBECAAQRNqQXBxIABBC0kbIgRBA3YiAHYiAUEDcQRAAkAgAUEBcSAAckEBcyICQQN0IgBBtNAAaiIBIABBvNAAaigCACIAKAIIIgNGBEBBjNAAIAZBfiACd3E2AgAMAQsgASADNgIIIAMgATYCDAsgAEEIaiEBIAAgAkEDdCICQQNyNgIEIAAgAmoiACAAKAIEQQFyNgIEDBELQZTQACgCACIIIARPDQEgAQRAAkBBAiAAdCICQQAgAmtyIAEgAHRxaCIAQQN0IgJBtNAAaiIBIAJBvNAAaigCACICKAIIIgNGBEBBjNAAIAZBfiAAd3EiBjYCAAwBCyABIAM2AgggAyABNgIMCyACIARBA3I2AgQgAEEDdCIAIARrIQUgACACaiAFNgIAIAIgBGoiBCAFQQFyNgIEIAgEQCAIQXhxQbTQAGohAEGg0AAoAgAhAwJ/QQEgCEEDdnQiASAGcUUEQEGM0AAgASAGcjYCACAADAELIAAoAggLIgEgAzYCDCAAIAM2AgggAyAANgIMIAMgATYCCAsgAkEIaiEBQaDQACAENgIAQZTQACAFNgIADBELQZDQACgCACILRQ0BIAtoQQJ0QbzSAGooAgAiACgCBEF4cSAEayEFIAAhAgNAAkAgAigCECIBRQRAIAJBFGooAgAiAUUNAQsgASgCBEF4cSAEayIDIAVJIQIgAyAFIAIbIQUgASAAIAIbIQAgASECDAELCyAAKAIYIQkgACgCDCIDIABHBEBBnNAAKAIAGiADIAAoAggiATYCCCABIAM2AgwMEAsgAEEUaiICKAIAIgFFBEAgACgCECIBRQ0DIABBEGohAgsDQCACIQcgASIDQRRqIgIoAgAiAQ0AIANBEGohAiADKAIQIgENAAsgB0EANgIADA8LQX8hBCAAQb9/Sw0AIABBE2oiAUFwcSEEQZDQACgCACIIRQ0AQQAgBGshBQJAAkACQAJ/QQAgBEGAAkkNABpBHyAEQf///wdLDQAaIARBJiABQQh2ZyIAa3ZBAXEgAEEBdGtBPmoLIgZBAnRBvNIAaigCACICRQRAQQAhAUEAIQMMAQtBACEBIARBGSAGQQF2a0EAIAZBH0cbdCEAQQAhAwNAAkAgAigCBEF4cSAEayIHIAVPDQAgAiEDIAciBQ0AQQAhBSACIQEMAwsgASACQRRqKAIAIgcgByACIABBHXZBBHFqQRBqKAIAIgJGGyABIAcbIQEgAEEBdCEAIAINAAsLIAEgA3JFBEBBACEDQQIgBnQiAEEAIABrciAIcSIARQ0DIABoQQJ0QbzSAGooAgAhAQsgAUUNAQsDQCABKAIEQXhxIARrIgIgBUkhACACIAUgABshBSABIAMgABshAyABKAIQIgAEfyAABSABQRRqKAIACyIBDQALCyADRQ0AIAVBlNAAKAIAIARrTw0AIAMoAhghByADIAMoAgwiAEcEQEGc0AAoAgAaIAAgAygCCCIBNgIIIAEgADYCDAwOCyADQRRqIgIoAgAiAUUEQCADKAIQIgFFDQMgA0EQaiECCwNAIAIhBiABIgBBFGoiAigCACIBDQAgAEEQaiECIAAoAhAiAQ0ACyAGQQA2AgAMDQtBlNAAKAIAIgMgBE8EQEGg0AAoAgAhAQJAIAMgBGsiAkEQTwRAIAEgBGoiACACQQFyNgIEIAEgA2ogAjYCACABIARBA3I2AgQMAQsgASADQQNyNgIEIAEgA2oiACAAKAIEQQFyNgIEQQAhAEEAIQILQZTQACACNgIAQaDQACAANgIAIAFBCGohAQwPC0GY0AAoAgAiAyAESwRAIAQgCWoiACADIARrIgFBAXI2AgRBpNAAIAA2AgBBmNAAIAE2AgAgCSAEQQNyNgIEIAlBCGohAQwPC0EAIQEgBAJ/QeTTACgCAARAQezTACgCAAwBC0Hw0wBCfzcCAEHo0wBCgICEgICAwAA3AgBB5NMAIApBDGpBcHFB2KrVqgVzNgIAQfjTAEEANgIAQcjTAEEANgIAQYCABAsiACAEQccAaiIFaiIGQQAgAGsiB3EiAk8EQEH80wBBMDYCAAwPCwJAQcTTACgCACIBRQ0AQbzTACgCACIIIAJqIQAgACABTSAAIAhLcQ0AQQAhAUH80wBBMDYCAAwPC0HI0wAtAABBBHENBAJAAkAgCQRAQczTACEBA0AgASgCACIAIAlNBEAgACABKAIEaiAJSw0DCyABKAIIIgENAAsLQQAQMyIAQX9GDQUgAiEGQejTACgCACIBQQFrIgMgAHEEQCACIABrIAAgA2pBACABa3FqIQYLIAQgBk8NBSAGQf7///8HSw0FQcTTACgCACIDBEBBvNMAKAIAIgcgBmohASABIAdNDQYgASADSw0GCyAGEDMiASAARw0BDAcLIAYgA2sgB3EiBkH+////B0sNBCAGEDMhACAAIAEoAgAgASgCBGpGDQMgACEBCwJAIAYgBEHIAGpPDQAgAUF/Rg0AQezTACgCACIAIAUgBmtqQQAgAGtxIgBB/v///wdLBEAgASEADAcLIAAQM0F/RwRAIAAgBmohBiABIQAMBwtBACAGaxAzGgwECyABIgBBf0cNBQwDC0EAIQMMDAtBACEADAoLIABBf0cNAgtByNMAQcjTACgCAEEEcjYCAAsgAkH+////B0sNASACEDMhAEEAEDMhASAAQX9GDQEgAUF/Rg0BIAAgAU8NASABIABrIgYgBEE4ak0NAQtBvNMAQbzTACgCACAGaiIBNgIAQcDTACgCACABSQRAQcDTACABNgIACwJAAkACQEGk0AAoAgAiAgRAQczTACEBA0AgACABKAIAIgMgASgCBCIFakYNAiABKAIIIgENAAsMAgtBnNAAKAIAIgFBAEcgACABT3FFBEBBnNAAIAA2AgALQQAhAUHQ0wAgBjYCAEHM0wAgADYCAEGs0ABBfzYCAEGw0ABB5NMAKAIANgIAQdjTAEEANgIAA0AgAUHI0ABqIAFBvNAAaiICNgIAIAIgAUG00ABqIgM2AgAgAUHA0ABqIAM2AgAgAUHQ0ABqIAFBxNAAaiIDNgIAIAMgAjYCACABQdjQAGogAUHM0ABqIgI2AgAgAiADNgIAIAFB1NAAaiACNgIAIAFBIGoiAUGAAkcNAAtBeCAAa0EPcSIBIABqIgIgBkE4ayIDIAFrIgFBAXI2AgRBqNAAQfTTACgCADYCAEGY0AAgATYCAEGk0AAgAjYCACAAIANqQTg2AgQMAgsgACACTQ0AIAIgA0kNACABKAIMQQhxDQBBeCACa0EPcSIAIAJqIgNBmNAAKAIAIAZqIgcgAGsiAEEBcjYCBCABIAUgBmo2AgRBqNAAQfTTACgCADYCAEGY0AAgADYCAEGk0AAgAzYCACACIAdqQTg2AgQMAQsgAEGc0AAoAgBJBEBBnNAAIAA2AgALIAAgBmohA0HM0wAhAQJAAkACQANAIAMgASgCAEcEQCABKAIIIgENAQwCCwsgAS0ADEEIcUUNAQtBzNMAIQEDQCABKAIAIgMgAk0EQCADIAEoAgRqIgUgAksNAwsgASgCCCEBDAALAAsgASAANgIAIAEgASgCBCAGajYCBCAAQXggAGtBD3FqIgkgBEEDcjYCBCADQXggA2tBD3FqIgYgBCAJaiIEayEBIAIgBkYEQEGk0AAgBDYCAEGY0ABBmNAAKAIAIAFqIgA2AgAgBCAAQQFyNgIEDAgLQaDQACgCACAGRgRAQaDQACAENgIAQZTQAEGU0AAoAgAgAWoiADYCACAEIABBAXI2AgQgACAEaiAANgIADAgLIAYoAgQiBUEDcUEBRw0GIAVBeHEhCCAFQf8BTQRAIAVBA3YhAyAGKAIIIgAgBigCDCICRgRAQYzQAEGM0AAoAgBBfiADd3E2AgAMBwsgAiAANgIIIAAgAjYCDAwGCyAGKAIYIQcgBiAGKAIMIgBHBEAgACAGKAIIIgI2AgggAiAANgIMDAULIAZBFGoiAigCACIFRQRAIAYoAhAiBUUNBCAGQRBqIQILA0AgAiEDIAUiAEEUaiICKAIAIgUNACAAQRBqIQIgACgCECIFDQALIANBADYCAAwEC0F4IABrQQ9xIgEgAGoiByAGQThrIgMgAWsiAUEBcjYCBCAAIANqQTg2AgQgAiAFQTcgBWtBD3FqQT9rIgMgAyACQRBqSRsiA0EjNgIEQajQAEH00wAoAgA2AgBBmNAAIAE2AgBBpNAAIAc2AgAgA0EQakHU0wApAgA3AgAgA0HM0wApAgA3AghB1NMAIANBCGo2AgBB0NMAIAY2AgBBzNMAIAA2AgBB2NMAQQA2AgAgA0EkaiEBA0AgAUEHNgIAIAUgAUEEaiIBSw0ACyACIANGDQAgAyADKAIEQX5xNgIEIAMgAyACayIFNgIAIAIgBUEBcjYCBCAFQf8BTQRAIAVBeHFBtNAAaiEAAn9BjNAAKAIAIgFBASAFQQN2dCIDcUUEQEGM0AAgASADcjYCACAADAELIAAoAggLIgEgAjYCDCAAIAI2AgggAiAANgIMIAIgATYCCAwBC0EfIQEgBUH///8HTQRAIAVBJiAFQQh2ZyIAa3ZBAXEgAEEBdGtBPmohAQsgAiABNgIcIAJCADcCECABQQJ0QbzSAGohAEGQ0AAoAgAiA0EBIAF0IgZxRQRAIAAgAjYCAEGQ0AAgAyAGcjYCACACIAA2AhggAiACNgIIIAIgAjYCDAwBCyAFQRkgAUEBdmtBACABQR9HG3QhASAAKAIAIQMCQANAIAMiACgCBEF4cSAFRg0BIAFBHXYhAyABQQF0IQEgACADQQRxakEQaiIGKAIAIgMNAAsgBiACNgIAIAIgADYCGCACIAI2AgwgAiACNgIIDAELIAAoAggiASACNgIMIAAgAjYCCCACQQA2AhggAiAANgIMIAIgATYCCAtBmNAAKAIAIgEgBE0NAEGk0AAoAgAiACAEaiICIAEgBGsiAUEBcjYCBEGY0AAgATYCAEGk0AAgAjYCACAAIARBA3I2AgQgAEEIaiEBDAgLQQAhAUH80wBBMDYCAAwHC0EAIQALIAdFDQACQCAGKAIcIgJBAnRBvNIAaiIDKAIAIAZGBEAgAyAANgIAIAANAUGQ0ABBkNAAKAIAQX4gAndxNgIADAILIAdBEEEUIAcoAhAgBkYbaiAANgIAIABFDQELIAAgBzYCGCAGKAIQIgIEQCAAIAI2AhAgAiAANgIYCyAGQRRqKAIAIgJFDQAgAEEUaiACNgIAIAIgADYCGAsgASAIaiEBIAYgCGoiBigCBCEFCyAGIAVBfnE2AgQgASAEaiABNgIAIAQgAUEBcjYCBCABQf8BTQRAIAFBeHFBtNAAaiEAAn9BjNAAKAIAIgJBASABQQN2dCIBcUUEQEGM0AAgASACcjYCACAADAELIAAoAggLIgEgBDYCDCAAIAQ2AgggBCAANgIMIAQgATYCCAwBC0EfIQUgAUH///8HTQRAIAFBJiABQQh2ZyIAa3ZBAXEgAEEBdGtBPmohBQsgBCAFNgIcIARCADcCECAFQQJ0QbzSAGohAEGQ0AAoAgAiAkEBIAV0IgNxRQRAIAAgBDYCAEGQ0AAgAiADcjYCACAEIAA2AhggBCAENgIIIAQgBDYCDAwBCyABQRkgBUEBdmtBACAFQR9HG3QhBSAAKAIAIQACQANAIAAiAigCBEF4cSABRg0BIAVBHXYhACAFQQF0IQUgAiAAQQRxakEQaiIDKAIAIgANAAsgAyAENgIAIAQgAjYCGCAEIAQ2AgwgBCAENgIIDAELIAIoAggiACAENgIMIAIgBDYCCCAEQQA2AhggBCACNgIMIAQgADYCCAsgCUEIaiEBDAILAkAgB0UNAAJAIAMoAhwiAUECdEG80gBqIgIoAgAgA0YEQCACIAA2AgAgAA0BQZDQACAIQX4gAXdxIgg2AgAMAgsgB0EQQRQgBygCECADRhtqIAA2AgAgAEUNAQsgACAHNgIYIAMoAhAiAQRAIAAgATYCECABIAA2AhgLIANBFGooAgAiAUUNACAAQRRqIAE2AgAgASAANgIYCwJAIAVBD00EQCADIAQgBWoiAEEDcjYCBCAAIANqIgAgACgCBEEBcjYCBAwBCyADIARqIgIgBUEBcjYCBCADIARBA3I2AgQgAiAFaiAFNgIAIAVB/wFNBEAgBUF4cUG00ABqIQACf0GM0AAoAgAiAUEBIAVBA3Z0IgVxRQRAQYzQACABIAVyNgIAIAAMAQsgACgCCAsiASACNgIMIAAgAjYCCCACIAA2AgwgAiABNgIIDAELQR8hASAFQf///wdNBEAgBUEmIAVBCHZnIgBrdkEBcSAAQQF0a0E+aiEBCyACIAE2AhwgAkIANwIQIAFBAnRBvNIAaiEAQQEgAXQiBCAIcUUEQCAAIAI2AgBBkNAAIAQgCHI2AgAgAiAANgIYIAIgAjYCCCACIAI2AgwMAQsgBUEZIAFBAXZrQQAgAUEfRxt0IQEgACgCACEEAkADQCAEIgAoAgRBeHEgBUYNASABQR12IQQgAUEBdCEBIAAgBEEEcWpBEGoiBigCACIEDQALIAYgAjYCACACIAA2AhggAiACNgIMIAIgAjYCCAwBCyAAKAIIIgEgAjYCDCAAIAI2AgggAkEANgIYIAIgADYCDCACIAE2AggLIANBCGohAQwBCwJAIAlFDQACQCAAKAIcIgFBAnRBvNIAaiICKAIAIABGBEAgAiADNgIAIAMNAUGQ0AAgC0F+IAF3cTYCAAwCCyAJQRBBFCAJKAIQIABGG2ogAzYCACADRQ0BCyADIAk2AhggACgCECIBBEAgAyABNgIQIAEgAzYCGAsgAEEUaigCACIBRQ0AIANBFGogATYCACABIAM2AhgLAkAgBUEPTQRAIAAgBCAFaiIBQQNyNgIEIAAgAWoiASABKAIEQQFyNgIEDAELIAAgBGoiByAFQQFyNgIEIAAgBEEDcjYCBCAFIAdqIAU2AgAgCARAIAhBeHFBtNAAaiEBQaDQACgCACEDAn9BASAIQQN2dCICIAZxRQRAQYzQACACIAZyNgIAIAEMAQsgASgCCAsiAiADNgIMIAEgAzYCCCADIAE2AgwgAyACNgIIC0Gg0AAgBzYCAEGU0AAgBTYCAAsgAEEIaiEBCyAKQRBqJAAgAQtDACAARQRAPwBBEHQPCwJAIABB//8DcQ0AIABBAEgNACAAQRB2QAAiAEF/RgRAQfzTAEEwNgIAQX8PCyAAQRB0DwsACwvcPyIAQYAICwkBAAAAAgAAAAMAQZQICwUEAAAABQBBpAgLCQYAAAAHAAAACABB3AgLii1JbnZhbGlkIGNoYXIgaW4gdXJsIHF1ZXJ5AFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fYm9keQBDb250ZW50LUxlbmd0aCBvdmVyZmxvdwBDaHVuayBzaXplIG92ZXJmbG93AFJlc3BvbnNlIG92ZXJmbG93AEludmFsaWQgbWV0aG9kIGZvciBIVFRQL3gueCByZXF1ZXN0AEludmFsaWQgbWV0aG9kIGZvciBSVFNQL3gueCByZXF1ZXN0AEV4cGVjdGVkIFNPVVJDRSBtZXRob2QgZm9yIElDRS94LnggcmVxdWVzdABJbnZhbGlkIGNoYXIgaW4gdXJsIGZyYWdtZW50IHN0YXJ0AEV4cGVjdGVkIGRvdABTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3N0YXR1cwBJbnZhbGlkIHJlc3BvbnNlIHN0YXR1cwBJbnZhbGlkIGNoYXJhY3RlciBpbiBjaHVuayBleHRlbnNpb25zAFVzZXIgY2FsbGJhY2sgZXJyb3IAYG9uX3Jlc2V0YCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfaGVhZGVyYCBjYWxsYmFjayBlcnJvcgBgb25fbWVzc2FnZV9iZWdpbmAgY2FsbGJhY2sgZXJyb3IAYG9uX2NodW5rX2V4dGVuc2lvbl92YWx1ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX3N0YXR1c19jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX3ZlcnNpb25fY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl91cmxfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9jaHVua19jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX2hlYWRlcl92YWx1ZV9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX21lc3NhZ2VfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9tZXRob2RfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9oZWFkZXJfZmllbGRfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9jaHVua19leHRlbnNpb25fbmFtZWAgY2FsbGJhY2sgZXJyb3IAVW5leHBlY3RlZCBjaGFyIGluIHVybCBzZXJ2ZXIASW52YWxpZCBoZWFkZXIgdmFsdWUgY2hhcgBJbnZhbGlkIGhlYWRlciBmaWVsZCBjaGFyAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fdmVyc2lvbgBJbnZhbGlkIG1pbm9yIHZlcnNpb24ASW52YWxpZCBtYWpvciB2ZXJzaW9uAEV4cGVjdGVkIHNwYWNlIGFmdGVyIHZlcnNpb24ARXhwZWN0ZWQgQ1JMRiBhZnRlciB2ZXJzaW9uAEludmFsaWQgSFRUUCB2ZXJzaW9uAEludmFsaWQgaGVhZGVyIHRva2VuAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fdXJsAEludmFsaWQgY2hhcmFjdGVycyBpbiB1cmwAVW5leHBlY3RlZCBzdGFydCBjaGFyIGluIHVybABEb3VibGUgQCBpbiB1cmwARW1wdHkgQ29udGVudC1MZW5ndGgASW52YWxpZCBjaGFyYWN0ZXIgaW4gQ29udGVudC1MZW5ndGgARHVwbGljYXRlIENvbnRlbnQtTGVuZ3RoAEludmFsaWQgY2hhciBpbiB1cmwgcGF0aABDb250ZW50LUxlbmd0aCBjYW4ndCBiZSBwcmVzZW50IHdpdGggVHJhbnNmZXItRW5jb2RpbmcASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgc2l6ZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2hlYWRlcl92YWx1ZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2NodW5rX2V4dGVuc2lvbl92YWx1ZQBJbnZhbGlkIGNoYXJhY3RlciBpbiBjaHVuayBleHRlbnNpb25zIHZhbHVlAE1pc3NpbmcgZXhwZWN0ZWQgTEYgYWZ0ZXIgaGVhZGVyIHZhbHVlAEludmFsaWQgYFRyYW5zZmVyLUVuY29kaW5nYCBoZWFkZXIgdmFsdWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyBxdW90ZSB2YWx1ZQBJbnZhbGlkIGNoYXJhY3RlciBpbiBjaHVuayBleHRlbnNpb25zIHF1b3RlZCB2YWx1ZQBQYXVzZWQgYnkgb25faGVhZGVyc19jb21wbGV0ZQBJbnZhbGlkIEVPRiBzdGF0ZQBvbl9yZXNldCBwYXVzZQBvbl9jaHVua19oZWFkZXIgcGF1c2UAb25fbWVzc2FnZV9iZWdpbiBwYXVzZQBvbl9jaHVua19leHRlbnNpb25fdmFsdWUgcGF1c2UAb25fc3RhdHVzX2NvbXBsZXRlIHBhdXNlAG9uX3ZlcnNpb25fY29tcGxldGUgcGF1c2UAb25fdXJsX2NvbXBsZXRlIHBhdXNlAG9uX2NodW5rX2NvbXBsZXRlIHBhdXNlAG9uX2hlYWRlcl92YWx1ZV9jb21wbGV0ZSBwYXVzZQBvbl9tZXNzYWdlX2NvbXBsZXRlIHBhdXNlAG9uX21ldGhvZF9jb21wbGV0ZSBwYXVzZQBvbl9oZWFkZXJfZmllbGRfY29tcGxldGUgcGF1c2UAb25fY2h1bmtfZXh0ZW5zaW9uX25hbWUgcGF1c2UAVW5leHBlY3RlZCBzcGFjZSBhZnRlciBzdGFydCBsaW5lAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fY2h1bmtfZXh0ZW5zaW9uX25hbWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyBuYW1lAFBhdXNlIG9uIENPTk5FQ1QvVXBncmFkZQBQYXVzZSBvbiBQUkkvVXBncmFkZQBFeHBlY3RlZCBIVFRQLzIgQ29ubmVjdGlvbiBQcmVmYWNlAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fbWV0aG9kAEV4cGVjdGVkIHNwYWNlIGFmdGVyIG1ldGhvZABTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2hlYWRlcl9maWVsZABQYXVzZWQASW52YWxpZCB3b3JkIGVuY291bnRlcmVkAEludmFsaWQgbWV0aG9kIGVuY291bnRlcmVkAFVuZXhwZWN0ZWQgY2hhciBpbiB1cmwgc2NoZW1hAFJlcXVlc3QgaGFzIGludmFsaWQgYFRyYW5zZmVyLUVuY29kaW5nYABTV0lUQ0hfUFJPWFkAVVNFX1BST1hZAE1LQUNUSVZJVFkAVU5QUk9DRVNTQUJMRV9FTlRJVFkAQ09QWQBNT1ZFRF9QRVJNQU5FTlRMWQBUT09fRUFSTFkATk9USUZZAEZBSUxFRF9ERVBFTkRFTkNZAEJBRF9HQVRFV0FZAFBMQVkAUFVUAENIRUNLT1VUAEdBVEVXQVlfVElNRU9VVABSRVFVRVNUX1RJTUVPVVQATkVUV09SS19DT05ORUNUX1RJTUVPVVQAQ09OTkVDVElPTl9USU1FT1VUAExPR0lOX1RJTUVPVVQATkVUV09SS19SRUFEX1RJTUVPVVQAUE9TVABNSVNESVJFQ1RFRF9SRVFVRVNUAENMSUVOVF9DTE9TRURfUkVRVUVTVABDTElFTlRfQ0xPU0VEX0xPQURfQkFMQU5DRURfUkVRVUVTVABCQURfUkVRVUVTVABIVFRQX1JFUVVFU1RfU0VOVF9UT19IVFRQU19QT1JUAFJFUE9SVABJTV9BX1RFQVBPVABSRVNFVF9DT05URU5UAE5PX0NPTlRFTlQAUEFSVElBTF9DT05URU5UAEhQRV9JTlZBTElEX0NPTlNUQU5UAEhQRV9DQl9SRVNFVABHRVQASFBFX1NUUklDVABDT05GTElDVABURU1QT1JBUllfUkVESVJFQ1QAUEVSTUFORU5UX1JFRElSRUNUAENPTk5FQ1QATVVMVElfU1RBVFVTAEhQRV9JTlZBTElEX1NUQVRVUwBUT09fTUFOWV9SRVFVRVNUUwBFQVJMWV9ISU5UUwBVTkFWQUlMQUJMRV9GT1JfTEVHQUxfUkVBU09OUwBPUFRJT05TAFNXSVRDSElOR19QUk9UT0NPTFMAVkFSSUFOVF9BTFNPX05FR09USUFURVMATVVMVElQTEVfQ0hPSUNFUwBJTlRFUk5BTF9TRVJWRVJfRVJST1IAV0VCX1NFUlZFUl9VTktOT1dOX0VSUk9SAFJBSUxHVU5fRVJST1IASURFTlRJVFlfUFJPVklERVJfQVVUSEVOVElDQVRJT05fRVJST1IAU1NMX0NFUlRJRklDQVRFX0VSUk9SAElOVkFMSURfWF9GT1JXQVJERURfRk9SAFNFVF9QQVJBTUVURVIAR0VUX1BBUkFNRVRFUgBIUEVfVVNFUgBTRUVfT1RIRVIASFBFX0NCX0NIVU5LX0hFQURFUgBNS0NBTEVOREFSAFNFVFVQAFdFQl9TRVJWRVJfSVNfRE9XTgBURUFSRE9XTgBIUEVfQ0xPU0VEX0NPTk5FQ1RJT04ASEVVUklTVElDX0VYUElSQVRJT04ARElTQ09OTkVDVEVEX09QRVJBVElPTgBOT05fQVVUSE9SSVRBVElWRV9JTkZPUk1BVElPTgBIUEVfSU5WQUxJRF9WRVJTSU9OAEhQRV9DQl9NRVNTQUdFX0JFR0lOAFNJVEVfSVNfRlJPWkVOAEhQRV9JTlZBTElEX0hFQURFUl9UT0tFTgBJTlZBTElEX1RPS0VOAEZPUkJJRERFTgBFTkhBTkNFX1lPVVJfQ0FMTQBIUEVfSU5WQUxJRF9VUkwAQkxPQ0tFRF9CWV9QQVJFTlRBTF9DT05UUk9MAE1LQ09MAEFDTABIUEVfSU5URVJOQUwAUkVRVUVTVF9IRUFERVJfRklFTERTX1RPT19MQVJHRV9VTk9GRklDSUFMAEhQRV9PSwBVTkxJTksAVU5MT0NLAFBSSQBSRVRSWV9XSVRIAEhQRV9JTlZBTElEX0NPTlRFTlRfTEVOR1RIAEhQRV9VTkVYUEVDVEVEX0NPTlRFTlRfTEVOR1RIAEZMVVNIAFBST1BQQVRDSABNLVNFQVJDSABVUklfVE9PX0xPTkcAUFJPQ0VTU0lORwBNSVNDRUxMQU5FT1VTX1BFUlNJU1RFTlRfV0FSTklORwBNSVNDRUxMQU5FT1VTX1dBUk5JTkcASFBFX0lOVkFMSURfVFJBTlNGRVJfRU5DT0RJTkcARXhwZWN0ZWQgQ1JMRgBIUEVfSU5WQUxJRF9DSFVOS19TSVpFAE1PVkUAQ09OVElOVUUASFBFX0NCX1NUQVRVU19DT01QTEVURQBIUEVfQ0JfSEVBREVSU19DT01QTEVURQBIUEVfQ0JfVkVSU0lPTl9DT01QTEVURQBIUEVfQ0JfVVJMX0NPTVBMRVRFAEhQRV9DQl9DSFVOS19DT01QTEVURQBIUEVfQ0JfSEVBREVSX1ZBTFVFX0NPTVBMRVRFAEhQRV9DQl9DSFVOS19FWFRFTlNJT05fVkFMVUVfQ09NUExFVEUASFBFX0NCX0NIVU5LX0VYVEVOU0lPTl9OQU1FX0NPTVBMRVRFAEhQRV9DQl9NRVNTQUdFX0NPTVBMRVRFAEhQRV9DQl9NRVRIT0RfQ09NUExFVEUASFBFX0NCX0hFQURFUl9GSUVMRF9DT01QTEVURQBERUxFVEUASFBFX0lOVkFMSURfRU9GX1NUQVRFAElOVkFMSURfU1NMX0NFUlRJRklDQVRFAFBBVVNFAE5PX1JFU1BPTlNFAFVOU1VQUE9SVEVEX01FRElBX1RZUEUAR09ORQBOT1RfQUNDRVBUQUJMRQBTRVJWSUNFX1VOQVZBSUxBQkxFAFJBTkdFX05PVF9TQVRJU0ZJQUJMRQBPUklHSU5fSVNfVU5SRUFDSEFCTEUAUkVTUE9OU0VfSVNfU1RBTEUAUFVSR0UATUVSR0UAUkVRVUVTVF9IRUFERVJfRklFTERTX1RPT19MQVJHRQBSRVFVRVNUX0hFQURFUl9UT09fTEFSR0UAUEFZTE9BRF9UT09fTEFSR0UASU5TVUZGSUNJRU5UX1NUT1JBR0UASFBFX1BBVVNFRF9VUEdSQURFAEhQRV9QQVVTRURfSDJfVVBHUkFERQBTT1VSQ0UAQU5OT1VOQ0UAVFJBQ0UASFBFX1VORVhQRUNURURfU1BBQ0UAREVTQ1JJQkUAVU5TVUJTQ1JJQkUAUkVDT1JEAEhQRV9JTlZBTElEX01FVEhPRABOT1RfRk9VTkQAUFJPUEZJTkQAVU5CSU5EAFJFQklORABVTkFVVEhPUklaRUQATUVUSE9EX05PVF9BTExPV0VEAEhUVFBfVkVSU0lPTl9OT1RfU1VQUE9SVEVEAEFMUkVBRFlfUkVQT1JURUQAQUNDRVBURUQATk9UX0lNUExFTUVOVEVEAExPT1BfREVURUNURUQASFBFX0NSX0VYUEVDVEVEAEhQRV9MRl9FWFBFQ1RFRABDUkVBVEVEAElNX1VTRUQASFBFX1BBVVNFRABUSU1FT1VUX09DQ1VSRUQAUEFZTUVOVF9SRVFVSVJFRABQUkVDT05ESVRJT05fUkVRVUlSRUQAUFJPWFlfQVVUSEVOVElDQVRJT05fUkVRVUlSRUQATkVUV09SS19BVVRIRU5USUNBVElPTl9SRVFVSVJFRABMRU5HVEhfUkVRVUlSRUQAU1NMX0NFUlRJRklDQVRFX1JFUVVJUkVEAFVQR1JBREVfUkVRVUlSRUQAUEFHRV9FWFBJUkVEAFBSRUNPTkRJVElPTl9GQUlMRUQARVhQRUNUQVRJT05fRkFJTEVEAFJFVkFMSURBVElPTl9GQUlMRUQAU1NMX0hBTkRTSEFLRV9GQUlMRUQATE9DS0VEAFRSQU5TRk9STUFUSU9OX0FQUExJRUQATk9UX01PRElGSUVEAE5PVF9FWFRFTkRFRABCQU5EV0lEVEhfTElNSVRfRVhDRUVERUQAU0lURV9JU19PVkVSTE9BREVEAEhFQUQARXhwZWN0ZWQgSFRUUC8AAF4TAAAmEwAAMBAAAPAXAACdEwAAFRIAADkXAADwEgAAChAAAHUSAACtEgAAghMAAE8UAAB/EAAAoBUAACMUAACJEgAAixQAAE0VAADUEQAAzxQAABAYAADJFgAA3BYAAMERAADgFwAAuxQAAHQUAAB8FQAA5RQAAAgXAAAfEAAAZRUAAKMUAAAoFQAAAhUAAJkVAAAsEAAAixkAAE8PAADUDgAAahAAAM4QAAACFwAAiQ4AAG4TAAAcEwAAZhQAAFYXAADBEwAAzRMAAGwTAABoFwAAZhcAAF8XAAAiEwAAzg8AAGkOAADYDgAAYxYAAMsTAACqDgAAKBcAACYXAADFEwAAXRYAAOgRAABnEwAAZRMAAPIWAABzEwAAHRcAAPkWAADzEQAAzw4AAM4VAAAMEgAAsxEAAKURAABhEAAAMhcAALsTAEH5NQsBAQBBkDYL4AEBAQIBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBB/TcLAQEAQZE4C14CAwICAgICAAACAgACAgACAgICAgICAgICAAQAAAAAAAICAgICAgICAgICAgICAgICAgICAgICAgICAAAAAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAAgACAEH9OQsBAQBBkToLXgIAAgICAgIAAAICAAICAAICAgICAgICAgIAAwAEAAAAAgICAgICAgICAgICAgICAgICAgICAgICAgIAAAACAgICAgICAgICAgICAgICAgICAgICAgICAgICAgACAAIAQfA7Cw1sb3NlZWVwLWFsaXZlAEGJPAsBAQBBoDwL4AEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBBiT4LAQEAQaA+C+cBAQEBAQEBAQEBAQEBAgEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQFjaHVua2VkAEGwwAALXwEBAAEBAQEBAAABAQABAQABAQEBAQEBAQEBAAAAAAAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQABAEGQwgALIWVjdGlvbmVudC1sZW5ndGhvbnJveHktY29ubmVjdGlvbgBBwMIACy1yYW5zZmVyLWVuY29kaW5ncGdyYWRlDQoNCg0KU00NCg0KVFRQL0NFL1RTUC8AQfnCAAsFAQIAAQMAQZDDAAvgAQQBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAEH5xAALBQECAAEDAEGQxQAL4AEEAQEFAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBB+cYACwQBAAABAEGRxwAL3wEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAEH6yAALBAEAAAIAQZDJAAtfAwQAAAQEBAQEBAQEBAQEBQQEBAQEBAQEBAQEBAAEAAYHBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQABAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAQAQfrKAAsEAQAAAQBBkMsACwEBAEGqywALQQIAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwAAAAAAAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAEH6zAALBAEAAAEAQZDNAAsBAQBBms0ACwYCAAAAAAIAQbHNAAs6AwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwBB8M4AC5YBTk9VTkNFRUNLT1VUTkVDVEVURUNSSUJFTFVTSEVURUFEU0VBUkNIUkdFQ1RJVklUWUxFTkRBUlZFT1RJRllQVElPTlNDSFNFQVlTVEFUQ0hHRU9SRElSRUNUT1JUUkNIUEFSQU1FVEVSVVJDRUJTQ1JJQkVBUkRPV05BQ0VJTkROS0NLVUJTQ1JJQkVIVFRQL0FEVFAv', 'base64')
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3434:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { Buffer } = __nccwpck_require__(4573)
|
|
|
|
module.exports = Buffer.from('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', 'base64')
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 172:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.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;
|
|
}
|
|
exports.enumToMap = enumToMap;
|
|
//# sourceMappingURL=utils.js.map
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7501:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { kClients } = __nccwpck_require__(6443)
|
|
const Agent = __nccwpck_require__(7405)
|
|
const {
|
|
kAgent,
|
|
kMockAgentSet,
|
|
kMockAgentGet,
|
|
kDispatches,
|
|
kIsMockActive,
|
|
kNetConnect,
|
|
kGetNetConnect,
|
|
kOptions,
|
|
kFactory
|
|
} = __nccwpck_require__(1117)
|
|
const MockClient = __nccwpck_require__(7365)
|
|
const MockPool = __nccwpck_require__(4004)
|
|
const { matchValue, buildMockOptions } = __nccwpck_require__(3397)
|
|
const { InvalidArgumentError, UndiciError } = __nccwpck_require__(8707)
|
|
const Dispatcher = __nccwpck_require__(883)
|
|
const Pluralizer = __nccwpck_require__(1529)
|
|
const PendingInterceptorsFormatter = __nccwpck_require__(6142)
|
|
|
|
class MockAgent extends Dispatcher {
|
|
constructor (opts) {
|
|
super(opts)
|
|
|
|
this[kNetConnect] = true
|
|
this[kIsMockActive] = true
|
|
|
|
// Instantiate Agent and encapsulate
|
|
if ((opts?.agent && typeof opts.agent.dispatch !== 'function')) {
|
|
throw new InvalidArgumentError('Argument opts.agent must implement Agent')
|
|
}
|
|
const agent = 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) {
|
|
// Call MockAgent.get to perform additional setup before dispatching as normal
|
|
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, 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) {
|
|
// First check if we can immediately find it
|
|
const client = this[kClients].get(origin)
|
|
if (client) {
|
|
return client
|
|
}
|
|
|
|
// If the origin is not a string create a dummy parent pool and return to user
|
|
if (typeof origin !== 'string') {
|
|
const dispatcher = this[kFactory]('http://localhost:9999')
|
|
this[kMockAgentSet](origin, dispatcher)
|
|
return dispatcher
|
|
}
|
|
|
|
// If we match, create a pool and assign the same dispatches
|
|
for (const [keyMatcher, nonExplicitDispatcher] of Array.from(this[kClients])) {
|
|
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[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())
|
|
}
|
|
}
|
|
|
|
module.exports = MockAgent
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7365:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { promisify } = __nccwpck_require__(7975)
|
|
const Client = __nccwpck_require__(3701)
|
|
const { buildMockDispatch } = __nccwpck_require__(3397)
|
|
const {
|
|
kDispatches,
|
|
kMockAgent,
|
|
kClose,
|
|
kOriginalClose,
|
|
kOrigin,
|
|
kOriginalDispatch,
|
|
kConnected
|
|
} = __nccwpck_require__(1117)
|
|
const { MockInterceptor } = __nccwpck_require__(1511)
|
|
const Symbols = __nccwpck_require__(6443)
|
|
const { InvalidArgumentError } = __nccwpck_require__(8707)
|
|
|
|
/**
|
|
* MockClient provides an API that extends the Client to influence the mockDispatches.
|
|
*/
|
|
class MockClient 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])
|
|
}
|
|
}
|
|
|
|
module.exports = MockClient
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2429:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { UndiciError } = __nccwpck_require__(8707)
|
|
|
|
const kMockNotMatchedError = Symbol.for('undici.error.UND_MOCK_ERR_MOCK_NOT_MATCHED')
|
|
|
|
/**
|
|
* The request does not match any registered mock dispatches.
|
|
*/
|
|
class MockNotMatchedError 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'
|
|
}
|
|
|
|
static [Symbol.hasInstance] (instance) {
|
|
return instance && instance[kMockNotMatchedError] === true
|
|
}
|
|
|
|
[kMockNotMatchedError] = true
|
|
}
|
|
|
|
module.exports = {
|
|
MockNotMatchedError
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1511:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { getResponseData, buildKey, addMockDispatch } = __nccwpck_require__(3397)
|
|
const {
|
|
kDispatches,
|
|
kDispatchKey,
|
|
kDefaultHeaders,
|
|
kDefaultTrailers,
|
|
kContentLength,
|
|
kMockDispatch
|
|
} = __nccwpck_require__(1117)
|
|
const { InvalidArgumentError } = __nccwpck_require__(8707)
|
|
const { buildURL } = __nccwpck_require__(3440)
|
|
|
|
/**
|
|
* Defines the scope API for an interceptor reply
|
|
*/
|
|
class MockScope {
|
|
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
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Defines an interceptor for a Mock
|
|
*/
|
|
class MockInterceptor {
|
|
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'
|
|
}
|
|
// See https://github.com/nodejs/undici/issues/1245
|
|
// As per RFC 3986, clients are not supposed to send URI
|
|
// fragments to servers when they retrieve a document,
|
|
if (typeof opts.path === 'string') {
|
|
if (opts.query) {
|
|
opts.path = buildURL(opts.path, opts.query)
|
|
} else {
|
|
// Matches https://github.com/nodejs/undici/blob/main/lib/web/fetch/index.js#L1811
|
|
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 (replyParameters) {
|
|
if (typeof replyParameters.statusCode === 'undefined') {
|
|
throw new InvalidArgumentError('statusCode must be defined')
|
|
}
|
|
if (typeof replyParameters.responseOptions !== 'object' || replyParameters.responseOptions === null) {
|
|
throw new InvalidArgumentError('responseOptions must be an object')
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Mock an undici request with a defined reply.
|
|
*/
|
|
reply (replyOptionsCallbackOrStatusCode) {
|
|
// Values of reply aren't available right now as they
|
|
// can only be available when the reply callback is invoked.
|
|
if (typeof replyOptionsCallbackOrStatusCode === 'function') {
|
|
// We'll first wrap the provided callback in another function,
|
|
// this function will properly resolve the data from the callback
|
|
// when invoked.
|
|
const wrappedDefaultsCallback = (opts) => {
|
|
// Our reply options callback contains the parameter for statusCode, data and options.
|
|
const resolvedData = replyOptionsCallbackOrStatusCode(opts)
|
|
|
|
// Check if it is in the right format
|
|
if (typeof resolvedData !== 'object' || resolvedData === null) {
|
|
throw new InvalidArgumentError('reply options callback must return an object')
|
|
}
|
|
|
|
const replyParameters = { data: '', responseOptions: {}, ...resolvedData }
|
|
this.validateReplyParameters(replyParameters)
|
|
// Since the values can be obtained immediately we return them
|
|
// from this higher order function that will be resolved later.
|
|
return {
|
|
...this.createMockScopeDispatchData(replyParameters)
|
|
}
|
|
}
|
|
|
|
// Add usual dispatch data, but this time set the data parameter to function that will eventually provide data.
|
|
const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback)
|
|
return new MockScope(newMockDispatch)
|
|
}
|
|
|
|
// We can have either one or three parameters, if we get here,
|
|
// we should have 1-3 parameters. So we spread the arguments of
|
|
// this function to obtain the parameters, since replyData will always
|
|
// just be the statusCode.
|
|
const replyParameters = {
|
|
statusCode: replyOptionsCallbackOrStatusCode,
|
|
data: arguments[1] === undefined ? '' : arguments[1],
|
|
responseOptions: arguments[2] === undefined ? {} : arguments[2]
|
|
}
|
|
this.validateReplyParameters(replyParameters)
|
|
|
|
// Send in-already provided data like usual
|
|
const dispatchData = this.createMockScopeDispatchData(replyParameters)
|
|
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
|
|
}
|
|
}
|
|
|
|
module.exports.MockInterceptor = MockInterceptor
|
|
module.exports.MockScope = MockScope
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4004:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { promisify } = __nccwpck_require__(7975)
|
|
const Pool = __nccwpck_require__(628)
|
|
const { buildMockDispatch } = __nccwpck_require__(3397)
|
|
const {
|
|
kDispatches,
|
|
kMockAgent,
|
|
kClose,
|
|
kOriginalClose,
|
|
kOrigin,
|
|
kOriginalDispatch,
|
|
kConnected
|
|
} = __nccwpck_require__(1117)
|
|
const { MockInterceptor } = __nccwpck_require__(1511)
|
|
const Symbols = __nccwpck_require__(6443)
|
|
const { InvalidArgumentError } = __nccwpck_require__(8707)
|
|
|
|
/**
|
|
* MockPool provides an API that extends the Pool to influence the mockDispatches.
|
|
*/
|
|
class MockPool 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])
|
|
}
|
|
}
|
|
|
|
module.exports = MockPool
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1117:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
module.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')
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3397:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { MockNotMatchedError } = __nccwpck_require__(2429)
|
|
const {
|
|
kDispatches,
|
|
kMockAgent,
|
|
kOriginalDispatch,
|
|
kOrigin,
|
|
kGetNetConnect
|
|
} = __nccwpck_require__(1117)
|
|
const { buildURL } = __nccwpck_require__(3440)
|
|
const { STATUS_CODES } = __nccwpck_require__(7067)
|
|
const {
|
|
types: {
|
|
isPromise
|
|
}
|
|
} = __nccwpck_require__(7975)
|
|
|
|
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]
|
|
})
|
|
)
|
|
}
|
|
|
|
/**
|
|
* @param {import('../../index').Headers|string[]|Record<string, string>} headers
|
|
* @param {string} key
|
|
*/
|
|
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 undefined
|
|
} else if (typeof headers.get === 'function') {
|
|
return headers.get(key)
|
|
} else {
|
|
return lowerCaseEntries(headers)[key.toLocaleLowerCase()]
|
|
}
|
|
}
|
|
|
|
/** @param {string[]} headers */
|
|
function buildHeadersFromArray (headers) { // fetch HeadersList
|
|
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 (mockDispatch, headers) {
|
|
if (typeof mockDispatch.headers === 'function') {
|
|
if (Array.isArray(headers)) { // fetch HeadersList
|
|
headers = buildHeadersFromArray(headers)
|
|
}
|
|
return mockDispatch.headers(headers ? lowerCaseEntries(headers) : {})
|
|
}
|
|
if (typeof mockDispatch.headers === 'undefined') {
|
|
return true
|
|
}
|
|
if (typeof headers !== 'object' || typeof mockDispatch.headers !== 'object') {
|
|
return false
|
|
}
|
|
|
|
for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch.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 (mockDispatch, { path, method, body, headers }) {
|
|
const pathMatch = matchValue(mockDispatch.path, path)
|
|
const methodMatch = matchValue(mockDispatch.method, method)
|
|
const bodyMatch = typeof mockDispatch.body !== 'undefined' ? matchValue(mockDispatch.body, body) : true
|
|
const headersMatch = matchHeaders(mockDispatch, headers)
|
|
return pathMatch && methodMatch && bodyMatch && headersMatch
|
|
}
|
|
|
|
function getResponseData (data) {
|
|
if (Buffer.isBuffer(data)) {
|
|
return data
|
|
} else if (data instanceof Uint8Array) {
|
|
return data
|
|
} else if (data instanceof ArrayBuffer) {
|
|
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
|
|
|
|
// Match path
|
|
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}'`)
|
|
}
|
|
|
|
// Match method
|
|
matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method))
|
|
if (matchedMockDispatches.length === 0) {
|
|
throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}' on path '${resolvedPath}'`)
|
|
}
|
|
|
|
// Match body
|
|
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}' on path '${resolvedPath}'`)
|
|
}
|
|
|
|
// Match headers
|
|
matchedMockDispatches = matchedMockDispatches.filter((mockDispatch) => matchHeaders(mockDispatch, key.headers))
|
|
if (matchedMockDispatches.length === 0) {
|
|
const headers = typeof key.headers === 'object' ? JSON.stringify(key.headers) : key.headers
|
|
throw new MockNotMatchedError(`Mock dispatch not matched for headers '${headers}' on path '${resolvedPath}'`)
|
|
}
|
|
|
|
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) {
|
|
const keys = Object.keys(data)
|
|
const result = []
|
|
for (let i = 0; i < keys.length; ++i) {
|
|
const key = keys[i]
|
|
const value = data[key]
|
|
const name = Buffer.from(`${key}`)
|
|
if (Array.isArray(value)) {
|
|
for (let j = 0; j < value.length; ++j) {
|
|
result.push(name, Buffer.from(`${value[j]}`))
|
|
}
|
|
} else {
|
|
result.push(name, Buffer.from(`${value}`))
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
|
|
* @param {number} statusCode
|
|
*/
|
|
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')
|
|
}
|
|
|
|
/**
|
|
* Mock dispatch function used to simulate undici dispatches
|
|
*/
|
|
function mockDispatch (opts, handler) {
|
|
// Get mock dispatch from built key
|
|
const key = buildKey(opts)
|
|
const mockDispatch = getMockDispatch(this[kDispatches], key)
|
|
|
|
mockDispatch.timesInvoked++
|
|
|
|
// Here's where we resolve a callback if a callback is present for the dispatch data.
|
|
if (mockDispatch.data.callback) {
|
|
mockDispatch.data = { ...mockDispatch.data, ...mockDispatch.data.callback(opts) }
|
|
}
|
|
|
|
// Parse mockDispatch data
|
|
const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch
|
|
const { timesInvoked, times } = mockDispatch
|
|
|
|
// If it's used up and not persistent, mark as consumed
|
|
mockDispatch.consumed = !persist && timesInvoked >= times
|
|
mockDispatch.pending = timesInvoked < times
|
|
|
|
// If specified, trigger dispatch error
|
|
if (error !== null) {
|
|
deleteMockDispatch(this[kDispatches], key)
|
|
handler.onError(error)
|
|
return true
|
|
}
|
|
|
|
// Handle the request with a delay if necessary
|
|
if (typeof delay === 'number' && delay > 0) {
|
|
setTimeout(() => {
|
|
handleReply(this[kDispatches])
|
|
}, delay)
|
|
} else {
|
|
handleReply(this[kDispatches])
|
|
}
|
|
|
|
function handleReply (mockDispatches, _data = data) {
|
|
// fetch's HeadersList is a 1D string array
|
|
const optsHeaders = Array.isArray(opts.headers)
|
|
? buildHeadersFromArray(opts.headers)
|
|
: opts.headers
|
|
const body = typeof _data === 'function'
|
|
? _data({ ...opts, headers: optsHeaders })
|
|
: _data
|
|
|
|
// util.types.isPromise is likely needed for jest.
|
|
if (isPromise(body)) {
|
|
// If handleReply is asynchronous, throwing an error
|
|
// in the callback will reject the promise, rather than
|
|
// synchronously throw the error, which breaks some tests.
|
|
// Rather, we wait for the callback to resolve if it is a
|
|
// promise, and then re-run handleReply with the new body.
|
|
body.then((newData) => handleReply(mockDispatches, newData))
|
|
return
|
|
}
|
|
|
|
const responseData = getResponseData(body)
|
|
const responseHeaders = generateKeyValues(headers)
|
|
const responseTrailers = generateKeyValues(trailers)
|
|
|
|
handler.onConnect?.(err => handler.onError(err), null)
|
|
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
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
getResponseData,
|
|
getMockDispatch,
|
|
addMockDispatch,
|
|
deleteMockDispatch,
|
|
buildKey,
|
|
generateKeyValues,
|
|
matchValue,
|
|
getResponse,
|
|
getStatusText,
|
|
mockDispatch,
|
|
buildMockDispatch,
|
|
checkNetConnect,
|
|
buildMockOptions,
|
|
getHeaderByName,
|
|
buildHeadersFromArray
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6142:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { Transform } = __nccwpck_require__(7075)
|
|
const { Console } = __nccwpck_require__(7540)
|
|
|
|
const PERSISTENT = process.versions.icu ? '✅' : 'Y '
|
|
const NOT_PERSISTENT = process.versions.icu ? '❌' : 'N '
|
|
|
|
/**
|
|
* Gets the output of `console.table(…)` as a string.
|
|
*/
|
|
module.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 ? PERSISTENT : NOT_PERSISTENT,
|
|
Invocations: timesInvoked,
|
|
Remaining: persist ? Infinity : times - timesInvoked
|
|
}))
|
|
|
|
this.logger.table(withPrettyHeaders)
|
|
return this.transform.read().toString()
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1529:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
const singulars = {
|
|
pronoun: 'it',
|
|
is: 'is',
|
|
was: 'was',
|
|
this: 'this'
|
|
}
|
|
|
|
const plurals = {
|
|
pronoun: 'they',
|
|
is: 'are',
|
|
was: 'were',
|
|
this: 'these'
|
|
}
|
|
|
|
module.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 }
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6603:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
/**
|
|
* This module offers an optimized timer implementation designed for scenarios
|
|
* where high precision is not critical.
|
|
*
|
|
* The timer achieves faster performance by using a low-resolution approach,
|
|
* with an accuracy target of within 500ms. This makes it particularly useful
|
|
* for timers with delays of 1 second or more, where exact timing is less
|
|
* crucial.
|
|
*
|
|
* It's important to note that Node.js timers are inherently imprecise, as
|
|
* delays can occur due to the event loop being blocked by other operations.
|
|
* Consequently, timers may trigger later than their scheduled time.
|
|
*/
|
|
|
|
/**
|
|
* The fastNow variable contains the internal fast timer clock value.
|
|
*
|
|
* @type {number}
|
|
*/
|
|
let fastNow = 0
|
|
|
|
/**
|
|
* RESOLUTION_MS represents the target resolution time in milliseconds.
|
|
*
|
|
* @type {number}
|
|
* @default 1000
|
|
*/
|
|
const RESOLUTION_MS = 1e3
|
|
|
|
/**
|
|
* TICK_MS defines the desired interval in milliseconds between each tick.
|
|
* The target value is set to half the resolution time, minus 1 ms, to account
|
|
* for potential event loop overhead.
|
|
*
|
|
* @type {number}
|
|
* @default 499
|
|
*/
|
|
const TICK_MS = (RESOLUTION_MS >> 1) - 1
|
|
|
|
/**
|
|
* fastNowTimeout is a Node.js timer used to manage and process
|
|
* the FastTimers stored in the `fastTimers` array.
|
|
*
|
|
* @type {NodeJS.Timeout}
|
|
*/
|
|
let fastNowTimeout
|
|
|
|
/**
|
|
* The kFastTimer symbol is used to identify FastTimer instances.
|
|
*
|
|
* @type {Symbol}
|
|
*/
|
|
const kFastTimer = Symbol('kFastTimer')
|
|
|
|
/**
|
|
* The fastTimers array contains all active FastTimers.
|
|
*
|
|
* @type {FastTimer[]}
|
|
*/
|
|
const fastTimers = []
|
|
|
|
/**
|
|
* These constants represent the various states of a FastTimer.
|
|
*/
|
|
|
|
/**
|
|
* The `NOT_IN_LIST` constant indicates that the FastTimer is not included
|
|
* in the `fastTimers` array. Timers with this status will not be processed
|
|
* during the next tick by the `onTick` function.
|
|
*
|
|
* A FastTimer can be re-added to the `fastTimers` array by invoking the
|
|
* `refresh` method on the FastTimer instance.
|
|
*
|
|
* @type {-2}
|
|
*/
|
|
const NOT_IN_LIST = -2
|
|
|
|
/**
|
|
* The `TO_BE_CLEARED` constant indicates that the FastTimer is scheduled
|
|
* for removal from the `fastTimers` array. A FastTimer in this state will
|
|
* be removed in the next tick by the `onTick` function and will no longer
|
|
* be processed.
|
|
*
|
|
* This status is also set when the `clear` method is called on the FastTimer instance.
|
|
*
|
|
* @type {-1}
|
|
*/
|
|
const TO_BE_CLEARED = -1
|
|
|
|
/**
|
|
* The `PENDING` constant signifies that the FastTimer is awaiting processing
|
|
* in the next tick by the `onTick` function. Timers with this status will have
|
|
* their `_idleStart` value set and their status updated to `ACTIVE` in the next tick.
|
|
*
|
|
* @type {0}
|
|
*/
|
|
const PENDING = 0
|
|
|
|
/**
|
|
* The `ACTIVE` constant indicates that the FastTimer is active and waiting
|
|
* for its timer to expire. During the next tick, the `onTick` function will
|
|
* check if the timer has expired, and if so, it will execute the associated callback.
|
|
*
|
|
* @type {1}
|
|
*/
|
|
const ACTIVE = 1
|
|
|
|
/**
|
|
* The onTick function processes the fastTimers array.
|
|
*
|
|
* @returns {void}
|
|
*/
|
|
function onTick () {
|
|
/**
|
|
* Increment the fastNow value by the TICK_MS value, despite the actual time
|
|
* that has passed since the last tick. This approach ensures independence
|
|
* from the system clock and delays caused by a blocked event loop.
|
|
*
|
|
* @type {number}
|
|
*/
|
|
fastNow += TICK_MS
|
|
|
|
/**
|
|
* The `idx` variable is used to iterate over the `fastTimers` array.
|
|
* Expired timers are removed by replacing them with the last element in the array.
|
|
* Consequently, `idx` is only incremented when the current element is not removed.
|
|
*
|
|
* @type {number}
|
|
*/
|
|
let idx = 0
|
|
|
|
/**
|
|
* The len variable will contain the length of the fastTimers array
|
|
* and will be decremented when a FastTimer should be removed from the
|
|
* fastTimers array.
|
|
*
|
|
* @type {number}
|
|
*/
|
|
let len = fastTimers.length
|
|
|
|
while (idx < len) {
|
|
/**
|
|
* @type {FastTimer}
|
|
*/
|
|
const timer = fastTimers[idx]
|
|
|
|
// If the timer is in the ACTIVE state and the timer has expired, it will
|
|
// be processed in the next tick.
|
|
if (timer._state === PENDING) {
|
|
// Set the _idleStart value to the fastNow value minus the TICK_MS value
|
|
// to account for the time the timer was in the PENDING state.
|
|
timer._idleStart = fastNow - TICK_MS
|
|
timer._state = ACTIVE
|
|
} else if (
|
|
timer._state === ACTIVE &&
|
|
fastNow >= timer._idleStart + timer._idleTimeout
|
|
) {
|
|
timer._state = TO_BE_CLEARED
|
|
timer._idleStart = -1
|
|
timer._onTimeout(timer._timerArg)
|
|
}
|
|
|
|
if (timer._state === TO_BE_CLEARED) {
|
|
timer._state = NOT_IN_LIST
|
|
|
|
// Move the last element to the current index and decrement len if it is
|
|
// not the only element in the array.
|
|
if (--len !== 0) {
|
|
fastTimers[idx] = fastTimers[len]
|
|
}
|
|
} else {
|
|
++idx
|
|
}
|
|
}
|
|
|
|
// Set the length of the fastTimers array to the new length and thus
|
|
// removing the excess FastTimers elements from the array.
|
|
fastTimers.length = len
|
|
|
|
// If there are still active FastTimers in the array, refresh the Timer.
|
|
// If there are no active FastTimers, the timer will be refreshed again
|
|
// when a new FastTimer is instantiated.
|
|
if (fastTimers.length !== 0) {
|
|
refreshTimeout()
|
|
}
|
|
}
|
|
|
|
function refreshTimeout () {
|
|
// If the fastNowTimeout is already set, refresh it.
|
|
if (fastNowTimeout) {
|
|
fastNowTimeout.refresh()
|
|
// fastNowTimeout is not instantiated yet, create a new Timer.
|
|
} else {
|
|
clearTimeout(fastNowTimeout)
|
|
fastNowTimeout = setTimeout(onTick, TICK_MS)
|
|
|
|
// If the Timer has an unref method, call it to allow the process to exit if
|
|
// there are no other active handles.
|
|
if (fastNowTimeout.unref) {
|
|
fastNowTimeout.unref()
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The `FastTimer` class is a data structure designed to store and manage
|
|
* timer information.
|
|
*/
|
|
class FastTimer {
|
|
[kFastTimer] = true
|
|
|
|
/**
|
|
* The state of the timer, which can be one of the following:
|
|
* - NOT_IN_LIST (-2)
|
|
* - TO_BE_CLEARED (-1)
|
|
* - PENDING (0)
|
|
* - ACTIVE (1)
|
|
*
|
|
* @type {-2|-1|0|1}
|
|
* @private
|
|
*/
|
|
_state = NOT_IN_LIST
|
|
|
|
/**
|
|
* The number of milliseconds to wait before calling the callback.
|
|
*
|
|
* @type {number}
|
|
* @private
|
|
*/
|
|
_idleTimeout = -1
|
|
|
|
/**
|
|
* The time in milliseconds when the timer was started. This value is used to
|
|
* calculate when the timer should expire.
|
|
*
|
|
* @type {number}
|
|
* @default -1
|
|
* @private
|
|
*/
|
|
_idleStart = -1
|
|
|
|
/**
|
|
* The function to be executed when the timer expires.
|
|
* @type {Function}
|
|
* @private
|
|
*/
|
|
_onTimeout
|
|
|
|
/**
|
|
* The argument to be passed to the callback when the timer expires.
|
|
*
|
|
* @type {*}
|
|
* @private
|
|
*/
|
|
_timerArg
|
|
|
|
/**
|
|
* @constructor
|
|
* @param {Function} callback A function to be executed after the timer
|
|
* expires.
|
|
* @param {number} delay The time, in milliseconds that the timer should wait
|
|
* before the specified function or code is executed.
|
|
* @param {*} arg
|
|
*/
|
|
constructor (callback, delay, arg) {
|
|
this._onTimeout = callback
|
|
this._idleTimeout = delay
|
|
this._timerArg = arg
|
|
|
|
this.refresh()
|
|
}
|
|
|
|
/**
|
|
* Sets the timer's start time to the current time, and reschedules the timer
|
|
* to call its callback at the previously specified duration adjusted to the
|
|
* current time.
|
|
* Using this on a timer that has already called its callback will reactivate
|
|
* the timer.
|
|
*
|
|
* @returns {void}
|
|
*/
|
|
refresh () {
|
|
// In the special case that the timer is not in the list of active timers,
|
|
// add it back to the array to be processed in the next tick by the onTick
|
|
// function.
|
|
if (this._state === NOT_IN_LIST) {
|
|
fastTimers.push(this)
|
|
}
|
|
|
|
// If the timer is the only active timer, refresh the fastNowTimeout for
|
|
// better resolution.
|
|
if (!fastNowTimeout || fastTimers.length === 1) {
|
|
refreshTimeout()
|
|
}
|
|
|
|
// Setting the state to PENDING will cause the timer to be reset in the
|
|
// next tick by the onTick function.
|
|
this._state = PENDING
|
|
}
|
|
|
|
/**
|
|
* The `clear` method cancels the timer, preventing it from executing.
|
|
*
|
|
* @returns {void}
|
|
* @private
|
|
*/
|
|
clear () {
|
|
// Set the state to TO_BE_CLEARED to mark the timer for removal in the next
|
|
// tick by the onTick function.
|
|
this._state = TO_BE_CLEARED
|
|
|
|
// Reset the _idleStart value to -1 to indicate that the timer is no longer
|
|
// active.
|
|
this._idleStart = -1
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This module exports a setTimeout and clearTimeout function that can be
|
|
* used as a drop-in replacement for the native functions.
|
|
*/
|
|
module.exports = {
|
|
/**
|
|
* The setTimeout() method sets a timer which executes a function once the
|
|
* timer expires.
|
|
* @param {Function} callback A function to be executed after the timer
|
|
* expires.
|
|
* @param {number} delay The time, in milliseconds that the timer should
|
|
* wait before the specified function or code is executed.
|
|
* @param {*} [arg] An optional argument to be passed to the callback function
|
|
* when the timer expires.
|
|
* @returns {NodeJS.Timeout|FastTimer}
|
|
*/
|
|
setTimeout (callback, delay, arg) {
|
|
// If the delay is less than or equal to the RESOLUTION_MS value return a
|
|
// native Node.js Timer instance.
|
|
return delay <= RESOLUTION_MS
|
|
? setTimeout(callback, delay, arg)
|
|
: new FastTimer(callback, delay, arg)
|
|
},
|
|
/**
|
|
* The clearTimeout method cancels an instantiated Timer previously created
|
|
* by calling setTimeout.
|
|
*
|
|
* @param {NodeJS.Timeout|FastTimer} timeout
|
|
*/
|
|
clearTimeout (timeout) {
|
|
// If the timeout is a FastTimer, call its own clear method.
|
|
if (timeout[kFastTimer]) {
|
|
/**
|
|
* @type {FastTimer}
|
|
*/
|
|
timeout.clear()
|
|
// Otherwise it is an instance of a native NodeJS.Timeout, so call the
|
|
// Node.js native clearTimeout function.
|
|
} else {
|
|
clearTimeout(timeout)
|
|
}
|
|
},
|
|
/**
|
|
* The setFastTimeout() method sets a fastTimer which executes a function once
|
|
* the timer expires.
|
|
* @param {Function} callback A function to be executed after the timer
|
|
* expires.
|
|
* @param {number} delay The time, in milliseconds that the timer should
|
|
* wait before the specified function or code is executed.
|
|
* @param {*} [arg] An optional argument to be passed to the callback function
|
|
* when the timer expires.
|
|
* @returns {FastTimer}
|
|
*/
|
|
setFastTimeout (callback, delay, arg) {
|
|
return new FastTimer(callback, delay, arg)
|
|
},
|
|
/**
|
|
* The clearTimeout method cancels an instantiated FastTimer previously
|
|
* created by calling setFastTimeout.
|
|
*
|
|
* @param {FastTimer} timeout
|
|
*/
|
|
clearFastTimeout (timeout) {
|
|
timeout.clear()
|
|
},
|
|
/**
|
|
* The now method returns the value of the internal fast timer clock.
|
|
*
|
|
* @returns {number}
|
|
*/
|
|
now () {
|
|
return fastNow
|
|
},
|
|
/**
|
|
* Trigger the onTick function to process the fastTimers array.
|
|
* Exported for testing purposes only.
|
|
* Marking as deprecated to discourage any use outside of testing.
|
|
* @deprecated
|
|
* @param {number} [delay=0] The delay in milliseconds to add to the now value.
|
|
*/
|
|
tick (delay = 0) {
|
|
fastNow += delay - RESOLUTION_MS + 1
|
|
onTick()
|
|
onTick()
|
|
},
|
|
/**
|
|
* Reset FastTimers.
|
|
* Exported for testing purposes only.
|
|
* Marking as deprecated to discourage any use outside of testing.
|
|
* @deprecated
|
|
*/
|
|
reset () {
|
|
fastNow = 0
|
|
fastTimers.length = 0
|
|
clearTimeout(fastNowTimeout)
|
|
fastNowTimeout = null
|
|
},
|
|
/**
|
|
* Exporting for testing purposes only.
|
|
* Marking as deprecated to discourage any use outside of testing.
|
|
* @deprecated
|
|
*/
|
|
kFastTimer
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9634:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { kConstruct } = __nccwpck_require__(109)
|
|
const { urlEquals, getFieldValues } = __nccwpck_require__(6798)
|
|
const { kEnumerableProperty, isDisturbed } = __nccwpck_require__(3440)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const { Response, cloneResponse, fromInnerResponse } = __nccwpck_require__(9051)
|
|
const { Request, fromInnerRequest } = __nccwpck_require__(9967)
|
|
const { kState } = __nccwpck_require__(3627)
|
|
const { fetching } = __nccwpck_require__(4398)
|
|
const { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = __nccwpck_require__(3168)
|
|
const assert = __nccwpck_require__(4589)
|
|
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#dfn-cache-batch-operation
|
|
* @typedef {Object} CacheBatchOperation
|
|
* @property {'delete' | 'put'} type
|
|
* @property {any} request
|
|
* @property {any} response
|
|
* @property {import('../../types/cache').CacheQueryOptions} options
|
|
*/
|
|
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#dfn-request-response-list
|
|
* @typedef {[any, any][]} requestResponseList
|
|
*/
|
|
|
|
class Cache {
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list
|
|
* @type {requestResponseList}
|
|
*/
|
|
#relevantRequestResponseList
|
|
|
|
constructor () {
|
|
if (arguments[0] !== kConstruct) {
|
|
webidl.illegalConstructor()
|
|
}
|
|
|
|
webidl.util.markAsUncloneable(this)
|
|
this.#relevantRequestResponseList = arguments[1]
|
|
}
|
|
|
|
async match (request, options = {}) {
|
|
webidl.brandCheck(this, Cache)
|
|
|
|
const prefix = 'Cache.match'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
request = webidl.converters.RequestInfo(request, prefix, 'request')
|
|
options = webidl.converters.CacheQueryOptions(options, prefix, 'options')
|
|
|
|
const p = this.#internalMatchAll(request, options, 1)
|
|
|
|
if (p.length === 0) {
|
|
return
|
|
}
|
|
|
|
return p[0]
|
|
}
|
|
|
|
async matchAll (request = undefined, options = {}) {
|
|
webidl.brandCheck(this, Cache)
|
|
|
|
const prefix = 'Cache.matchAll'
|
|
if (request !== undefined) request = webidl.converters.RequestInfo(request, prefix, 'request')
|
|
options = webidl.converters.CacheQueryOptions(options, prefix, 'options')
|
|
|
|
return this.#internalMatchAll(request, options)
|
|
}
|
|
|
|
async add (request) {
|
|
webidl.brandCheck(this, Cache)
|
|
|
|
const prefix = 'Cache.add'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
request = webidl.converters.RequestInfo(request, prefix, 'request')
|
|
|
|
// 1.
|
|
const requests = [request]
|
|
|
|
// 2.
|
|
const responseArrayPromise = this.addAll(requests)
|
|
|
|
// 3.
|
|
return await responseArrayPromise
|
|
}
|
|
|
|
async addAll (requests) {
|
|
webidl.brandCheck(this, Cache)
|
|
|
|
const prefix = 'Cache.addAll'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
// 1.
|
|
const responsePromises = []
|
|
|
|
// 2.
|
|
const requestList = []
|
|
|
|
// 3.
|
|
for (let request of requests) {
|
|
if (request === undefined) {
|
|
throw webidl.errors.conversionFailed({
|
|
prefix,
|
|
argument: 'Argument 1',
|
|
types: ['undefined is not allowed']
|
|
})
|
|
}
|
|
|
|
request = webidl.converters.RequestInfo(request)
|
|
|
|
if (typeof request === 'string') {
|
|
continue
|
|
}
|
|
|
|
// 3.1
|
|
const r = request[kState]
|
|
|
|
// 3.2
|
|
if (!urlIsHttpHttpsScheme(r.url) || r.method !== 'GET') {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: 'Expected http/s scheme when method is not GET.'
|
|
})
|
|
}
|
|
}
|
|
|
|
// 4.
|
|
/** @type {ReturnType<typeof fetching>[]} */
|
|
const fetchControllers = []
|
|
|
|
// 5.
|
|
for (const request of requests) {
|
|
// 5.1
|
|
const r = new Request(request)[kState]
|
|
|
|
// 5.2
|
|
if (!urlIsHttpHttpsScheme(r.url)) {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: 'Expected http/s scheme.'
|
|
})
|
|
}
|
|
|
|
// 5.4
|
|
r.initiator = 'fetch'
|
|
r.destination = 'subresource'
|
|
|
|
// 5.5
|
|
requestList.push(r)
|
|
|
|
// 5.6
|
|
const responsePromise = createDeferredPromise()
|
|
|
|
// 5.7
|
|
fetchControllers.push(fetching({
|
|
request: r,
|
|
processResponse (response) {
|
|
// 1.
|
|
if (response.type === 'error' || response.status === 206 || response.status < 200 || response.status > 299) {
|
|
responsePromise.reject(webidl.errors.exception({
|
|
header: 'Cache.addAll',
|
|
message: 'Received an invalid status code or the request failed.'
|
|
}))
|
|
} else if (response.headersList.contains('vary')) { // 2.
|
|
// 2.1
|
|
const fieldValues = getFieldValues(response.headersList.get('vary'))
|
|
|
|
// 2.2
|
|
for (const fieldValue of fieldValues) {
|
|
// 2.2.1
|
|
if (fieldValue === '*') {
|
|
responsePromise.reject(webidl.errors.exception({
|
|
header: 'Cache.addAll',
|
|
message: 'invalid vary field value'
|
|
}))
|
|
|
|
for (const controller of fetchControllers) {
|
|
controller.abort()
|
|
}
|
|
|
|
return
|
|
}
|
|
}
|
|
}
|
|
},
|
|
processResponseEndOfBody (response) {
|
|
// 1.
|
|
if (response.aborted) {
|
|
responsePromise.reject(new DOMException('aborted', 'AbortError'))
|
|
return
|
|
}
|
|
|
|
// 2.
|
|
responsePromise.resolve(response)
|
|
}
|
|
}))
|
|
|
|
// 5.8
|
|
responsePromises.push(responsePromise.promise)
|
|
}
|
|
|
|
// 6.
|
|
const p = Promise.all(responsePromises)
|
|
|
|
// 7.
|
|
const responses = await p
|
|
|
|
// 7.1
|
|
const operations = []
|
|
|
|
// 7.2
|
|
let index = 0
|
|
|
|
// 7.3
|
|
for (const response of responses) {
|
|
// 7.3.1
|
|
/** @type {CacheBatchOperation} */
|
|
const operation = {
|
|
type: 'put', // 7.3.2
|
|
request: requestList[index], // 7.3.3
|
|
response // 7.3.4
|
|
}
|
|
|
|
operations.push(operation) // 7.3.5
|
|
|
|
index++ // 7.3.6
|
|
}
|
|
|
|
// 7.5
|
|
const cacheJobPromise = createDeferredPromise()
|
|
|
|
// 7.6.1
|
|
let errorData = null
|
|
|
|
// 7.6.2
|
|
try {
|
|
this.#batchCacheOperations(operations)
|
|
} catch (e) {
|
|
errorData = e
|
|
}
|
|
|
|
// 7.6.3
|
|
queueMicrotask(() => {
|
|
// 7.6.3.1
|
|
if (errorData === null) {
|
|
cacheJobPromise.resolve(undefined)
|
|
} else {
|
|
// 7.6.3.2
|
|
cacheJobPromise.reject(errorData)
|
|
}
|
|
})
|
|
|
|
// 7.7
|
|
return cacheJobPromise.promise
|
|
}
|
|
|
|
async put (request, response) {
|
|
webidl.brandCheck(this, Cache)
|
|
|
|
const prefix = 'Cache.put'
|
|
webidl.argumentLengthCheck(arguments, 2, prefix)
|
|
|
|
request = webidl.converters.RequestInfo(request, prefix, 'request')
|
|
response = webidl.converters.Response(response, prefix, 'response')
|
|
|
|
// 1.
|
|
let innerRequest = null
|
|
|
|
// 2.
|
|
if (request instanceof Request) {
|
|
innerRequest = request[kState]
|
|
} else { // 3.
|
|
innerRequest = new Request(request)[kState]
|
|
}
|
|
|
|
// 4.
|
|
if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== 'GET') {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: 'Expected an http/s scheme when method is not GET'
|
|
})
|
|
}
|
|
|
|
// 5.
|
|
const innerResponse = response[kState]
|
|
|
|
// 6.
|
|
if (innerResponse.status === 206) {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: 'Got 206 status'
|
|
})
|
|
}
|
|
|
|
// 7.
|
|
if (innerResponse.headersList.contains('vary')) {
|
|
// 7.1.
|
|
const fieldValues = getFieldValues(innerResponse.headersList.get('vary'))
|
|
|
|
// 7.2.
|
|
for (const fieldValue of fieldValues) {
|
|
// 7.2.1
|
|
if (fieldValue === '*') {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: 'Got * vary field value'
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// 8.
|
|
if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: 'Response body is locked or disturbed'
|
|
})
|
|
}
|
|
|
|
// 9.
|
|
const clonedResponse = cloneResponse(innerResponse)
|
|
|
|
// 10.
|
|
const bodyReadPromise = createDeferredPromise()
|
|
|
|
// 11.
|
|
if (innerResponse.body != null) {
|
|
// 11.1
|
|
const stream = innerResponse.body.stream
|
|
|
|
// 11.2
|
|
const reader = stream.getReader()
|
|
|
|
// 11.3
|
|
readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject)
|
|
} else {
|
|
bodyReadPromise.resolve(undefined)
|
|
}
|
|
|
|
// 12.
|
|
/** @type {CacheBatchOperation[]} */
|
|
const operations = []
|
|
|
|
// 13.
|
|
/** @type {CacheBatchOperation} */
|
|
const operation = {
|
|
type: 'put', // 14.
|
|
request: innerRequest, // 15.
|
|
response: clonedResponse // 16.
|
|
}
|
|
|
|
// 17.
|
|
operations.push(operation)
|
|
|
|
// 19.
|
|
const bytes = await bodyReadPromise.promise
|
|
|
|
if (clonedResponse.body != null) {
|
|
clonedResponse.body.source = bytes
|
|
}
|
|
|
|
// 19.1
|
|
const cacheJobPromise = createDeferredPromise()
|
|
|
|
// 19.2.1
|
|
let errorData = null
|
|
|
|
// 19.2.2
|
|
try {
|
|
this.#batchCacheOperations(operations)
|
|
} catch (e) {
|
|
errorData = e
|
|
}
|
|
|
|
// 19.2.3
|
|
queueMicrotask(() => {
|
|
// 19.2.3.1
|
|
if (errorData === null) {
|
|
cacheJobPromise.resolve()
|
|
} else { // 19.2.3.2
|
|
cacheJobPromise.reject(errorData)
|
|
}
|
|
})
|
|
|
|
return cacheJobPromise.promise
|
|
}
|
|
|
|
async delete (request, options = {}) {
|
|
webidl.brandCheck(this, Cache)
|
|
|
|
const prefix = 'Cache.delete'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
request = webidl.converters.RequestInfo(request, prefix, 'request')
|
|
options = webidl.converters.CacheQueryOptions(options, prefix, 'options')
|
|
|
|
/**
|
|
* @type {Request}
|
|
*/
|
|
let r = null
|
|
|
|
if (request instanceof Request) {
|
|
r = request[kState]
|
|
|
|
if (r.method !== 'GET' && !options.ignoreMethod) {
|
|
return false
|
|
}
|
|
} else {
|
|
assert(typeof request === 'string')
|
|
|
|
r = new Request(request)[kState]
|
|
}
|
|
|
|
/** @type {CacheBatchOperation[]} */
|
|
const operations = []
|
|
|
|
/** @type {CacheBatchOperation} */
|
|
const operation = {
|
|
type: 'delete',
|
|
request: r,
|
|
options
|
|
}
|
|
|
|
operations.push(operation)
|
|
|
|
const cacheJobPromise = createDeferredPromise()
|
|
|
|
let errorData = null
|
|
let requestResponses
|
|
|
|
try {
|
|
requestResponses = this.#batchCacheOperations(operations)
|
|
} catch (e) {
|
|
errorData = e
|
|
}
|
|
|
|
queueMicrotask(() => {
|
|
if (errorData === null) {
|
|
cacheJobPromise.resolve(!!requestResponses?.length)
|
|
} else {
|
|
cacheJobPromise.reject(errorData)
|
|
}
|
|
})
|
|
|
|
return cacheJobPromise.promise
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#dom-cache-keys
|
|
* @param {any} request
|
|
* @param {import('../../types/cache').CacheQueryOptions} options
|
|
* @returns {Promise<readonly Request[]>}
|
|
*/
|
|
async keys (request = undefined, options = {}) {
|
|
webidl.brandCheck(this, Cache)
|
|
|
|
const prefix = 'Cache.keys'
|
|
|
|
if (request !== undefined) request = webidl.converters.RequestInfo(request, prefix, 'request')
|
|
options = webidl.converters.CacheQueryOptions(options, prefix, 'options')
|
|
|
|
// 1.
|
|
let r = null
|
|
|
|
// 2.
|
|
if (request !== undefined) {
|
|
// 2.1
|
|
if (request instanceof Request) {
|
|
// 2.1.1
|
|
r = request[kState]
|
|
|
|
// 2.1.2
|
|
if (r.method !== 'GET' && !options.ignoreMethod) {
|
|
return []
|
|
}
|
|
} else if (typeof request === 'string') { // 2.2
|
|
r = new Request(request)[kState]
|
|
}
|
|
}
|
|
|
|
// 4.
|
|
const promise = createDeferredPromise()
|
|
|
|
// 5.
|
|
// 5.1
|
|
const requests = []
|
|
|
|
// 5.2
|
|
if (request === undefined) {
|
|
// 5.2.1
|
|
for (const requestResponse of this.#relevantRequestResponseList) {
|
|
// 5.2.1.1
|
|
requests.push(requestResponse[0])
|
|
}
|
|
} else { // 5.3
|
|
// 5.3.1
|
|
const requestResponses = this.#queryCache(r, options)
|
|
|
|
// 5.3.2
|
|
for (const requestResponse of requestResponses) {
|
|
// 5.3.2.1
|
|
requests.push(requestResponse[0])
|
|
}
|
|
}
|
|
|
|
// 5.4
|
|
queueMicrotask(() => {
|
|
// 5.4.1
|
|
const requestList = []
|
|
|
|
// 5.4.2
|
|
for (const request of requests) {
|
|
const requestObject = fromInnerRequest(
|
|
request,
|
|
new AbortController().signal,
|
|
'immutable'
|
|
)
|
|
// 5.4.2.1
|
|
requestList.push(requestObject)
|
|
}
|
|
|
|
// 5.4.3
|
|
promise.resolve(Object.freeze(requestList))
|
|
})
|
|
|
|
return promise.promise
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm
|
|
* @param {CacheBatchOperation[]} operations
|
|
* @returns {requestResponseList}
|
|
*/
|
|
#batchCacheOperations (operations) {
|
|
// 1.
|
|
const cache = this.#relevantRequestResponseList
|
|
|
|
// 2.
|
|
const backupCache = [...cache]
|
|
|
|
// 3.
|
|
const addedItems = []
|
|
|
|
// 4.1
|
|
const resultList = []
|
|
|
|
try {
|
|
// 4.2
|
|
for (const operation of operations) {
|
|
// 4.2.1
|
|
if (operation.type !== 'delete' && operation.type !== 'put') {
|
|
throw webidl.errors.exception({
|
|
header: 'Cache.#batchCacheOperations',
|
|
message: 'operation type does not match "delete" or "put"'
|
|
})
|
|
}
|
|
|
|
// 4.2.2
|
|
if (operation.type === 'delete' && operation.response != null) {
|
|
throw webidl.errors.exception({
|
|
header: 'Cache.#batchCacheOperations',
|
|
message: 'delete operation should not have an associated response'
|
|
})
|
|
}
|
|
|
|
// 4.2.3
|
|
if (this.#queryCache(operation.request, operation.options, addedItems).length) {
|
|
throw new DOMException('???', 'InvalidStateError')
|
|
}
|
|
|
|
// 4.2.4
|
|
let requestResponses
|
|
|
|
// 4.2.5
|
|
if (operation.type === 'delete') {
|
|
// 4.2.5.1
|
|
requestResponses = this.#queryCache(operation.request, operation.options)
|
|
|
|
// TODO: the spec is wrong, this is needed to pass WPTs
|
|
if (requestResponses.length === 0) {
|
|
return []
|
|
}
|
|
|
|
// 4.2.5.2
|
|
for (const requestResponse of requestResponses) {
|
|
const idx = cache.indexOf(requestResponse)
|
|
assert(idx !== -1)
|
|
|
|
// 4.2.5.2.1
|
|
cache.splice(idx, 1)
|
|
}
|
|
} else if (operation.type === 'put') { // 4.2.6
|
|
// 4.2.6.1
|
|
if (operation.response == null) {
|
|
throw webidl.errors.exception({
|
|
header: 'Cache.#batchCacheOperations',
|
|
message: 'put operation should have an associated response'
|
|
})
|
|
}
|
|
|
|
// 4.2.6.2
|
|
const r = operation.request
|
|
|
|
// 4.2.6.3
|
|
if (!urlIsHttpHttpsScheme(r.url)) {
|
|
throw webidl.errors.exception({
|
|
header: 'Cache.#batchCacheOperations',
|
|
message: 'expected http or https scheme'
|
|
})
|
|
}
|
|
|
|
// 4.2.6.4
|
|
if (r.method !== 'GET') {
|
|
throw webidl.errors.exception({
|
|
header: 'Cache.#batchCacheOperations',
|
|
message: 'not get method'
|
|
})
|
|
}
|
|
|
|
// 4.2.6.5
|
|
if (operation.options != null) {
|
|
throw webidl.errors.exception({
|
|
header: 'Cache.#batchCacheOperations',
|
|
message: 'options must not be defined'
|
|
})
|
|
}
|
|
|
|
// 4.2.6.6
|
|
requestResponses = this.#queryCache(operation.request)
|
|
|
|
// 4.2.6.7
|
|
for (const requestResponse of requestResponses) {
|
|
const idx = cache.indexOf(requestResponse)
|
|
assert(idx !== -1)
|
|
|
|
// 4.2.6.7.1
|
|
cache.splice(idx, 1)
|
|
}
|
|
|
|
// 4.2.6.8
|
|
cache.push([operation.request, operation.response])
|
|
|
|
// 4.2.6.10
|
|
addedItems.push([operation.request, operation.response])
|
|
}
|
|
|
|
// 4.2.7
|
|
resultList.push([operation.request, operation.response])
|
|
}
|
|
|
|
// 4.3
|
|
return resultList
|
|
} catch (e) { // 5.
|
|
// 5.1
|
|
this.#relevantRequestResponseList.length = 0
|
|
|
|
// 5.2
|
|
this.#relevantRequestResponseList = backupCache
|
|
|
|
// 5.3
|
|
throw e
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#query-cache
|
|
* @param {any} requestQuery
|
|
* @param {import('../../types/cache').CacheQueryOptions} options
|
|
* @param {requestResponseList} targetStorage
|
|
* @returns {requestResponseList}
|
|
*/
|
|
#queryCache (requestQuery, options, targetStorage) {
|
|
/** @type {requestResponseList} */
|
|
const resultList = []
|
|
|
|
const storage = targetStorage ?? this.#relevantRequestResponseList
|
|
|
|
for (const requestResponse of storage) {
|
|
const [cachedRequest, cachedResponse] = requestResponse
|
|
if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options)) {
|
|
resultList.push(requestResponse)
|
|
}
|
|
}
|
|
|
|
return resultList
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm
|
|
* @param {any} requestQuery
|
|
* @param {any} request
|
|
* @param {any | null} response
|
|
* @param {import('../../types/cache').CacheQueryOptions | undefined} options
|
|
* @returns {boolean}
|
|
*/
|
|
#requestMatchesCachedItem (requestQuery, request, response = null, options) {
|
|
// if (options?.ignoreMethod === false && request.method === 'GET') {
|
|
// return false
|
|
// }
|
|
|
|
const queryURL = new URL(requestQuery.url)
|
|
|
|
const cachedURL = new URL(request.url)
|
|
|
|
if (options?.ignoreSearch) {
|
|
cachedURL.search = ''
|
|
|
|
queryURL.search = ''
|
|
}
|
|
|
|
if (!urlEquals(queryURL, cachedURL, true)) {
|
|
return false
|
|
}
|
|
|
|
if (
|
|
response == null ||
|
|
options?.ignoreVary ||
|
|
!response.headersList.contains('vary')
|
|
) {
|
|
return true
|
|
}
|
|
|
|
const fieldValues = getFieldValues(response.headersList.get('vary'))
|
|
|
|
for (const fieldValue of fieldValues) {
|
|
if (fieldValue === '*') {
|
|
return false
|
|
}
|
|
|
|
const requestValue = request.headersList.get(fieldValue)
|
|
const queryValue = requestQuery.headersList.get(fieldValue)
|
|
|
|
// If one has the header and the other doesn't, or one has
|
|
// a different value than the other, return false
|
|
if (requestValue !== queryValue) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
#internalMatchAll (request, options, maxResponses = Infinity) {
|
|
// 1.
|
|
let r = null
|
|
|
|
// 2.
|
|
if (request !== undefined) {
|
|
if (request instanceof Request) {
|
|
// 2.1.1
|
|
r = request[kState]
|
|
|
|
// 2.1.2
|
|
if (r.method !== 'GET' && !options.ignoreMethod) {
|
|
return []
|
|
}
|
|
} else if (typeof request === 'string') {
|
|
// 2.2.1
|
|
r = new Request(request)[kState]
|
|
}
|
|
}
|
|
|
|
// 5.
|
|
// 5.1
|
|
const responses = []
|
|
|
|
// 5.2
|
|
if (request === undefined) {
|
|
// 5.2.1
|
|
for (const requestResponse of this.#relevantRequestResponseList) {
|
|
responses.push(requestResponse[1])
|
|
}
|
|
} else { // 5.3
|
|
// 5.3.1
|
|
const requestResponses = this.#queryCache(r, options)
|
|
|
|
// 5.3.2
|
|
for (const requestResponse of requestResponses) {
|
|
responses.push(requestResponse[1])
|
|
}
|
|
}
|
|
|
|
// 5.4
|
|
// We don't implement CORs so we don't need to loop over the responses, yay!
|
|
|
|
// 5.5.1
|
|
const responseList = []
|
|
|
|
// 5.5.2
|
|
for (const response of responses) {
|
|
// 5.5.2.1
|
|
const responseObject = fromInnerResponse(response, 'immutable')
|
|
|
|
responseList.push(responseObject.clone())
|
|
|
|
if (responseList.length >= maxResponses) {
|
|
break
|
|
}
|
|
}
|
|
|
|
// 6.
|
|
return Object.freeze(responseList)
|
|
}
|
|
}
|
|
|
|
Object.defineProperties(Cache.prototype, {
|
|
[Symbol.toStringTag]: {
|
|
value: 'Cache',
|
|
configurable: true
|
|
},
|
|
match: kEnumerableProperty,
|
|
matchAll: kEnumerableProperty,
|
|
add: kEnumerableProperty,
|
|
addAll: kEnumerableProperty,
|
|
put: kEnumerableProperty,
|
|
delete: kEnumerableProperty,
|
|
keys: kEnumerableProperty
|
|
})
|
|
|
|
const cacheQueryOptionConverters = [
|
|
{
|
|
key: 'ignoreSearch',
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: () => false
|
|
},
|
|
{
|
|
key: 'ignoreMethod',
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: () => false
|
|
},
|
|
{
|
|
key: 'ignoreVary',
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: () => false
|
|
}
|
|
]
|
|
|
|
webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters)
|
|
|
|
webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([
|
|
...cacheQueryOptionConverters,
|
|
{
|
|
key: 'cacheName',
|
|
converter: webidl.converters.DOMString
|
|
}
|
|
])
|
|
|
|
webidl.converters.Response = webidl.interfaceConverter(Response)
|
|
|
|
webidl.converters['sequence<RequestInfo>'] = webidl.sequenceConverter(
|
|
webidl.converters.RequestInfo
|
|
)
|
|
|
|
module.exports = {
|
|
Cache
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3245:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { kConstruct } = __nccwpck_require__(109)
|
|
const { Cache } = __nccwpck_require__(9634)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const { kEnumerableProperty } = __nccwpck_require__(3440)
|
|
|
|
class CacheStorage {
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map
|
|
* @type {Map<string, import('./cache').requestResponseList}
|
|
*/
|
|
#caches = new Map()
|
|
|
|
constructor () {
|
|
if (arguments[0] !== kConstruct) {
|
|
webidl.illegalConstructor()
|
|
}
|
|
|
|
webidl.util.markAsUncloneable(this)
|
|
}
|
|
|
|
async match (request, options = {}) {
|
|
webidl.brandCheck(this, CacheStorage)
|
|
webidl.argumentLengthCheck(arguments, 1, 'CacheStorage.match')
|
|
|
|
request = webidl.converters.RequestInfo(request)
|
|
options = webidl.converters.MultiCacheQueryOptions(options)
|
|
|
|
// 1.
|
|
if (options.cacheName != null) {
|
|
// 1.1.1.1
|
|
if (this.#caches.has(options.cacheName)) {
|
|
// 1.1.1.1.1
|
|
const cacheList = this.#caches.get(options.cacheName)
|
|
const cache = new Cache(kConstruct, cacheList)
|
|
|
|
return await cache.match(request, options)
|
|
}
|
|
} else { // 2.
|
|
// 2.2
|
|
for (const cacheList of this.#caches.values()) {
|
|
const cache = new Cache(kConstruct, cacheList)
|
|
|
|
// 2.2.1.2
|
|
const response = await cache.match(request, options)
|
|
|
|
if (response !== undefined) {
|
|
return response
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#cache-storage-has
|
|
* @param {string} cacheName
|
|
* @returns {Promise<boolean>}
|
|
*/
|
|
async has (cacheName) {
|
|
webidl.brandCheck(this, CacheStorage)
|
|
|
|
const prefix = 'CacheStorage.has'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
cacheName = webidl.converters.DOMString(cacheName, prefix, 'cacheName')
|
|
|
|
// 2.1.1
|
|
// 2.2
|
|
return this.#caches.has(cacheName)
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open
|
|
* @param {string} cacheName
|
|
* @returns {Promise<Cache>}
|
|
*/
|
|
async open (cacheName) {
|
|
webidl.brandCheck(this, CacheStorage)
|
|
|
|
const prefix = 'CacheStorage.open'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
cacheName = webidl.converters.DOMString(cacheName, prefix, 'cacheName')
|
|
|
|
// 2.1
|
|
if (this.#caches.has(cacheName)) {
|
|
// await caches.open('v1') !== await caches.open('v1')
|
|
|
|
// 2.1.1
|
|
const cache = this.#caches.get(cacheName)
|
|
|
|
// 2.1.1.1
|
|
return new Cache(kConstruct, cache)
|
|
}
|
|
|
|
// 2.2
|
|
const cache = []
|
|
|
|
// 2.3
|
|
this.#caches.set(cacheName, cache)
|
|
|
|
// 2.4
|
|
return new Cache(kConstruct, cache)
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#cache-storage-delete
|
|
* @param {string} cacheName
|
|
* @returns {Promise<boolean>}
|
|
*/
|
|
async delete (cacheName) {
|
|
webidl.brandCheck(this, CacheStorage)
|
|
|
|
const prefix = 'CacheStorage.delete'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
cacheName = webidl.converters.DOMString(cacheName, prefix, 'cacheName')
|
|
|
|
return this.#caches.delete(cacheName)
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/ServiceWorker/#cache-storage-keys
|
|
* @returns {Promise<string[]>}
|
|
*/
|
|
async keys () {
|
|
webidl.brandCheck(this, CacheStorage)
|
|
|
|
// 2.1
|
|
const keys = this.#caches.keys()
|
|
|
|
// 2.2
|
|
return [...keys]
|
|
}
|
|
}
|
|
|
|
Object.defineProperties(CacheStorage.prototype, {
|
|
[Symbol.toStringTag]: {
|
|
value: 'CacheStorage',
|
|
configurable: true
|
|
},
|
|
match: kEnumerableProperty,
|
|
has: kEnumerableProperty,
|
|
open: kEnumerableProperty,
|
|
delete: kEnumerableProperty,
|
|
keys: kEnumerableProperty
|
|
})
|
|
|
|
module.exports = {
|
|
CacheStorage
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 109:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
module.exports = {
|
|
kConstruct: (__nccwpck_require__(6443).kConstruct)
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6798:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const assert = __nccwpck_require__(4589)
|
|
const { URLSerializer } = __nccwpck_require__(1900)
|
|
const { isValidHeaderName } = __nccwpck_require__(3168)
|
|
|
|
/**
|
|
* @see https://url.spec.whatwg.org/#concept-url-equals
|
|
* @param {URL} A
|
|
* @param {URL} B
|
|
* @param {boolean | undefined} excludeFragment
|
|
* @returns {boolean}
|
|
*/
|
|
function urlEquals (A, B, excludeFragment = false) {
|
|
const serializedA = URLSerializer(A, excludeFragment)
|
|
|
|
const serializedB = URLSerializer(B, excludeFragment)
|
|
|
|
return serializedA === serializedB
|
|
}
|
|
|
|
/**
|
|
* @see https://github.com/chromium/chromium/blob/694d20d134cb553d8d89e5500b9148012b1ba299/content/browser/cache_storage/cache_storage_cache.cc#L260-L262
|
|
* @param {string} header
|
|
*/
|
|
function getFieldValues (header) {
|
|
assert(header !== null)
|
|
|
|
const values = []
|
|
|
|
for (let value of header.split(',')) {
|
|
value = value.trim()
|
|
|
|
if (isValidHeaderName(value)) {
|
|
values.push(value)
|
|
}
|
|
}
|
|
|
|
return values
|
|
}
|
|
|
|
module.exports = {
|
|
urlEquals,
|
|
getFieldValues
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1276:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
// https://wicg.github.io/cookie-store/#cookie-maximum-attribute-value-size
|
|
const maxAttributeValueSize = 1024
|
|
|
|
// https://wicg.github.io/cookie-store/#cookie-maximum-name-value-pair-size
|
|
const maxNameValuePairSize = 4096
|
|
|
|
module.exports = {
|
|
maxAttributeValueSize,
|
|
maxNameValuePairSize
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9061:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { parseSetCookie } = __nccwpck_require__(1978)
|
|
const { stringify } = __nccwpck_require__(7797)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const { Headers } = __nccwpck_require__(660)
|
|
|
|
/**
|
|
* @typedef {Object} Cookie
|
|
* @property {string} name
|
|
* @property {string} value
|
|
* @property {Date|number|undefined} expires
|
|
* @property {number|undefined} maxAge
|
|
* @property {string|undefined} domain
|
|
* @property {string|undefined} path
|
|
* @property {boolean|undefined} secure
|
|
* @property {boolean|undefined} httpOnly
|
|
* @property {'Strict'|'Lax'|'None'} sameSite
|
|
* @property {string[]} unparsed
|
|
*/
|
|
|
|
/**
|
|
* @param {Headers} headers
|
|
* @returns {Record<string, string>}
|
|
*/
|
|
function getCookies (headers) {
|
|
webidl.argumentLengthCheck(arguments, 1, '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
|
|
}
|
|
|
|
/**
|
|
* @param {Headers} headers
|
|
* @param {string} name
|
|
* @param {{ path?: string, domain?: string }|undefined} attributes
|
|
* @returns {void}
|
|
*/
|
|
function deleteCookie (headers, name, attributes) {
|
|
webidl.brandCheck(headers, Headers, { strict: false })
|
|
|
|
const prefix = 'deleteCookie'
|
|
webidl.argumentLengthCheck(arguments, 2, prefix)
|
|
|
|
name = webidl.converters.DOMString(name, prefix, 'name')
|
|
attributes = webidl.converters.DeleteCookieAttributes(attributes)
|
|
|
|
// Matches behavior of
|
|
// https://github.com/denoland/deno_std/blob/63827b16330b82489a04614027c33b7904e08be5/http/cookie.ts#L278
|
|
setCookie(headers, {
|
|
name,
|
|
value: '',
|
|
expires: new Date(0),
|
|
...attributes
|
|
})
|
|
}
|
|
|
|
/**
|
|
* @param {Headers} headers
|
|
* @returns {Cookie[]}
|
|
*/
|
|
function getSetCookies (headers) {
|
|
webidl.argumentLengthCheck(arguments, 1, 'getSetCookies')
|
|
|
|
webidl.brandCheck(headers, Headers, { strict: false })
|
|
|
|
const cookies = headers.getSetCookie()
|
|
|
|
if (!cookies) {
|
|
return []
|
|
}
|
|
|
|
return cookies.map((pair) => parseSetCookie(pair))
|
|
}
|
|
|
|
/**
|
|
* @param {Headers} headers
|
|
* @param {Cookie} cookie
|
|
* @returns {void}
|
|
*/
|
|
function setCookie (headers, cookie) {
|
|
webidl.argumentLengthCheck(arguments, 2, 'setCookie')
|
|
|
|
webidl.brandCheck(headers, Headers, { strict: false })
|
|
|
|
cookie = webidl.converters.Cookie(cookie)
|
|
|
|
const str = stringify(cookie)
|
|
|
|
if (str) {
|
|
headers.append('Set-Cookie', str)
|
|
}
|
|
}
|
|
|
|
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: () => new Array(0)
|
|
}
|
|
])
|
|
|
|
module.exports = {
|
|
getCookies,
|
|
deleteCookie,
|
|
getSetCookies,
|
|
setCookie
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1978:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { maxNameValuePairSize, maxAttributeValueSize } = __nccwpck_require__(1276)
|
|
const { isCTLExcludingHtab } = __nccwpck_require__(7797)
|
|
const { collectASequenceOfCodePointsFast } = __nccwpck_require__(1900)
|
|
const assert = __nccwpck_require__(4589)
|
|
|
|
/**
|
|
* @description Parses the field-value attributes of a set-cookie header string.
|
|
* @see https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4
|
|
* @param {string} header
|
|
* @returns if the header is invalid, null will be returned
|
|
*/
|
|
function parseSetCookie (header) {
|
|
// 1. If the set-cookie-string contains a %x00-08 / %x0A-1F / %x7F
|
|
// character (CTL characters excluding HTAB): Abort these steps and
|
|
// ignore the set-cookie-string entirely.
|
|
if (isCTLExcludingHtab(header)) {
|
|
return null
|
|
}
|
|
|
|
let nameValuePair = ''
|
|
let unparsedAttributes = ''
|
|
let name = ''
|
|
let value = ''
|
|
|
|
// 2. If the set-cookie-string contains a %x3B (";") character:
|
|
if (header.includes(';')) {
|
|
// 1. The name-value-pair string consists of the characters up to,
|
|
// but not including, the first %x3B (";"), and the unparsed-
|
|
// attributes consist of the remainder of the set-cookie-string
|
|
// (including the %x3B (";") in question).
|
|
const position = { position: 0 }
|
|
|
|
nameValuePair = collectASequenceOfCodePointsFast(';', header, position)
|
|
unparsedAttributes = header.slice(position.position)
|
|
} else {
|
|
// Otherwise:
|
|
|
|
// 1. The name-value-pair string consists of all the characters
|
|
// contained in the set-cookie-string, and the unparsed-
|
|
// attributes is the empty string.
|
|
nameValuePair = header
|
|
}
|
|
|
|
// 3. If the name-value-pair string lacks a %x3D ("=") character, then
|
|
// the name string is empty, and the value string is the value of
|
|
// name-value-pair.
|
|
if (!nameValuePair.includes('=')) {
|
|
value = nameValuePair
|
|
} else {
|
|
// Otherwise, the name string consists of the characters up to, but
|
|
// not including, the first %x3D ("=") character, and the (possibly
|
|
// empty) value string consists of the characters after the first
|
|
// %x3D ("=") character.
|
|
const position = { position: 0 }
|
|
name = collectASequenceOfCodePointsFast(
|
|
'=',
|
|
nameValuePair,
|
|
position
|
|
)
|
|
value = nameValuePair.slice(position.position + 1)
|
|
}
|
|
|
|
// 4. Remove any leading or trailing WSP characters from the name
|
|
// string and the value string.
|
|
name = name.trim()
|
|
value = value.trim()
|
|
|
|
// 5. If the sum of the lengths of the name string and the value string
|
|
// is more than 4096 octets, abort these steps and ignore the set-
|
|
// cookie-string entirely.
|
|
if (name.length + value.length > maxNameValuePairSize) {
|
|
return null
|
|
}
|
|
|
|
// 6. The cookie-name is the name string, and the cookie-value is the
|
|
// value string.
|
|
return {
|
|
name, value, ...parseUnparsedAttributes(unparsedAttributes)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parses the remaining attributes of a set-cookie header
|
|
* @see https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4
|
|
* @param {string} unparsedAttributes
|
|
* @param {[Object.<string, unknown>]={}} cookieAttributeList
|
|
*/
|
|
function parseUnparsedAttributes (unparsedAttributes, cookieAttributeList = {}) {
|
|
// 1. If the unparsed-attributes string is empty, skip the rest of
|
|
// these steps.
|
|
if (unparsedAttributes.length === 0) {
|
|
return cookieAttributeList
|
|
}
|
|
|
|
// 2. Discard the first character of the unparsed-attributes (which
|
|
// will be a %x3B (";") character).
|
|
assert(unparsedAttributes[0] === ';')
|
|
unparsedAttributes = unparsedAttributes.slice(1)
|
|
|
|
let cookieAv = ''
|
|
|
|
// 3. If the remaining unparsed-attributes contains a %x3B (";")
|
|
// character:
|
|
if (unparsedAttributes.includes(';')) {
|
|
// 1. Consume the characters of the unparsed-attributes up to, but
|
|
// not including, the first %x3B (";") character.
|
|
cookieAv = collectASequenceOfCodePointsFast(
|
|
';',
|
|
unparsedAttributes,
|
|
{ position: 0 }
|
|
)
|
|
unparsedAttributes = unparsedAttributes.slice(cookieAv.length)
|
|
} else {
|
|
// Otherwise:
|
|
|
|
// 1. Consume the remainder of the unparsed-attributes.
|
|
cookieAv = unparsedAttributes
|
|
unparsedAttributes = ''
|
|
}
|
|
|
|
// Let the cookie-av string be the characters consumed in this step.
|
|
|
|
let attributeName = ''
|
|
let attributeValue = ''
|
|
|
|
// 4. If the cookie-av string contains a %x3D ("=") character:
|
|
if (cookieAv.includes('=')) {
|
|
// 1. The (possibly empty) attribute-name string consists of the
|
|
// characters up to, but not including, the first %x3D ("=")
|
|
// character, and the (possibly empty) attribute-value string
|
|
// consists of the characters after the first %x3D ("=")
|
|
// character.
|
|
const position = { position: 0 }
|
|
|
|
attributeName = collectASequenceOfCodePointsFast(
|
|
'=',
|
|
cookieAv,
|
|
position
|
|
)
|
|
attributeValue = cookieAv.slice(position.position + 1)
|
|
} else {
|
|
// Otherwise:
|
|
|
|
// 1. The attribute-name string consists of the entire cookie-av
|
|
// string, and the attribute-value string is empty.
|
|
attributeName = cookieAv
|
|
}
|
|
|
|
// 5. Remove any leading or trailing WSP characters from the attribute-
|
|
// name string and the attribute-value string.
|
|
attributeName = attributeName.trim()
|
|
attributeValue = attributeValue.trim()
|
|
|
|
// 6. If the attribute-value is longer than 1024 octets, ignore the
|
|
// cookie-av string and return to Step 1 of this algorithm.
|
|
if (attributeValue.length > maxAttributeValueSize) {
|
|
return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList)
|
|
}
|
|
|
|
// 7. Process the attribute-name and attribute-value according to the
|
|
// requirements in the following subsections. (Notice that
|
|
// attributes with unrecognized attribute-names are ignored.)
|
|
const attributeNameLowercase = attributeName.toLowerCase()
|
|
|
|
// https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.1
|
|
// If the attribute-name case-insensitively matches the string
|
|
// "Expires", the user agent MUST process the cookie-av as follows.
|
|
if (attributeNameLowercase === 'expires') {
|
|
// 1. Let the expiry-time be the result of parsing the attribute-value
|
|
// as cookie-date (see Section 5.1.1).
|
|
const expiryTime = new Date(attributeValue)
|
|
|
|
// 2. If the attribute-value failed to parse as a cookie date, ignore
|
|
// the cookie-av.
|
|
|
|
cookieAttributeList.expires = expiryTime
|
|
} else if (attributeNameLowercase === 'max-age') {
|
|
// https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.2
|
|
// If the attribute-name case-insensitively matches the string "Max-
|
|
// Age", the user agent MUST process the cookie-av as follows.
|
|
|
|
// 1. If the first character of the attribute-value is not a DIGIT or a
|
|
// "-" character, ignore the cookie-av.
|
|
const charCode = attributeValue.charCodeAt(0)
|
|
|
|
if ((charCode < 48 || charCode > 57) && attributeValue[0] !== '-') {
|
|
return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList)
|
|
}
|
|
|
|
// 2. If the remainder of attribute-value contains a non-DIGIT
|
|
// character, ignore the cookie-av.
|
|
if (!/^\d+$/.test(attributeValue)) {
|
|
return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList)
|
|
}
|
|
|
|
// 3. Let delta-seconds be the attribute-value converted to an integer.
|
|
const deltaSeconds = Number(attributeValue)
|
|
|
|
// 4. Let cookie-age-limit be the maximum age of the cookie (which
|
|
// SHOULD be 400 days or less, see Section 4.1.2.2).
|
|
|
|
// 5. Set delta-seconds to the smaller of its present value and cookie-
|
|
// age-limit.
|
|
// deltaSeconds = Math.min(deltaSeconds * 1000, maxExpiresMs)
|
|
|
|
// 6. If delta-seconds is less than or equal to zero (0), let expiry-
|
|
// time be the earliest representable date and time. Otherwise, let
|
|
// the expiry-time be the current date and time plus delta-seconds
|
|
// seconds.
|
|
// const expiryTime = deltaSeconds <= 0 ? Date.now() : Date.now() + deltaSeconds
|
|
|
|
// 7. Append an attribute to the cookie-attribute-list with an
|
|
// attribute-name of Max-Age and an attribute-value of expiry-time.
|
|
cookieAttributeList.maxAge = deltaSeconds
|
|
} else if (attributeNameLowercase === 'domain') {
|
|
// https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.3
|
|
// If the attribute-name case-insensitively matches the string "Domain",
|
|
// the user agent MUST process the cookie-av as follows.
|
|
|
|
// 1. Let cookie-domain be the attribute-value.
|
|
let cookieDomain = attributeValue
|
|
|
|
// 2. If cookie-domain starts with %x2E ("."), let cookie-domain be
|
|
// cookie-domain without its leading %x2E (".").
|
|
if (cookieDomain[0] === '.') {
|
|
cookieDomain = cookieDomain.slice(1)
|
|
}
|
|
|
|
// 3. Convert the cookie-domain to lower case.
|
|
cookieDomain = cookieDomain.toLowerCase()
|
|
|
|
// 4. Append an attribute to the cookie-attribute-list with an
|
|
// attribute-name of Domain and an attribute-value of cookie-domain.
|
|
cookieAttributeList.domain = cookieDomain
|
|
} else if (attributeNameLowercase === 'path') {
|
|
// https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.4
|
|
// If the attribute-name case-insensitively matches the string "Path",
|
|
// the user agent MUST process the cookie-av as follows.
|
|
|
|
// 1. If the attribute-value is empty or if the first character of the
|
|
// attribute-value is not %x2F ("/"):
|
|
let cookiePath = ''
|
|
if (attributeValue.length === 0 || attributeValue[0] !== '/') {
|
|
// 1. Let cookie-path be the default-path.
|
|
cookiePath = '/'
|
|
} else {
|
|
// Otherwise:
|
|
|
|
// 1. Let cookie-path be the attribute-value.
|
|
cookiePath = attributeValue
|
|
}
|
|
|
|
// 2. Append an attribute to the cookie-attribute-list with an
|
|
// attribute-name of Path and an attribute-value of cookie-path.
|
|
cookieAttributeList.path = cookiePath
|
|
} else if (attributeNameLowercase === 'secure') {
|
|
// https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.5
|
|
// If the attribute-name case-insensitively matches the string "Secure",
|
|
// the user agent MUST append an attribute to the cookie-attribute-list
|
|
// with an attribute-name of Secure and an empty attribute-value.
|
|
|
|
cookieAttributeList.secure = true
|
|
} else if (attributeNameLowercase === 'httponly') {
|
|
// https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.6
|
|
// If the attribute-name case-insensitively matches the string
|
|
// "HttpOnly", the user agent MUST append an attribute to the cookie-
|
|
// attribute-list with an attribute-name of HttpOnly and an empty
|
|
// attribute-value.
|
|
|
|
cookieAttributeList.httpOnly = true
|
|
} else if (attributeNameLowercase === 'samesite') {
|
|
// https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.7
|
|
// If the attribute-name case-insensitively matches the string
|
|
// "SameSite", the user agent MUST process the cookie-av as follows:
|
|
|
|
const attributeValueLowercase = attributeValue.toLowerCase()
|
|
|
|
// 1. If cookie-av's attribute-value is a case-insensitive match for
|
|
// "None", append an attribute to the cookie-attribute-list with an
|
|
// attribute-name of "SameSite" and an attribute-value of "None".
|
|
if (attributeValueLowercase === 'none') {
|
|
cookieAttributeList.sameSite = 'None'
|
|
} else if (attributeValueLowercase === 'strict') {
|
|
// 2. If cookie-av's attribute-value is a case-insensitive match for
|
|
// "Strict", append an attribute to the cookie-attribute-list with
|
|
// an attribute-name of "SameSite" and an attribute-value of
|
|
// "Strict".
|
|
cookieAttributeList.sameSite = 'Strict'
|
|
} else if (attributeValueLowercase === 'lax') {
|
|
// 3. If cookie-av's attribute-value is a case-insensitive match for
|
|
// "Lax", append an attribute to the cookie-attribute-list with an
|
|
// attribute-name of "SameSite" and an attribute-value of "Lax".
|
|
cookieAttributeList.sameSite = 'Lax'
|
|
}
|
|
} else {
|
|
cookieAttributeList.unparsed ??= []
|
|
|
|
cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`)
|
|
}
|
|
|
|
// 8. Return to Step 1 of this algorithm.
|
|
return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList)
|
|
}
|
|
|
|
module.exports = {
|
|
parseSetCookie,
|
|
parseUnparsedAttributes
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7797:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
/**
|
|
* @param {string} value
|
|
* @returns {boolean}
|
|
*/
|
|
function isCTLExcludingHtab (value) {
|
|
for (let i = 0; i < value.length; ++i) {
|
|
const code = value.charCodeAt(i)
|
|
|
|
if (
|
|
(code >= 0x00 && code <= 0x08) ||
|
|
(code >= 0x0A && code <= 0x1F) ||
|
|
code === 0x7F
|
|
) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
/**
|
|
CHAR = <any US-ASCII character (octets 0 - 127)>
|
|
token = 1*<any CHAR except CTLs or separators>
|
|
separators = "(" | ")" | "<" | ">" | "@"
|
|
| "," | ";" | ":" | "\" | <">
|
|
| "/" | "[" | "]" | "?" | "="
|
|
| "{" | "}" | SP | HT
|
|
* @param {string} name
|
|
*/
|
|
function validateCookieName (name) {
|
|
for (let i = 0; i < name.length; ++i) {
|
|
const code = name.charCodeAt(i)
|
|
|
|
if (
|
|
code < 0x21 || // exclude CTLs (0-31), SP and HT
|
|
code > 0x7E || // exclude non-ascii and DEL
|
|
code === 0x22 || // "
|
|
code === 0x28 || // (
|
|
code === 0x29 || // )
|
|
code === 0x3C || // <
|
|
code === 0x3E || // >
|
|
code === 0x40 || // @
|
|
code === 0x2C || // ,
|
|
code === 0x3B || // ;
|
|
code === 0x3A || // :
|
|
code === 0x5C || // \
|
|
code === 0x2F || // /
|
|
code === 0x5B || // [
|
|
code === 0x5D || // ]
|
|
code === 0x3F || // ?
|
|
code === 0x3D || // =
|
|
code === 0x7B || // {
|
|
code === 0x7D // }
|
|
) {
|
|
throw new Error('Invalid cookie name')
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
cookie-value = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE )
|
|
cookie-octet = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
|
|
; US-ASCII characters excluding CTLs,
|
|
; whitespace DQUOTE, comma, semicolon,
|
|
; and backslash
|
|
* @param {string} value
|
|
*/
|
|
function validateCookieValue (value) {
|
|
let len = value.length
|
|
let i = 0
|
|
|
|
// if the value is wrapped in DQUOTE
|
|
if (value[0] === '"') {
|
|
if (len === 1 || value[len - 1] !== '"') {
|
|
throw new Error('Invalid cookie value')
|
|
}
|
|
--len
|
|
++i
|
|
}
|
|
|
|
while (i < len) {
|
|
const code = value.charCodeAt(i++)
|
|
|
|
if (
|
|
code < 0x21 || // exclude CTLs (0-31)
|
|
code > 0x7E || // non-ascii and DEL (127)
|
|
code === 0x22 || // "
|
|
code === 0x2C || // ,
|
|
code === 0x3B || // ;
|
|
code === 0x5C // \
|
|
) {
|
|
throw new Error('Invalid cookie value')
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* path-value = <any CHAR except CTLs or ";">
|
|
* @param {string} path
|
|
*/
|
|
function validateCookiePath (path) {
|
|
for (let i = 0; i < path.length; ++i) {
|
|
const code = path.charCodeAt(i)
|
|
|
|
if (
|
|
code < 0x20 || // exclude CTLs (0-31)
|
|
code === 0x7F || // DEL
|
|
code === 0x3B // ;
|
|
) {
|
|
throw new Error('Invalid cookie path')
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* I have no idea why these values aren't allowed to be honest,
|
|
* but Deno tests these. - Khafra
|
|
* @param {string} domain
|
|
*/
|
|
function validateCookieDomain (domain) {
|
|
if (
|
|
domain.startsWith('-') ||
|
|
domain.endsWith('.') ||
|
|
domain.endsWith('-')
|
|
) {
|
|
throw new Error('Invalid cookie domain')
|
|
}
|
|
}
|
|
|
|
const IMFDays = [
|
|
'Sun', 'Mon', 'Tue', 'Wed',
|
|
'Thu', 'Fri', 'Sat'
|
|
]
|
|
|
|
const IMFMonths = [
|
|
'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
|
|
'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'
|
|
]
|
|
|
|
const IMFPaddedNumbers = Array(61).fill(0).map((_, i) => i.toString().padStart(2, '0'))
|
|
|
|
/**
|
|
* @see https://www.rfc-editor.org/rfc/rfc7231#section-7.1.1.1
|
|
* @param {number|Date} date
|
|
IMF-fixdate = day-name "," SP date1 SP time-of-day SP GMT
|
|
; fixed length/zone/capitalization subset of the format
|
|
; see Section 3.3 of [RFC5322]
|
|
|
|
day-name = %x4D.6F.6E ; "Mon", case-sensitive
|
|
/ %x54.75.65 ; "Tue", case-sensitive
|
|
/ %x57.65.64 ; "Wed", case-sensitive
|
|
/ %x54.68.75 ; "Thu", case-sensitive
|
|
/ %x46.72.69 ; "Fri", case-sensitive
|
|
/ %x53.61.74 ; "Sat", case-sensitive
|
|
/ %x53.75.6E ; "Sun", case-sensitive
|
|
date1 = day SP month SP year
|
|
; e.g., 02 Jun 1982
|
|
|
|
day = 2DIGIT
|
|
month = %x4A.61.6E ; "Jan", case-sensitive
|
|
/ %x46.65.62 ; "Feb", case-sensitive
|
|
/ %x4D.61.72 ; "Mar", case-sensitive
|
|
/ %x41.70.72 ; "Apr", case-sensitive
|
|
/ %x4D.61.79 ; "May", case-sensitive
|
|
/ %x4A.75.6E ; "Jun", case-sensitive
|
|
/ %x4A.75.6C ; "Jul", case-sensitive
|
|
/ %x41.75.67 ; "Aug", case-sensitive
|
|
/ %x53.65.70 ; "Sep", case-sensitive
|
|
/ %x4F.63.74 ; "Oct", case-sensitive
|
|
/ %x4E.6F.76 ; "Nov", case-sensitive
|
|
/ %x44.65.63 ; "Dec", case-sensitive
|
|
year = 4DIGIT
|
|
|
|
GMT = %x47.4D.54 ; "GMT", case-sensitive
|
|
|
|
time-of-day = hour ":" minute ":" second
|
|
; 00:00:00 - 23:59:60 (leap second)
|
|
|
|
hour = 2DIGIT
|
|
minute = 2DIGIT
|
|
second = 2DIGIT
|
|
*/
|
|
function toIMFDate (date) {
|
|
if (typeof date === 'number') {
|
|
date = new Date(date)
|
|
}
|
|
|
|
return `${IMFDays[date.getUTCDay()]}, ${IMFPaddedNumbers[date.getUTCDate()]} ${IMFMonths[date.getUTCMonth()]} ${date.getUTCFullYear()} ${IMFPaddedNumbers[date.getUTCHours()]}:${IMFPaddedNumbers[date.getUTCMinutes()]}:${IMFPaddedNumbers[date.getUTCSeconds()]} GMT`
|
|
}
|
|
|
|
/**
|
|
max-age-av = "Max-Age=" non-zero-digit *DIGIT
|
|
; In practice, both expires-av and max-age-av
|
|
; are limited to dates representable by the
|
|
; user agent.
|
|
* @param {number} maxAge
|
|
*/
|
|
function validateCookieMaxAge (maxAge) {
|
|
if (maxAge < 0) {
|
|
throw new Error('Invalid cookie max-age')
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://www.rfc-editor.org/rfc/rfc6265#section-4.1.1
|
|
* @param {import('./index').Cookie} cookie
|
|
*/
|
|
function stringify (cookie) {
|
|
if (cookie.name.length === 0) {
|
|
return null
|
|
}
|
|
|
|
validateCookieName(cookie.name)
|
|
validateCookieValue(cookie.value)
|
|
|
|
const out = [`${cookie.name}=${cookie.value}`]
|
|
|
|
// https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-cookie-prefixes-00#section-3.1
|
|
// https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-cookie-prefixes-00#section-3.2
|
|
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('; ')
|
|
}
|
|
|
|
module.exports = {
|
|
isCTLExcludingHtab,
|
|
validateCookieName,
|
|
validateCookiePath,
|
|
validateCookieValue,
|
|
toIMFDate,
|
|
stringify
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4031:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
const { Transform } = __nccwpck_require__(7075)
|
|
const { isASCIINumber, isValidLastEventId } = __nccwpck_require__(4811)
|
|
|
|
/**
|
|
* @type {number[]} BOM
|
|
*/
|
|
const BOM = [0xEF, 0xBB, 0xBF]
|
|
/**
|
|
* @type {10} LF
|
|
*/
|
|
const LF = 0x0A
|
|
/**
|
|
* @type {13} CR
|
|
*/
|
|
const CR = 0x0D
|
|
/**
|
|
* @type {58} COLON
|
|
*/
|
|
const COLON = 0x3A
|
|
/**
|
|
* @type {32} SPACE
|
|
*/
|
|
const SPACE = 0x20
|
|
|
|
/**
|
|
* @typedef {object} EventSourceStreamEvent
|
|
* @type {object}
|
|
* @property {string} [event] The event type.
|
|
* @property {string} [data] The data of the message.
|
|
* @property {string} [id] A unique ID for the event.
|
|
* @property {string} [retry] The reconnection time, in milliseconds.
|
|
*/
|
|
|
|
/**
|
|
* @typedef eventSourceSettings
|
|
* @type {object}
|
|
* @property {string} lastEventId The last event ID received from the server.
|
|
* @property {string} origin The origin of the event source.
|
|
* @property {number} reconnectionTime The reconnection time, in milliseconds.
|
|
*/
|
|
|
|
class EventSourceStream extends Transform {
|
|
/**
|
|
* @type {eventSourceSettings}
|
|
*/
|
|
state = null
|
|
|
|
/**
|
|
* Leading byte-order-mark check.
|
|
* @type {boolean}
|
|
*/
|
|
checkBOM = true
|
|
|
|
/**
|
|
* @type {boolean}
|
|
*/
|
|
crlfCheck = false
|
|
|
|
/**
|
|
* @type {boolean}
|
|
*/
|
|
eventEndCheck = false
|
|
|
|
/**
|
|
* @type {Buffer}
|
|
*/
|
|
buffer = null
|
|
|
|
pos = 0
|
|
|
|
event = {
|
|
data: undefined,
|
|
event: undefined,
|
|
id: undefined,
|
|
retry: undefined
|
|
}
|
|
|
|
/**
|
|
* @param {object} options
|
|
* @param {eventSourceSettings} options.eventSourceSettings
|
|
* @param {Function} [options.push]
|
|
*/
|
|
constructor (options = {}) {
|
|
// Enable object mode as EventSourceStream emits objects of shape
|
|
// EventSourceStreamEvent
|
|
options.readableObjectMode = true
|
|
|
|
super(options)
|
|
|
|
this.state = options.eventSourceSettings || {}
|
|
if (options.push) {
|
|
this.push = options.push
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Buffer} chunk
|
|
* @param {string} _encoding
|
|
* @param {Function} callback
|
|
* @returns {void}
|
|
*/
|
|
_transform (chunk, _encoding, callback) {
|
|
if (chunk.length === 0) {
|
|
callback()
|
|
return
|
|
}
|
|
|
|
// Cache the chunk in the buffer, as the data might not be complete while
|
|
// processing it
|
|
// TODO: Investigate if there is a more performant way to handle
|
|
// incoming chunks
|
|
// see: https://github.com/nodejs/undici/issues/2630
|
|
if (this.buffer) {
|
|
this.buffer = Buffer.concat([this.buffer, chunk])
|
|
} else {
|
|
this.buffer = chunk
|
|
}
|
|
|
|
// Strip leading byte-order-mark if we opened the stream and started
|
|
// the processing of the incoming data
|
|
if (this.checkBOM) {
|
|
switch (this.buffer.length) {
|
|
case 1:
|
|
// Check if the first byte is the same as the first byte of the BOM
|
|
if (this.buffer[0] === BOM[0]) {
|
|
// If it is, we need to wait for more data
|
|
callback()
|
|
return
|
|
}
|
|
// Set the checkBOM flag to false as we don't need to check for the
|
|
// BOM anymore
|
|
this.checkBOM = false
|
|
|
|
// The buffer only contains one byte so we need to wait for more data
|
|
callback()
|
|
return
|
|
case 2:
|
|
// Check if the first two bytes are the same as the first two bytes
|
|
// of the BOM
|
|
if (
|
|
this.buffer[0] === BOM[0] &&
|
|
this.buffer[1] === BOM[1]
|
|
) {
|
|
// If it is, we need to wait for more data, because the third byte
|
|
// is needed to determine if it is the BOM or not
|
|
callback()
|
|
return
|
|
}
|
|
|
|
// Set the checkBOM flag to false as we don't need to check for the
|
|
// BOM anymore
|
|
this.checkBOM = false
|
|
break
|
|
case 3:
|
|
// Check if the first three bytes are the same as the first three
|
|
// bytes of the BOM
|
|
if (
|
|
this.buffer[0] === BOM[0] &&
|
|
this.buffer[1] === BOM[1] &&
|
|
this.buffer[2] === BOM[2]
|
|
) {
|
|
// If it is, we can drop the buffered data, as it is only the BOM
|
|
this.buffer = Buffer.alloc(0)
|
|
// Set the checkBOM flag to false as we don't need to check for the
|
|
// BOM anymore
|
|
this.checkBOM = false
|
|
|
|
// Await more data
|
|
callback()
|
|
return
|
|
}
|
|
// If it is not the BOM, we can start processing the data
|
|
this.checkBOM = false
|
|
break
|
|
default:
|
|
// The buffer is longer than 3 bytes, so we can drop the BOM if it is
|
|
// present
|
|
if (
|
|
this.buffer[0] === BOM[0] &&
|
|
this.buffer[1] === BOM[1] &&
|
|
this.buffer[2] === BOM[2]
|
|
) {
|
|
// Remove the BOM from the buffer
|
|
this.buffer = this.buffer.subarray(3)
|
|
}
|
|
|
|
// Set the checkBOM flag to false as we don't need to check for the
|
|
this.checkBOM = false
|
|
break
|
|
}
|
|
}
|
|
|
|
while (this.pos < this.buffer.length) {
|
|
// If the previous line ended with an end-of-line, we need to check
|
|
// if the next character is also an end-of-line.
|
|
if (this.eventEndCheck) {
|
|
// If the the current character is an end-of-line, then the event
|
|
// is finished and we can process it
|
|
|
|
// If the previous line ended with a carriage return, we need to
|
|
// check if the current character is a line feed and remove it
|
|
// from the buffer.
|
|
if (this.crlfCheck) {
|
|
// If the current character is a line feed, we can remove it
|
|
// from the buffer and reset the crlfCheck flag
|
|
if (this.buffer[this.pos] === LF) {
|
|
this.buffer = this.buffer.subarray(this.pos + 1)
|
|
this.pos = 0
|
|
this.crlfCheck = false
|
|
|
|
// It is possible that the line feed is not the end of the
|
|
// event. We need to check if the next character is an
|
|
// end-of-line character to determine if the event is
|
|
// finished. We simply continue the loop to check the next
|
|
// character.
|
|
|
|
// As we removed the line feed from the buffer and set the
|
|
// crlfCheck flag to false, we basically don't make any
|
|
// distinction between a line feed and a carriage return.
|
|
continue
|
|
}
|
|
this.crlfCheck = false
|
|
}
|
|
|
|
if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
|
|
// If the current character is a carriage return, we need to
|
|
// set the crlfCheck flag to true, as we need to check if the
|
|
// next character is a line feed so we can remove it from the
|
|
// buffer
|
|
if (this.buffer[this.pos] === CR) {
|
|
this.crlfCheck = true
|
|
}
|
|
|
|
this.buffer = this.buffer.subarray(this.pos + 1)
|
|
this.pos = 0
|
|
if (
|
|
this.event.data !== undefined || this.event.event || this.event.id || this.event.retry) {
|
|
this.processEvent(this.event)
|
|
}
|
|
this.clearEvent()
|
|
continue
|
|
}
|
|
// If the current character is not an end-of-line, then the event
|
|
// is not finished and we have to reset the eventEndCheck flag
|
|
this.eventEndCheck = false
|
|
continue
|
|
}
|
|
|
|
// If the current character is an end-of-line, we can process the
|
|
// line
|
|
if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
|
|
// If the current character is a carriage return, we need to
|
|
// set the crlfCheck flag to true, as we need to check if the
|
|
// next character is a line feed
|
|
if (this.buffer[this.pos] === CR) {
|
|
this.crlfCheck = true
|
|
}
|
|
|
|
// In any case, we can process the line as we reached an
|
|
// end-of-line character
|
|
this.parseLine(this.buffer.subarray(0, this.pos), this.event)
|
|
|
|
// Remove the processed line from the buffer
|
|
this.buffer = this.buffer.subarray(this.pos + 1)
|
|
// Reset the position as we removed the processed line from the buffer
|
|
this.pos = 0
|
|
// A line was processed and this could be the end of the event. We need
|
|
// to check if the next line is empty to determine if the event is
|
|
// finished.
|
|
this.eventEndCheck = true
|
|
continue
|
|
}
|
|
|
|
this.pos++
|
|
}
|
|
|
|
callback()
|
|
}
|
|
|
|
/**
|
|
* @param {Buffer} line
|
|
* @param {EventStreamEvent} event
|
|
*/
|
|
parseLine (line, event) {
|
|
// If the line is empty (a blank line)
|
|
// Dispatch the event, as defined below.
|
|
// This will be handled in the _transform method
|
|
if (line.length === 0) {
|
|
return
|
|
}
|
|
|
|
// If the line starts with a U+003A COLON character (:)
|
|
// Ignore the line.
|
|
const colonPosition = line.indexOf(COLON)
|
|
if (colonPosition === 0) {
|
|
return
|
|
}
|
|
|
|
let field = ''
|
|
let value = ''
|
|
|
|
// If the line contains a U+003A COLON character (:)
|
|
if (colonPosition !== -1) {
|
|
// Collect the characters on the line before the first U+003A COLON
|
|
// character (:), and let field be that string.
|
|
// TODO: Investigate if there is a more performant way to extract the
|
|
// field
|
|
// see: https://github.com/nodejs/undici/issues/2630
|
|
field = line.subarray(0, colonPosition).toString('utf8')
|
|
|
|
// Collect the characters on the line after the first U+003A COLON
|
|
// character (:), and let value be that string.
|
|
// If value starts with a U+0020 SPACE character, remove it from value.
|
|
let valueStart = colonPosition + 1
|
|
if (line[valueStart] === SPACE) {
|
|
++valueStart
|
|
}
|
|
// TODO: Investigate if there is a more performant way to extract the
|
|
// value
|
|
// see: https://github.com/nodejs/undici/issues/2630
|
|
value = line.subarray(valueStart).toString('utf8')
|
|
|
|
// Otherwise, the string is not empty but does not contain a U+003A COLON
|
|
// character (:)
|
|
} else {
|
|
// Process the field using the steps described below, using the whole
|
|
// line as the field name, and the empty string as the field value.
|
|
field = line.toString('utf8')
|
|
value = ''
|
|
}
|
|
|
|
// Modify the event with the field name and value. The value is also
|
|
// decoded as UTF-8
|
|
switch (field) {
|
|
case 'data':
|
|
if (event[field] === undefined) {
|
|
event[field] = value
|
|
} else {
|
|
event[field] += `\n${value}`
|
|
}
|
|
break
|
|
case 'retry':
|
|
if (isASCIINumber(value)) {
|
|
event[field] = value
|
|
}
|
|
break
|
|
case 'id':
|
|
if (isValidLastEventId(value)) {
|
|
event[field] = value
|
|
}
|
|
break
|
|
case 'event':
|
|
if (value.length > 0) {
|
|
event[field] = value
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {EventSourceStreamEvent} event
|
|
*/
|
|
processEvent (event) {
|
|
if (event.retry && isASCIINumber(event.retry)) {
|
|
this.state.reconnectionTime = parseInt(event.retry, 10)
|
|
}
|
|
|
|
if (event.id && isValidLastEventId(event.id)) {
|
|
this.state.lastEventId = event.id
|
|
}
|
|
|
|
// only dispatch event, when data is provided
|
|
if (event.data !== undefined) {
|
|
this.push({
|
|
type: event.event || 'message',
|
|
options: {
|
|
data: event.data,
|
|
lastEventId: this.state.lastEventId,
|
|
origin: this.state.origin
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
clearEvent () {
|
|
this.event = {
|
|
data: undefined,
|
|
event: undefined,
|
|
id: undefined,
|
|
retry: undefined
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
EventSourceStream
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1238:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { pipeline } = __nccwpck_require__(7075)
|
|
const { fetching } = __nccwpck_require__(4398)
|
|
const { makeRequest } = __nccwpck_require__(9967)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const { EventSourceStream } = __nccwpck_require__(4031)
|
|
const { parseMIMEType } = __nccwpck_require__(1900)
|
|
const { createFastMessageEvent } = __nccwpck_require__(5188)
|
|
const { isNetworkError } = __nccwpck_require__(9051)
|
|
const { delay } = __nccwpck_require__(4811)
|
|
const { kEnumerableProperty } = __nccwpck_require__(3440)
|
|
const { environmentSettingsObject } = __nccwpck_require__(3168)
|
|
|
|
let experimentalWarned = false
|
|
|
|
/**
|
|
* A reconnection time, in milliseconds. This must initially be an implementation-defined value,
|
|
* probably in the region of a few seconds.
|
|
*
|
|
* In Comparison:
|
|
* - Chrome uses 3000ms.
|
|
* - Deno uses 5000ms.
|
|
*
|
|
* @type {3000}
|
|
*/
|
|
const defaultReconnectionTime = 3000
|
|
|
|
/**
|
|
* The readyState attribute represents the state of the connection.
|
|
* @enum
|
|
* @readonly
|
|
* @see https://html.spec.whatwg.org/multipage/server-sent-events.html#dom-eventsource-readystate-dev
|
|
*/
|
|
|
|
/**
|
|
* The connection has not yet been established, or it was closed and the user
|
|
* agent is reconnecting.
|
|
* @type {0}
|
|
*/
|
|
const CONNECTING = 0
|
|
|
|
/**
|
|
* The user agent has an open connection and is dispatching events as it
|
|
* receives them.
|
|
* @type {1}
|
|
*/
|
|
const OPEN = 1
|
|
|
|
/**
|
|
* The connection is not open, and the user agent is not trying to reconnect.
|
|
* @type {2}
|
|
*/
|
|
const CLOSED = 2
|
|
|
|
/**
|
|
* Requests for the element will have their mode set to "cors" and their credentials mode set to "same-origin".
|
|
* @type {'anonymous'}
|
|
*/
|
|
const ANONYMOUS = 'anonymous'
|
|
|
|
/**
|
|
* Requests for the element will have their mode set to "cors" and their credentials mode set to "include".
|
|
* @type {'use-credentials'}
|
|
*/
|
|
const USE_CREDENTIALS = 'use-credentials'
|
|
|
|
/**
|
|
* The EventSource interface is used to receive server-sent events. It
|
|
* connects to a server over HTTP and receives events in text/event-stream
|
|
* format without closing the connection.
|
|
* @extends {EventTarget}
|
|
* @see https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events
|
|
* @api public
|
|
*/
|
|
class EventSource extends EventTarget {
|
|
#events = {
|
|
open: null,
|
|
error: null,
|
|
message: null
|
|
}
|
|
|
|
#url = null
|
|
#withCredentials = false
|
|
|
|
#readyState = CONNECTING
|
|
|
|
#request = null
|
|
#controller = null
|
|
|
|
#dispatcher
|
|
|
|
/**
|
|
* @type {import('./eventsource-stream').eventSourceSettings}
|
|
*/
|
|
#state
|
|
|
|
/**
|
|
* Creates a new EventSource object.
|
|
* @param {string} url
|
|
* @param {EventSourceInit} [eventSourceInitDict]
|
|
* @see https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface
|
|
*/
|
|
constructor (url, eventSourceInitDict = {}) {
|
|
// 1. Let ev be a new EventSource object.
|
|
super()
|
|
|
|
webidl.util.markAsUncloneable(this)
|
|
|
|
const prefix = 'EventSource constructor'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
if (!experimentalWarned) {
|
|
experimentalWarned = true
|
|
process.emitWarning('EventSource is experimental, expect them to change at any time.', {
|
|
code: 'UNDICI-ES'
|
|
})
|
|
}
|
|
|
|
url = webidl.converters.USVString(url, prefix, 'url')
|
|
eventSourceInitDict = webidl.converters.EventSourceInitDict(eventSourceInitDict, prefix, 'eventSourceInitDict')
|
|
|
|
this.#dispatcher = eventSourceInitDict.dispatcher
|
|
this.#state = {
|
|
lastEventId: '',
|
|
reconnectionTime: defaultReconnectionTime
|
|
}
|
|
|
|
// 2. Let settings be ev's relevant settings object.
|
|
// https://html.spec.whatwg.org/multipage/webappapis.html#environment-settings-object
|
|
const settings = environmentSettingsObject
|
|
|
|
let urlRecord
|
|
|
|
try {
|
|
// 3. Let urlRecord be the result of encoding-parsing a URL given url, relative to settings.
|
|
urlRecord = new URL(url, settings.settingsObject.baseUrl)
|
|
this.#state.origin = urlRecord.origin
|
|
} catch (e) {
|
|
// 4. If urlRecord is failure, then throw a "SyntaxError" DOMException.
|
|
throw new DOMException(e, 'SyntaxError')
|
|
}
|
|
|
|
// 5. Set ev's url to urlRecord.
|
|
this.#url = urlRecord.href
|
|
|
|
// 6. Let corsAttributeState be Anonymous.
|
|
let corsAttributeState = ANONYMOUS
|
|
|
|
// 7. If the value of eventSourceInitDict's withCredentials member is true,
|
|
// then set corsAttributeState to Use Credentials and set ev's
|
|
// withCredentials attribute to true.
|
|
if (eventSourceInitDict.withCredentials) {
|
|
corsAttributeState = USE_CREDENTIALS
|
|
this.#withCredentials = true
|
|
}
|
|
|
|
// 8. Let request be the result of creating a potential-CORS request given
|
|
// urlRecord, the empty string, and corsAttributeState.
|
|
const initRequest = {
|
|
redirect: 'follow',
|
|
keepalive: true,
|
|
// @see https://html.spec.whatwg.org/multipage/urls-and-fetching.html#cors-settings-attributes
|
|
mode: 'cors',
|
|
credentials: corsAttributeState === 'anonymous'
|
|
? 'same-origin'
|
|
: 'omit',
|
|
referrer: 'no-referrer'
|
|
}
|
|
|
|
// 9. Set request's client to settings.
|
|
initRequest.client = environmentSettingsObject.settingsObject
|
|
|
|
// 10. User agents may set (`Accept`, `text/event-stream`) in request's header list.
|
|
initRequest.headersList = [['accept', { name: 'accept', value: 'text/event-stream' }]]
|
|
|
|
// 11. Set request's cache mode to "no-store".
|
|
initRequest.cache = 'no-store'
|
|
|
|
// 12. Set request's initiator type to "other".
|
|
initRequest.initiator = 'other'
|
|
|
|
initRequest.urlList = [new URL(this.#url)]
|
|
|
|
// 13. Set ev's request to request.
|
|
this.#request = makeRequest(initRequest)
|
|
|
|
this.#connect()
|
|
}
|
|
|
|
/**
|
|
* Returns the state of this EventSource object's connection. It can have the
|
|
* values described below.
|
|
* @returns {0|1|2}
|
|
* @readonly
|
|
*/
|
|
get readyState () {
|
|
return this.#readyState
|
|
}
|
|
|
|
/**
|
|
* Returns the URL providing the event stream.
|
|
* @readonly
|
|
* @returns {string}
|
|
*/
|
|
get url () {
|
|
return this.#url
|
|
}
|
|
|
|
/**
|
|
* Returns a boolean indicating whether the EventSource object was
|
|
* instantiated with CORS credentials set (true), or not (false, the default).
|
|
*/
|
|
get withCredentials () {
|
|
return this.#withCredentials
|
|
}
|
|
|
|
#connect () {
|
|
if (this.#readyState === CLOSED) return
|
|
|
|
this.#readyState = CONNECTING
|
|
|
|
const fetchParams = {
|
|
request: this.#request,
|
|
dispatcher: this.#dispatcher
|
|
}
|
|
|
|
// 14. Let processEventSourceEndOfBody given response res be the following step: if res is not a network error, then reestablish the connection.
|
|
const processEventSourceEndOfBody = (response) => {
|
|
if (isNetworkError(response)) {
|
|
this.dispatchEvent(new Event('error'))
|
|
this.close()
|
|
}
|
|
|
|
this.#reconnect()
|
|
}
|
|
|
|
// 15. Fetch request, with processResponseEndOfBody set to processEventSourceEndOfBody...
|
|
fetchParams.processResponseEndOfBody = processEventSourceEndOfBody
|
|
|
|
// and processResponse set to the following steps given response res:
|
|
fetchParams.processResponse = (response) => {
|
|
// 1. If res is an aborted network error, then fail the connection.
|
|
|
|
if (isNetworkError(response)) {
|
|
// 1. When a user agent is to fail the connection, the user agent
|
|
// must queue a task which, if the readyState attribute is set to a
|
|
// value other than CLOSED, sets the readyState attribute to CLOSED
|
|
// and fires an event named error at the EventSource object. Once the
|
|
// user agent has failed the connection, it does not attempt to
|
|
// reconnect.
|
|
if (response.aborted) {
|
|
this.close()
|
|
this.dispatchEvent(new Event('error'))
|
|
return
|
|
// 2. Otherwise, if res is a network error, then reestablish the
|
|
// connection, unless the user agent knows that to be futile, in
|
|
// which case the user agent may fail the connection.
|
|
} else {
|
|
this.#reconnect()
|
|
return
|
|
}
|
|
}
|
|
|
|
// 3. Otherwise, if res's status is not 200, or if res's `Content-Type`
|
|
// is not `text/event-stream`, then fail the connection.
|
|
const contentType = response.headersList.get('content-type', true)
|
|
const mimeType = contentType !== null ? parseMIMEType(contentType) : 'failure'
|
|
const contentTypeValid = mimeType !== 'failure' && mimeType.essence === 'text/event-stream'
|
|
if (
|
|
response.status !== 200 ||
|
|
contentTypeValid === false
|
|
) {
|
|
this.close()
|
|
this.dispatchEvent(new Event('error'))
|
|
return
|
|
}
|
|
|
|
// 4. Otherwise, announce the connection and interpret res's body
|
|
// line by line.
|
|
|
|
// When a user agent is to announce the connection, the user agent
|
|
// must queue a task which, if the readyState attribute is set to a
|
|
// value other than CLOSED, sets the readyState attribute to OPEN
|
|
// and fires an event named open at the EventSource object.
|
|
// @see https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model
|
|
this.#readyState = OPEN
|
|
this.dispatchEvent(new Event('open'))
|
|
|
|
// If redirected to a different origin, set the origin to the new origin.
|
|
this.#state.origin = response.urlList[response.urlList.length - 1].origin
|
|
|
|
const eventSourceStream = new EventSourceStream({
|
|
eventSourceSettings: this.#state,
|
|
push: (event) => {
|
|
this.dispatchEvent(createFastMessageEvent(
|
|
event.type,
|
|
event.options
|
|
))
|
|
}
|
|
})
|
|
|
|
pipeline(response.body.stream,
|
|
eventSourceStream,
|
|
(error) => {
|
|
if (
|
|
error?.aborted === false
|
|
) {
|
|
this.close()
|
|
this.dispatchEvent(new Event('error'))
|
|
}
|
|
})
|
|
}
|
|
|
|
this.#controller = fetching(fetchParams)
|
|
}
|
|
|
|
/**
|
|
* @see https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async #reconnect () {
|
|
// When a user agent is to reestablish the connection, the user agent must
|
|
// run the following steps. These steps are run in parallel, not as part of
|
|
// a task. (The tasks that it queues, of course, are run like normal tasks
|
|
// and not themselves in parallel.)
|
|
|
|
// 1. Queue a task to run the following steps:
|
|
|
|
// 1. If the readyState attribute is set to CLOSED, abort the task.
|
|
if (this.#readyState === CLOSED) return
|
|
|
|
// 2. Set the readyState attribute to CONNECTING.
|
|
this.#readyState = CONNECTING
|
|
|
|
// 3. Fire an event named error at the EventSource object.
|
|
this.dispatchEvent(new Event('error'))
|
|
|
|
// 2. Wait a delay equal to the reconnection time of the event source.
|
|
await delay(this.#state.reconnectionTime)
|
|
|
|
// 5. Queue a task to run the following steps:
|
|
|
|
// 1. If the EventSource object's readyState attribute is not set to
|
|
// CONNECTING, then return.
|
|
if (this.#readyState !== CONNECTING) return
|
|
|
|
// 2. Let request be the EventSource object's request.
|
|
// 3. If the EventSource object's last event ID string is not the empty
|
|
// string, then:
|
|
// 1. Let lastEventIDValue be the EventSource object's last event ID
|
|
// string, encoded as UTF-8.
|
|
// 2. Set (`Last-Event-ID`, lastEventIDValue) in request's header
|
|
// list.
|
|
if (this.#state.lastEventId.length) {
|
|
this.#request.headersList.set('last-event-id', this.#state.lastEventId, true)
|
|
}
|
|
|
|
// 4. Fetch request and process the response obtained in this fashion, if any, as described earlier in this section.
|
|
this.#connect()
|
|
}
|
|
|
|
/**
|
|
* Closes the connection, if any, and sets the readyState attribute to
|
|
* CLOSED.
|
|
*/
|
|
close () {
|
|
webidl.brandCheck(this, EventSource)
|
|
|
|
if (this.#readyState === CLOSED) return
|
|
this.#readyState = CLOSED
|
|
this.#controller.abort()
|
|
this.#request = null
|
|
}
|
|
|
|
get onopen () {
|
|
return this.#events.open
|
|
}
|
|
|
|
set onopen (fn) {
|
|
if (this.#events.open) {
|
|
this.removeEventListener('open', this.#events.open)
|
|
}
|
|
|
|
if (typeof fn === 'function') {
|
|
this.#events.open = fn
|
|
this.addEventListener('open', fn)
|
|
} else {
|
|
this.#events.open = null
|
|
}
|
|
}
|
|
|
|
get onmessage () {
|
|
return this.#events.message
|
|
}
|
|
|
|
set onmessage (fn) {
|
|
if (this.#events.message) {
|
|
this.removeEventListener('message', this.#events.message)
|
|
}
|
|
|
|
if (typeof fn === 'function') {
|
|
this.#events.message = fn
|
|
this.addEventListener('message', fn)
|
|
} else {
|
|
this.#events.message = null
|
|
}
|
|
}
|
|
|
|
get onerror () {
|
|
return this.#events.error
|
|
}
|
|
|
|
set onerror (fn) {
|
|
if (this.#events.error) {
|
|
this.removeEventListener('error', this.#events.error)
|
|
}
|
|
|
|
if (typeof fn === 'function') {
|
|
this.#events.error = fn
|
|
this.addEventListener('error', fn)
|
|
} else {
|
|
this.#events.error = null
|
|
}
|
|
}
|
|
}
|
|
|
|
const constantsPropertyDescriptors = {
|
|
CONNECTING: {
|
|
__proto__: null,
|
|
configurable: false,
|
|
enumerable: true,
|
|
value: CONNECTING,
|
|
writable: false
|
|
},
|
|
OPEN: {
|
|
__proto__: null,
|
|
configurable: false,
|
|
enumerable: true,
|
|
value: OPEN,
|
|
writable: false
|
|
},
|
|
CLOSED: {
|
|
__proto__: null,
|
|
configurable: false,
|
|
enumerable: true,
|
|
value: CLOSED,
|
|
writable: false
|
|
}
|
|
}
|
|
|
|
Object.defineProperties(EventSource, constantsPropertyDescriptors)
|
|
Object.defineProperties(EventSource.prototype, constantsPropertyDescriptors)
|
|
|
|
Object.defineProperties(EventSource.prototype, {
|
|
close: kEnumerableProperty,
|
|
onerror: kEnumerableProperty,
|
|
onmessage: kEnumerableProperty,
|
|
onopen: kEnumerableProperty,
|
|
readyState: kEnumerableProperty,
|
|
url: kEnumerableProperty,
|
|
withCredentials: kEnumerableProperty
|
|
})
|
|
|
|
webidl.converters.EventSourceInitDict = webidl.dictionaryConverter([
|
|
{
|
|
key: 'withCredentials',
|
|
converter: webidl.converters.boolean,
|
|
defaultValue: () => false
|
|
},
|
|
{
|
|
key: 'dispatcher', // undici only
|
|
converter: webidl.converters.any
|
|
}
|
|
])
|
|
|
|
module.exports = {
|
|
EventSource,
|
|
defaultReconnectionTime
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4811:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
/**
|
|
* Checks if the given value is a valid LastEventId.
|
|
* @param {string} value
|
|
* @returns {boolean}
|
|
*/
|
|
function isValidLastEventId (value) {
|
|
// LastEventId should not contain U+0000 NULL
|
|
return value.indexOf('\u0000') === -1
|
|
}
|
|
|
|
/**
|
|
* Checks if the given value is a base 10 digit.
|
|
* @param {string} value
|
|
* @returns {boolean}
|
|
*/
|
|
function isASCIINumber (value) {
|
|
if (value.length === 0) return false
|
|
for (let i = 0; i < value.length; i++) {
|
|
if (value.charCodeAt(i) < 0x30 || value.charCodeAt(i) > 0x39) return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
// https://github.com/nodejs/undici/issues/2664
|
|
function delay (ms) {
|
|
return new Promise((resolve) => {
|
|
setTimeout(resolve, ms).unref()
|
|
})
|
|
}
|
|
|
|
module.exports = {
|
|
isValidLastEventId,
|
|
isASCIINumber,
|
|
delay
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4492:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const util = __nccwpck_require__(3440)
|
|
const {
|
|
ReadableStreamFrom,
|
|
isBlobLike,
|
|
isReadableStreamLike,
|
|
readableStreamClose,
|
|
createDeferredPromise,
|
|
fullyReadBody,
|
|
extractMimeType,
|
|
utf8DecodeBytes
|
|
} = __nccwpck_require__(3168)
|
|
const { FormData } = __nccwpck_require__(5910)
|
|
const { kState } = __nccwpck_require__(3627)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const { Blob } = __nccwpck_require__(4573)
|
|
const assert = __nccwpck_require__(4589)
|
|
const { isErrored, isDisturbed } = __nccwpck_require__(7075)
|
|
const { isArrayBuffer } = __nccwpck_require__(3429)
|
|
const { serializeAMimeType } = __nccwpck_require__(1900)
|
|
const { multipartFormDataParser } = __nccwpck_require__(116)
|
|
let random
|
|
|
|
try {
|
|
const crypto = __nccwpck_require__(7598)
|
|
random = (max) => crypto.randomInt(0, max)
|
|
} catch {
|
|
random = (max) => Math.floor(Math.random(max))
|
|
}
|
|
|
|
const textEncoder = new TextEncoder()
|
|
function noop () {}
|
|
|
|
const hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf('v18') !== 0
|
|
let streamRegistry
|
|
|
|
if (hasFinalizationRegistry) {
|
|
streamRegistry = new FinalizationRegistry((weakRef) => {
|
|
const stream = weakRef.deref()
|
|
if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) {
|
|
stream.cancel('Response object has been garbage collected').catch(noop)
|
|
}
|
|
})
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#concept-bodyinit-extract
|
|
function extractBody (object, keepalive = false) {
|
|
// 1. Let stream be null.
|
|
let stream = null
|
|
|
|
// 2. If object is a ReadableStream object, then set stream to object.
|
|
if (object instanceof ReadableStream) {
|
|
stream = object
|
|
} else if (isBlobLike(object)) {
|
|
// 3. Otherwise, if object is a Blob object, set stream to the
|
|
// result of running object’s get stream.
|
|
stream = object.stream()
|
|
} else {
|
|
// 4. Otherwise, set stream to a new ReadableStream object, and set
|
|
// up stream with byte reading support.
|
|
stream = new ReadableStream({
|
|
async pull (controller) {
|
|
const buffer = typeof source === 'string' ? textEncoder.encode(source) : source
|
|
|
|
if (buffer.byteLength) {
|
|
controller.enqueue(buffer)
|
|
}
|
|
|
|
queueMicrotask(() => readableStreamClose(controller))
|
|
},
|
|
start () {},
|
|
type: 'bytes'
|
|
})
|
|
}
|
|
|
|
// 5. Assert: stream is a ReadableStream object.
|
|
assert(isReadableStreamLike(stream))
|
|
|
|
// 6. Let action be null.
|
|
let action = null
|
|
|
|
// 7. Let source be null.
|
|
let source = null
|
|
|
|
// 8. Let length be null.
|
|
let length = null
|
|
|
|
// 9. Let type be null.
|
|
let type = null
|
|
|
|
// 10. Switch on object:
|
|
if (typeof object === 'string') {
|
|
// Set source to the UTF-8 encoding of object.
|
|
// Note: setting source to a Uint8Array here breaks some mocking assumptions.
|
|
source = object
|
|
|
|
// Set type to `text/plain;charset=UTF-8`.
|
|
type = 'text/plain;charset=UTF-8'
|
|
} else if (object instanceof URLSearchParams) {
|
|
// URLSearchParams
|
|
|
|
// spec says to run application/x-www-form-urlencoded on body.list
|
|
// this is implemented in Node.js as apart of an URLSearchParams instance toString method
|
|
// See: https://github.com/nodejs/node/blob/e46c680bf2b211bbd52cf959ca17ee98c7f657f5/lib/internal/url.js#L490
|
|
// and https://github.com/nodejs/node/blob/e46c680bf2b211bbd52cf959ca17ee98c7f657f5/lib/internal/url.js#L1100
|
|
|
|
// Set source to the result of running the application/x-www-form-urlencoded serializer with object’s list.
|
|
source = object.toString()
|
|
|
|
// Set type to `application/x-www-form-urlencoded;charset=UTF-8`.
|
|
type = 'application/x-www-form-urlencoded;charset=UTF-8'
|
|
} else if (isArrayBuffer(object)) {
|
|
// BufferSource/ArrayBuffer
|
|
|
|
// Set source to a copy of the bytes held by object.
|
|
source = new Uint8Array(object.slice())
|
|
} else if (ArrayBuffer.isView(object)) {
|
|
// BufferSource/ArrayBufferView
|
|
|
|
// Set source to a copy of the bytes held by object.
|
|
source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength))
|
|
} else if (util.isFormDataLike(object)) {
|
|
const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, '0')}`
|
|
const prefix = `--${boundary}\r\nContent-Disposition: form-data`
|
|
|
|
/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
|
|
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')
|
|
|
|
// Set action to this step: run the multipart/form-data
|
|
// encoding algorithm, with object’s entry list and UTF-8.
|
|
// - This ensures that the body is immutable and can't be changed afterwords
|
|
// - That the content-length is calculated in advance.
|
|
// - And that all parts are pre-encoded and ready to be sent.
|
|
|
|
const blobParts = []
|
|
const rn = new Uint8Array([13, 10]) // '\r\n'
|
|
length = 0
|
|
let hasUnknownSizeValue = false
|
|
|
|
for (const [name, value] of object) {
|
|
if (typeof value === 'string') {
|
|
const chunk = textEncoder.encode(prefix +
|
|
`; name="${escape(normalizeLinefeeds(name))}"` +
|
|
`\r\n\r\n${normalizeLinefeeds(value)}\r\n`)
|
|
blobParts.push(chunk)
|
|
length += chunk.byteLength
|
|
} else {
|
|
const chunk = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` +
|
|
(value.name ? `; filename="${escape(value.name)}"` : '') + '\r\n' +
|
|
`Content-Type: ${
|
|
value.type || 'application/octet-stream'
|
|
}\r\n\r\n`)
|
|
blobParts.push(chunk, value, rn)
|
|
if (typeof value.size === 'number') {
|
|
length += chunk.byteLength + value.size + rn.byteLength
|
|
} else {
|
|
hasUnknownSizeValue = true
|
|
}
|
|
}
|
|
}
|
|
|
|
// CRLF is appended to the body to function with legacy servers and match other implementations.
|
|
// https://github.com/curl/curl/blob/3434c6b46e682452973972e8313613dfa58cd690/lib/mime.c#L1029-L1030
|
|
// https://github.com/form-data/form-data/issues/63
|
|
const chunk = textEncoder.encode(`--${boundary}--\r\n`)
|
|
blobParts.push(chunk)
|
|
length += chunk.byteLength
|
|
if (hasUnknownSizeValue) {
|
|
length = null
|
|
}
|
|
|
|
// Set source to object.
|
|
source = object
|
|
|
|
action = async function * () {
|
|
for (const part of blobParts) {
|
|
if (part.stream) {
|
|
yield * part.stream()
|
|
} else {
|
|
yield part
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set type to `multipart/form-data; boundary=`,
|
|
// followed by the multipart/form-data boundary string generated
|
|
// by the multipart/form-data encoding algorithm.
|
|
type = `multipart/form-data; boundary=${boundary}`
|
|
} else if (isBlobLike(object)) {
|
|
// Blob
|
|
|
|
// Set source to object.
|
|
source = object
|
|
|
|
// Set length to object’s size.
|
|
length = object.size
|
|
|
|
// If object’s type attribute is not the empty byte sequence, set
|
|
// type to its value.
|
|
if (object.type) {
|
|
type = object.type
|
|
}
|
|
} else if (typeof object[Symbol.asyncIterator] === 'function') {
|
|
// If keepalive is true, then throw a TypeError.
|
|
if (keepalive) {
|
|
throw new TypeError('keepalive')
|
|
}
|
|
|
|
// If object is disturbed or locked, then throw a TypeError.
|
|
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)
|
|
}
|
|
|
|
// 11. If source is a byte sequence, then set action to a
|
|
// step that returns source and length to source’s length.
|
|
if (typeof source === 'string' || util.isBuffer(source)) {
|
|
length = Buffer.byteLength(source)
|
|
}
|
|
|
|
// 12. If action is non-null, then run these steps in in parallel:
|
|
if (action != null) {
|
|
// Run action.
|
|
let iterator
|
|
stream = new ReadableStream({
|
|
async start () {
|
|
iterator = action(object)[Symbol.asyncIterator]()
|
|
},
|
|
async pull (controller) {
|
|
const { value, done } = await iterator.next()
|
|
if (done) {
|
|
// When running action is done, close stream.
|
|
queueMicrotask(() => {
|
|
controller.close()
|
|
controller.byobRequest?.respond(0)
|
|
})
|
|
} else {
|
|
// Whenever one or more bytes are available and stream is not errored,
|
|
// enqueue a Uint8Array wrapping an ArrayBuffer containing the available
|
|
// bytes into stream.
|
|
if (!isErrored(stream)) {
|
|
const buffer = new Uint8Array(value)
|
|
if (buffer.byteLength) {
|
|
controller.enqueue(buffer)
|
|
}
|
|
}
|
|
}
|
|
return controller.desiredSize > 0
|
|
},
|
|
async cancel (reason) {
|
|
await iterator.return()
|
|
},
|
|
type: 'bytes'
|
|
})
|
|
}
|
|
|
|
// 13. Let body be a body whose stream is stream, source is source,
|
|
// and length is length.
|
|
const body = { stream, source, length }
|
|
|
|
// 14. Return (body, type).
|
|
return [body, type]
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#bodyinit-safely-extract
|
|
function safelyExtractBody (object, keepalive = false) {
|
|
// To safely extract a body and a `Content-Type` value from
|
|
// a byte sequence or BodyInit object object, run these steps:
|
|
|
|
// 1. If object is a ReadableStream object, then:
|
|
if (object instanceof ReadableStream) {
|
|
// Assert: object is neither disturbed nor locked.
|
|
// istanbul ignore next
|
|
assert(!util.isDisturbed(object), 'The body has already been consumed.')
|
|
// istanbul ignore next
|
|
assert(!object.locked, 'The stream is locked.')
|
|
}
|
|
|
|
// 2. Return the results of extracting object.
|
|
return extractBody(object, keepalive)
|
|
}
|
|
|
|
function cloneBody (instance, body) {
|
|
// To clone a body body, run these steps:
|
|
|
|
// https://fetch.spec.whatwg.org/#concept-body-clone
|
|
|
|
// 1. Let « out1, out2 » be the result of teeing body’s stream.
|
|
const [out1, out2] = body.stream.tee()
|
|
|
|
// 2. Set body’s stream to out1.
|
|
body.stream = out1
|
|
|
|
// 3. Return a body whose stream is out2 and other members are copied from body.
|
|
return {
|
|
stream: out2,
|
|
length: body.length,
|
|
source: body.source
|
|
}
|
|
}
|
|
|
|
function throwIfAborted (state) {
|
|
if (state.aborted) {
|
|
throw new DOMException('The operation was aborted.', 'AbortError')
|
|
}
|
|
}
|
|
|
|
function bodyMixinMethods (instance) {
|
|
const methods = {
|
|
blob () {
|
|
// The blob() method steps are to return the result of
|
|
// running consume body with this and the following step
|
|
// given a byte sequence bytes: return a Blob whose
|
|
// contents are bytes and whose type attribute is this’s
|
|
// MIME type.
|
|
return consumeBody(this, (bytes) => {
|
|
let mimeType = bodyMimeType(this)
|
|
|
|
if (mimeType === null) {
|
|
mimeType = ''
|
|
} else if (mimeType) {
|
|
mimeType = serializeAMimeType(mimeType)
|
|
}
|
|
|
|
// Return a Blob whose contents are bytes and type attribute
|
|
// is mimeType.
|
|
return new Blob([bytes], { type: mimeType })
|
|
}, instance)
|
|
},
|
|
|
|
arrayBuffer () {
|
|
// The arrayBuffer() method steps are to return the result
|
|
// of running consume body with this and the following step
|
|
// given a byte sequence bytes: return a new ArrayBuffer
|
|
// whose contents are bytes.
|
|
return consumeBody(this, (bytes) => {
|
|
return new Uint8Array(bytes).buffer
|
|
}, instance)
|
|
},
|
|
|
|
text () {
|
|
// The text() method steps are to return the result of running
|
|
// consume body with this and UTF-8 decode.
|
|
return consumeBody(this, utf8DecodeBytes, instance)
|
|
},
|
|
|
|
json () {
|
|
// The json() method steps are to return the result of running
|
|
// consume body with this and parse JSON from bytes.
|
|
return consumeBody(this, parseJSONFromBytes, instance)
|
|
},
|
|
|
|
formData () {
|
|
// The formData() method steps are to return the result of running
|
|
// consume body with this and the following step given a byte sequence bytes:
|
|
return consumeBody(this, (value) => {
|
|
// 1. Let mimeType be the result of get the MIME type with this.
|
|
const mimeType = bodyMimeType(this)
|
|
|
|
// 2. If mimeType is non-null, then switch on mimeType’s essence and run
|
|
// the corresponding steps:
|
|
if (mimeType !== null) {
|
|
switch (mimeType.essence) {
|
|
case 'multipart/form-data': {
|
|
// 1. ... [long step]
|
|
const parsed = multipartFormDataParser(value, mimeType)
|
|
|
|
// 2. If that fails for some reason, then throw a TypeError.
|
|
if (parsed === 'failure') {
|
|
throw new TypeError('Failed to parse body as FormData.')
|
|
}
|
|
|
|
// 3. Return a new FormData object, appending each entry,
|
|
// resulting from the parsing operation, to its entry list.
|
|
const fd = new FormData()
|
|
fd[kState] = parsed
|
|
|
|
return fd
|
|
}
|
|
case 'application/x-www-form-urlencoded': {
|
|
// 1. Let entries be the result of parsing bytes.
|
|
const entries = new URLSearchParams(value.toString())
|
|
|
|
// 2. If entries is failure, then throw a TypeError.
|
|
|
|
// 3. Return a new FormData object whose entry list is entries.
|
|
const fd = new FormData()
|
|
|
|
for (const [name, value] of entries) {
|
|
fd.append(name, value)
|
|
}
|
|
|
|
return fd
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. Throw a TypeError.
|
|
throw new TypeError(
|
|
'Content-Type was not one of "multipart/form-data" or "application/x-www-form-urlencoded".'
|
|
)
|
|
}, instance)
|
|
},
|
|
|
|
bytes () {
|
|
// The bytes() method steps are to return the result of running consume body
|
|
// with this and the following step given a byte sequence bytes: return the
|
|
// result of creating a Uint8Array from bytes in this’s relevant realm.
|
|
return consumeBody(this, (bytes) => {
|
|
return new Uint8Array(bytes)
|
|
}, instance)
|
|
}
|
|
}
|
|
|
|
return methods
|
|
}
|
|
|
|
function mixinBody (prototype) {
|
|
Object.assign(prototype.prototype, bodyMixinMethods(prototype))
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#concept-body-consume-body
|
|
* @param {Response|Request} object
|
|
* @param {(value: unknown) => unknown} convertBytesToJSValue
|
|
* @param {Response|Request} instance
|
|
*/
|
|
async function consumeBody (object, convertBytesToJSValue, instance) {
|
|
webidl.brandCheck(object, instance)
|
|
|
|
// 1. If object is unusable, then return a promise rejected
|
|
// with a TypeError.
|
|
if (bodyUnusable(object)) {
|
|
throw new TypeError('Body is unusable: Body has already been read')
|
|
}
|
|
|
|
throwIfAborted(object[kState])
|
|
|
|
// 2. Let promise be a new promise.
|
|
const promise = createDeferredPromise()
|
|
|
|
// 3. Let errorSteps given error be to reject promise with error.
|
|
const errorSteps = (error) => promise.reject(error)
|
|
|
|
// 4. Let successSteps given a byte sequence data be to resolve
|
|
// promise with the result of running convertBytesToJSValue
|
|
// with data. If that threw an exception, then run errorSteps
|
|
// with that exception.
|
|
const successSteps = (data) => {
|
|
try {
|
|
promise.resolve(convertBytesToJSValue(data))
|
|
} catch (e) {
|
|
errorSteps(e)
|
|
}
|
|
}
|
|
|
|
// 5. If object’s body is null, then run successSteps with an
|
|
// empty byte sequence.
|
|
if (object[kState].body == null) {
|
|
successSteps(Buffer.allocUnsafe(0))
|
|
return promise.promise
|
|
}
|
|
|
|
// 6. Otherwise, fully read object’s body given successSteps,
|
|
// errorSteps, and object’s relevant global object.
|
|
await fullyReadBody(object[kState].body, successSteps, errorSteps)
|
|
|
|
// 7. Return promise.
|
|
return promise.promise
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#body-unusable
|
|
function bodyUnusable (object) {
|
|
const body = object[kState].body
|
|
|
|
// An object including the Body interface mixin is
|
|
// said to be unusable if its body is non-null and
|
|
// its body’s stream is disturbed or locked.
|
|
return body != null && (body.stream.locked || util.isDisturbed(body.stream))
|
|
}
|
|
|
|
/**
|
|
* @see https://infra.spec.whatwg.org/#parse-json-bytes-to-a-javascript-value
|
|
* @param {Uint8Array} bytes
|
|
*/
|
|
function parseJSONFromBytes (bytes) {
|
|
return JSON.parse(utf8DecodeBytes(bytes))
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#concept-body-mime-type
|
|
* @param {import('./response').Response|import('./request').Request} requestOrResponse
|
|
*/
|
|
function bodyMimeType (requestOrResponse) {
|
|
// 1. Let headers be null.
|
|
// 2. If requestOrResponse is a Request object, then set headers to requestOrResponse’s request’s header list.
|
|
// 3. Otherwise, set headers to requestOrResponse’s response’s header list.
|
|
/** @type {import('./headers').HeadersList} */
|
|
const headers = requestOrResponse[kState].headersList
|
|
|
|
// 4. Let mimeType be the result of extracting a MIME type from headers.
|
|
const mimeType = extractMimeType(headers)
|
|
|
|
// 5. If mimeType is failure, then return null.
|
|
if (mimeType === 'failure') {
|
|
return null
|
|
}
|
|
|
|
// 6. Return mimeType.
|
|
return mimeType
|
|
}
|
|
|
|
module.exports = {
|
|
extractBody,
|
|
safelyExtractBody,
|
|
cloneBody,
|
|
mixinBody,
|
|
streamRegistry,
|
|
hasFinalizationRegistry,
|
|
bodyUnusable
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4495:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
const corsSafeListedMethods = /** @type {const} */ (['GET', 'HEAD', 'POST'])
|
|
const corsSafeListedMethodsSet = new Set(corsSafeListedMethods)
|
|
|
|
const nullBodyStatus = /** @type {const} */ ([101, 204, 205, 304])
|
|
|
|
const redirectStatus = /** @type {const} */ ([301, 302, 303, 307, 308])
|
|
const redirectStatusSet = new Set(redirectStatus)
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#block-bad-port
|
|
*/
|
|
const badPorts = /** @type {const} */ ([
|
|
'1', '7', '9', '11', '13', '15', '17', '19', '20', '21', '22', '23', '25', '37', '42', '43', '53', '69', '77', '79',
|
|
'87', '95', '101', '102', '103', '104', '109', '110', '111', '113', '115', '117', '119', '123', '135', '137',
|
|
'139', '143', '161', '179', '389', '427', '465', '512', '513', '514', '515', '526', '530', '531', '532',
|
|
'540', '548', '554', '556', '563', '587', '601', '636', '989', '990', '993', '995', '1719', '1720', '1723',
|
|
'2049', '3659', '4045', '4190', '5060', '5061', '6000', '6566', '6665', '6666', '6667', '6668', '6669', '6679',
|
|
'6697', '10080'
|
|
])
|
|
const badPortsSet = new Set(badPorts)
|
|
|
|
/**
|
|
* @see https://w3c.github.io/webappsec-referrer-policy/#referrer-policies
|
|
*/
|
|
const referrerPolicy = /** @type {const} */ ([
|
|
'',
|
|
'no-referrer',
|
|
'no-referrer-when-downgrade',
|
|
'same-origin',
|
|
'origin',
|
|
'strict-origin',
|
|
'origin-when-cross-origin',
|
|
'strict-origin-when-cross-origin',
|
|
'unsafe-url'
|
|
])
|
|
const referrerPolicySet = new Set(referrerPolicy)
|
|
|
|
const requestRedirect = /** @type {const} */ (['follow', 'manual', 'error'])
|
|
|
|
const safeMethods = /** @type {const} */ (['GET', 'HEAD', 'OPTIONS', 'TRACE'])
|
|
const safeMethodsSet = new Set(safeMethods)
|
|
|
|
const requestMode = /** @type {const} */ (['navigate', 'same-origin', 'no-cors', 'cors'])
|
|
|
|
const requestCredentials = /** @type {const} */ (['omit', 'same-origin', 'include'])
|
|
|
|
const requestCache = /** @type {const} */ ([
|
|
'default',
|
|
'no-store',
|
|
'reload',
|
|
'no-cache',
|
|
'force-cache',
|
|
'only-if-cached'
|
|
])
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#request-body-header-name
|
|
*/
|
|
const requestBodyHeader = /** @type {const} */ ([
|
|
'content-encoding',
|
|
'content-language',
|
|
'content-location',
|
|
'content-type',
|
|
// See https://github.com/nodejs/undici/issues/2021
|
|
// 'Content-Length' is a forbidden header name, which is typically
|
|
// removed in the Headers implementation. However, undici doesn't
|
|
// filter out headers, so we add it here.
|
|
'content-length'
|
|
])
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#enumdef-requestduplex
|
|
*/
|
|
const requestDuplex = /** @type {const} */ ([
|
|
'half'
|
|
])
|
|
|
|
/**
|
|
* @see http://fetch.spec.whatwg.org/#forbidden-method
|
|
*/
|
|
const forbiddenMethods = /** @type {const} */ (['CONNECT', 'TRACE', 'TRACK'])
|
|
const forbiddenMethodsSet = new Set(forbiddenMethods)
|
|
|
|
const subresource = /** @type {const} */ ([
|
|
'audio',
|
|
'audioworklet',
|
|
'font',
|
|
'image',
|
|
'manifest',
|
|
'paintworklet',
|
|
'script',
|
|
'style',
|
|
'track',
|
|
'video',
|
|
'xslt',
|
|
''
|
|
])
|
|
const subresourceSet = new Set(subresource)
|
|
|
|
module.exports = {
|
|
subresource,
|
|
forbiddenMethods,
|
|
requestBodyHeader,
|
|
referrerPolicy,
|
|
requestRedirect,
|
|
requestMode,
|
|
requestCredentials,
|
|
requestCache,
|
|
redirectStatus,
|
|
corsSafeListedMethods,
|
|
nullBodyStatus,
|
|
safeMethods,
|
|
badPorts,
|
|
requestDuplex,
|
|
subresourceSet,
|
|
badPortsSet,
|
|
redirectStatusSet,
|
|
corsSafeListedMethodsSet,
|
|
safeMethodsSet,
|
|
forbiddenMethodsSet,
|
|
referrerPolicySet
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1900:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const assert = __nccwpck_require__(4589)
|
|
|
|
const encoder = new TextEncoder()
|
|
|
|
/**
|
|
* @see https://mimesniff.spec.whatwg.org/#http-token-code-point
|
|
*/
|
|
const HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+\-.^_|~A-Za-z0-9]+$/
|
|
const HTTP_WHITESPACE_REGEX = /[\u000A\u000D\u0009\u0020]/ // eslint-disable-line
|
|
const ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g // eslint-disable-line
|
|
/**
|
|
* @see https://mimesniff.spec.whatwg.org/#http-quoted-string-token-code-point
|
|
*/
|
|
const HTTP_QUOTED_STRING_TOKENS = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/ // eslint-disable-line
|
|
|
|
// https://fetch.spec.whatwg.org/#data-url-processor
|
|
/** @param {URL} dataURL */
|
|
function dataURLProcessor (dataURL) {
|
|
// 1. Assert: dataURL’s scheme is "data".
|
|
assert(dataURL.protocol === 'data:')
|
|
|
|
// 2. Let input be the result of running the URL
|
|
// serializer on dataURL with exclude fragment
|
|
// set to true.
|
|
let input = URLSerializer(dataURL, true)
|
|
|
|
// 3. Remove the leading "data:" string from input.
|
|
input = input.slice(5)
|
|
|
|
// 4. Let position point at the start of input.
|
|
const position = { position: 0 }
|
|
|
|
// 5. Let mimeType be the result of collecting a
|
|
// sequence of code points that are not equal
|
|
// to U+002C (,), given position.
|
|
let mimeType = collectASequenceOfCodePointsFast(
|
|
',',
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 6. Strip leading and trailing ASCII whitespace
|
|
// from mimeType.
|
|
// Undici implementation note: we need to store the
|
|
// length because if the mimetype has spaces removed,
|
|
// the wrong amount will be sliced from the input in
|
|
// step #9
|
|
const mimeTypeLength = mimeType.length
|
|
mimeType = removeASCIIWhitespace(mimeType, true, true)
|
|
|
|
// 7. If position is past the end of input, then
|
|
// return failure
|
|
if (position.position >= input.length) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 8. Advance position by 1.
|
|
position.position++
|
|
|
|
// 9. Let encodedBody be the remainder of input.
|
|
const encodedBody = input.slice(mimeTypeLength + 1)
|
|
|
|
// 10. Let body be the percent-decoding of encodedBody.
|
|
let body = stringPercentDecode(encodedBody)
|
|
|
|
// 11. If mimeType ends with U+003B (;), followed by
|
|
// zero or more U+0020 SPACE, followed by an ASCII
|
|
// case-insensitive match for "base64", then:
|
|
if (/;(\u0020){0,}base64$/i.test(mimeType)) {
|
|
// 1. Let stringBody be the isomorphic decode of body.
|
|
const stringBody = isomorphicDecode(body)
|
|
|
|
// 2. Set body to the forgiving-base64 decode of
|
|
// stringBody.
|
|
body = forgivingBase64(stringBody)
|
|
|
|
// 3. If body is failure, then return failure.
|
|
if (body === 'failure') {
|
|
return 'failure'
|
|
}
|
|
|
|
// 4. Remove the last 6 code points from mimeType.
|
|
mimeType = mimeType.slice(0, -6)
|
|
|
|
// 5. Remove trailing U+0020 SPACE code points from mimeType,
|
|
// if any.
|
|
mimeType = mimeType.replace(/(\u0020)+$/, '')
|
|
|
|
// 6. Remove the last U+003B (;) code point from mimeType.
|
|
mimeType = mimeType.slice(0, -1)
|
|
}
|
|
|
|
// 12. If mimeType starts with U+003B (;), then prepend
|
|
// "text/plain" to mimeType.
|
|
if (mimeType.startsWith(';')) {
|
|
mimeType = 'text/plain' + mimeType
|
|
}
|
|
|
|
// 13. Let mimeTypeRecord be the result of parsing
|
|
// mimeType.
|
|
let mimeTypeRecord = parseMIMEType(mimeType)
|
|
|
|
// 14. If mimeTypeRecord is failure, then set
|
|
// mimeTypeRecord to text/plain;charset=US-ASCII.
|
|
if (mimeTypeRecord === 'failure') {
|
|
mimeTypeRecord = parseMIMEType('text/plain;charset=US-ASCII')
|
|
}
|
|
|
|
// 15. Return a new data: URL struct whose MIME
|
|
// type is mimeTypeRecord and body is body.
|
|
// https://fetch.spec.whatwg.org/#data-url-struct
|
|
return { mimeType: mimeTypeRecord, body }
|
|
}
|
|
|
|
// https://url.spec.whatwg.org/#concept-url-serializer
|
|
/**
|
|
* @param {URL} url
|
|
* @param {boolean} excludeFragment
|
|
*/
|
|
function URLSerializer (url, excludeFragment = false) {
|
|
if (!excludeFragment) {
|
|
return url.href
|
|
}
|
|
|
|
const href = url.href
|
|
const hashLength = url.hash.length
|
|
|
|
const serialized = hashLength === 0 ? href : href.substring(0, href.length - hashLength)
|
|
|
|
if (!hashLength && href.endsWith('#')) {
|
|
return serialized.slice(0, -1)
|
|
}
|
|
|
|
return serialized
|
|
}
|
|
|
|
// https://infra.spec.whatwg.org/#collect-a-sequence-of-code-points
|
|
/**
|
|
* @param {(char: string) => boolean} condition
|
|
* @param {string} input
|
|
* @param {{ position: number }} position
|
|
*/
|
|
function collectASequenceOfCodePoints (condition, input, position) {
|
|
// 1. Let result be the empty string.
|
|
let result = ''
|
|
|
|
// 2. While position doesn’t point past the end of input and the
|
|
// code point at position within input meets the condition condition:
|
|
while (position.position < input.length && condition(input[position.position])) {
|
|
// 1. Append that code point to the end of result.
|
|
result += input[position.position]
|
|
|
|
// 2. Advance position by 1.
|
|
position.position++
|
|
}
|
|
|
|
// 3. Return result.
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* A faster collectASequenceOfCodePoints that only works when comparing a single character.
|
|
* @param {string} char
|
|
* @param {string} input
|
|
* @param {{ position: number }} position
|
|
*/
|
|
function collectASequenceOfCodePointsFast (char, input, position) {
|
|
const idx = input.indexOf(char, position.position)
|
|
const start = position.position
|
|
|
|
if (idx === -1) {
|
|
position.position = input.length
|
|
return input.slice(start)
|
|
}
|
|
|
|
position.position = idx
|
|
return input.slice(start, position.position)
|
|
}
|
|
|
|
// https://url.spec.whatwg.org/#string-percent-decode
|
|
/** @param {string} input */
|
|
function stringPercentDecode (input) {
|
|
// 1. Let bytes be the UTF-8 encoding of input.
|
|
const bytes = encoder.encode(input)
|
|
|
|
// 2. Return the percent-decoding of bytes.
|
|
return percentDecode(bytes)
|
|
}
|
|
|
|
/**
|
|
* @param {number} byte
|
|
*/
|
|
function isHexCharByte (byte) {
|
|
// 0-9 A-F a-f
|
|
return (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x46) || (byte >= 0x61 && byte <= 0x66)
|
|
}
|
|
|
|
/**
|
|
* @param {number} byte
|
|
*/
|
|
function hexByteToNumber (byte) {
|
|
return (
|
|
// 0-9
|
|
byte >= 0x30 && byte <= 0x39
|
|
? (byte - 48)
|
|
// Convert to uppercase
|
|
// ((byte & 0xDF) - 65) + 10
|
|
: ((byte & 0xDF) - 55)
|
|
)
|
|
}
|
|
|
|
// https://url.spec.whatwg.org/#percent-decode
|
|
/** @param {Uint8Array} input */
|
|
function percentDecode (input) {
|
|
const length = input.length
|
|
// 1. Let output be an empty byte sequence.
|
|
/** @type {Uint8Array} */
|
|
const output = new Uint8Array(length)
|
|
let j = 0
|
|
// 2. For each byte byte in input:
|
|
for (let i = 0; i < length; ++i) {
|
|
const byte = input[i]
|
|
|
|
// 1. If byte is not 0x25 (%), then append byte to output.
|
|
if (byte !== 0x25) {
|
|
output[j++] = byte
|
|
|
|
// 2. Otherwise, if byte is 0x25 (%) and the next two bytes
|
|
// after byte in input are not in the ranges
|
|
// 0x30 (0) to 0x39 (9), 0x41 (A) to 0x46 (F),
|
|
// and 0x61 (a) to 0x66 (f), all inclusive, append byte
|
|
// to output.
|
|
} else if (
|
|
byte === 0x25 &&
|
|
!(isHexCharByte(input[i + 1]) && isHexCharByte(input[i + 2]))
|
|
) {
|
|
output[j++] = 0x25
|
|
|
|
// 3. Otherwise:
|
|
} else {
|
|
// 1. Let bytePoint be the two bytes after byte in input,
|
|
// decoded, and then interpreted as hexadecimal number.
|
|
// 2. Append a byte whose value is bytePoint to output.
|
|
output[j++] = (hexByteToNumber(input[i + 1]) << 4) | hexByteToNumber(input[i + 2])
|
|
|
|
// 3. Skip the next two bytes in input.
|
|
i += 2
|
|
}
|
|
}
|
|
|
|
// 3. Return output.
|
|
return length === j ? output : output.subarray(0, j)
|
|
}
|
|
|
|
// https://mimesniff.spec.whatwg.org/#parse-a-mime-type
|
|
/** @param {string} input */
|
|
function parseMIMEType (input) {
|
|
// 1. Remove any leading and trailing HTTP whitespace
|
|
// from input.
|
|
input = removeHTTPWhitespace(input, true, true)
|
|
|
|
// 2. Let position be a position variable for input,
|
|
// initially pointing at the start of input.
|
|
const position = { position: 0 }
|
|
|
|
// 3. Let type be the result of collecting a sequence
|
|
// of code points that are not U+002F (/) from
|
|
// input, given position.
|
|
const type = collectASequenceOfCodePointsFast(
|
|
'/',
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 4. If type is the empty string or does not solely
|
|
// contain HTTP token code points, then return failure.
|
|
// https://mimesniff.spec.whatwg.org/#http-token-code-point
|
|
if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 5. If position is past the end of input, then return
|
|
// failure
|
|
if (position.position > input.length) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 6. Advance position by 1. (This skips past U+002F (/).)
|
|
position.position++
|
|
|
|
// 7. Let subtype be the result of collecting a sequence of
|
|
// code points that are not U+003B (;) from input, given
|
|
// position.
|
|
let subtype = collectASequenceOfCodePointsFast(
|
|
';',
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 8. Remove any trailing HTTP whitespace from subtype.
|
|
subtype = removeHTTPWhitespace(subtype, false, true)
|
|
|
|
// 9. If subtype is the empty string or does not solely
|
|
// contain HTTP token code points, then return failure.
|
|
if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
|
|
return 'failure'
|
|
}
|
|
|
|
const typeLowercase = type.toLowerCase()
|
|
const subtypeLowercase = subtype.toLowerCase()
|
|
|
|
// 10. Let mimeType be a new MIME type record whose type
|
|
// is type, in ASCII lowercase, and subtype is subtype,
|
|
// in ASCII lowercase.
|
|
// https://mimesniff.spec.whatwg.org/#mime-type
|
|
const mimeType = {
|
|
type: typeLowercase,
|
|
subtype: subtypeLowercase,
|
|
/** @type {Map<string, string>} */
|
|
parameters: new Map(),
|
|
// https://mimesniff.spec.whatwg.org/#mime-type-essence
|
|
essence: `${typeLowercase}/${subtypeLowercase}`
|
|
}
|
|
|
|
// 11. While position is not past the end of input:
|
|
while (position.position < input.length) {
|
|
// 1. Advance position by 1. (This skips past U+003B (;).)
|
|
position.position++
|
|
|
|
// 2. Collect a sequence of code points that are HTTP
|
|
// whitespace from input given position.
|
|
collectASequenceOfCodePoints(
|
|
// https://fetch.spec.whatwg.org/#http-whitespace
|
|
char => HTTP_WHITESPACE_REGEX.test(char),
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 3. Let parameterName be the result of collecting a
|
|
// sequence of code points that are not U+003B (;)
|
|
// or U+003D (=) from input, given position.
|
|
let parameterName = collectASequenceOfCodePoints(
|
|
(char) => char !== ';' && char !== '=',
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 4. Set parameterName to parameterName, in ASCII
|
|
// lowercase.
|
|
parameterName = parameterName.toLowerCase()
|
|
|
|
// 5. If position is not past the end of input, then:
|
|
if (position.position < input.length) {
|
|
// 1. If the code point at position within input is
|
|
// U+003B (;), then continue.
|
|
if (input[position.position] === ';') {
|
|
continue
|
|
}
|
|
|
|
// 2. Advance position by 1. (This skips past U+003D (=).)
|
|
position.position++
|
|
}
|
|
|
|
// 6. If position is past the end of input, then break.
|
|
if (position.position > input.length) {
|
|
break
|
|
}
|
|
|
|
// 7. Let parameterValue be null.
|
|
let parameterValue = null
|
|
|
|
// 8. If the code point at position within input is
|
|
// U+0022 ("), then:
|
|
if (input[position.position] === '"') {
|
|
// 1. Set parameterValue to the result of collecting
|
|
// an HTTP quoted string from input, given position
|
|
// and the extract-value flag.
|
|
parameterValue = collectAnHTTPQuotedString(input, position, true)
|
|
|
|
// 2. Collect a sequence of code points that are not
|
|
// U+003B (;) from input, given position.
|
|
collectASequenceOfCodePointsFast(
|
|
';',
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 9. Otherwise:
|
|
} else {
|
|
// 1. Set parameterValue to the result of collecting
|
|
// a sequence of code points that are not U+003B (;)
|
|
// from input, given position.
|
|
parameterValue = collectASequenceOfCodePointsFast(
|
|
';',
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 2. Remove any trailing HTTP whitespace from parameterValue.
|
|
parameterValue = removeHTTPWhitespace(parameterValue, false, true)
|
|
|
|
// 3. If parameterValue is the empty string, then continue.
|
|
if (parameterValue.length === 0) {
|
|
continue
|
|
}
|
|
}
|
|
|
|
// 10. If all of the following are true
|
|
// - parameterName is not the empty string
|
|
// - parameterName solely contains HTTP token code points
|
|
// - parameterValue solely contains HTTP quoted-string token code points
|
|
// - mimeType’s parameters[parameterName] does not exist
|
|
// then set mimeType’s parameters[parameterName] to parameterValue.
|
|
if (
|
|
parameterName.length !== 0 &&
|
|
HTTP_TOKEN_CODEPOINTS.test(parameterName) &&
|
|
(parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) &&
|
|
!mimeType.parameters.has(parameterName)
|
|
) {
|
|
mimeType.parameters.set(parameterName, parameterValue)
|
|
}
|
|
}
|
|
|
|
// 12. Return mimeType.
|
|
return mimeType
|
|
}
|
|
|
|
// https://infra.spec.whatwg.org/#forgiving-base64-decode
|
|
/** @param {string} data */
|
|
function forgivingBase64 (data) {
|
|
// 1. Remove all ASCII whitespace from data.
|
|
data = data.replace(ASCII_WHITESPACE_REPLACE_REGEX, '') // eslint-disable-line
|
|
|
|
let dataLength = data.length
|
|
// 2. If data’s code point length divides by 4 leaving
|
|
// no remainder, then:
|
|
if (dataLength % 4 === 0) {
|
|
// 1. If data ends with one or two U+003D (=) code points,
|
|
// then remove them from data.
|
|
if (data.charCodeAt(dataLength - 1) === 0x003D) {
|
|
--dataLength
|
|
if (data.charCodeAt(dataLength - 1) === 0x003D) {
|
|
--dataLength
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. If data’s code point length divides by 4 leaving
|
|
// a remainder of 1, then return failure.
|
|
if (dataLength % 4 === 1) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 4. If data contains a code point that is not one of
|
|
// U+002B (+)
|
|
// U+002F (/)
|
|
// ASCII alphanumeric
|
|
// then return failure.
|
|
if (/[^+/0-9A-Za-z]/.test(data.length === dataLength ? data : data.substring(0, dataLength))) {
|
|
return 'failure'
|
|
}
|
|
|
|
const buffer = Buffer.from(data, 'base64')
|
|
return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#collect-an-http-quoted-string
|
|
// tests: https://fetch.spec.whatwg.org/#example-http-quoted-string
|
|
/**
|
|
* @param {string} input
|
|
* @param {{ position: number }} position
|
|
* @param {boolean?} extractValue
|
|
*/
|
|
function collectAnHTTPQuotedString (input, position, extractValue) {
|
|
// 1. Let positionStart be position.
|
|
const positionStart = position.position
|
|
|
|
// 2. Let value be the empty string.
|
|
let value = ''
|
|
|
|
// 3. Assert: the code point at position within input
|
|
// is U+0022 (").
|
|
assert(input[position.position] === '"')
|
|
|
|
// 4. Advance position by 1.
|
|
position.position++
|
|
|
|
// 5. While true:
|
|
while (true) {
|
|
// 1. Append the result of collecting a sequence of code points
|
|
// that are not U+0022 (") or U+005C (\) from input, given
|
|
// position, to value.
|
|
value += collectASequenceOfCodePoints(
|
|
(char) => char !== '"' && char !== '\\',
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 2. If position is past the end of input, then break.
|
|
if (position.position >= input.length) {
|
|
break
|
|
}
|
|
|
|
// 3. Let quoteOrBackslash be the code point at position within
|
|
// input.
|
|
const quoteOrBackslash = input[position.position]
|
|
|
|
// 4. Advance position by 1.
|
|
position.position++
|
|
|
|
// 5. If quoteOrBackslash is U+005C (\), then:
|
|
if (quoteOrBackslash === '\\') {
|
|
// 1. If position is past the end of input, then append
|
|
// U+005C (\) to value and break.
|
|
if (position.position >= input.length) {
|
|
value += '\\'
|
|
break
|
|
}
|
|
|
|
// 2. Append the code point at position within input to value.
|
|
value += input[position.position]
|
|
|
|
// 3. Advance position by 1.
|
|
position.position++
|
|
|
|
// 6. Otherwise:
|
|
} else {
|
|
// 1. Assert: quoteOrBackslash is U+0022 (").
|
|
assert(quoteOrBackslash === '"')
|
|
|
|
// 2. Break.
|
|
break
|
|
}
|
|
}
|
|
|
|
// 6. If the extract-value flag is set, then return value.
|
|
if (extractValue) {
|
|
return value
|
|
}
|
|
|
|
// 7. Return the code points from positionStart to position,
|
|
// inclusive, within input.
|
|
return input.slice(positionStart, position.position)
|
|
}
|
|
|
|
/**
|
|
* @see https://mimesniff.spec.whatwg.org/#serialize-a-mime-type
|
|
*/
|
|
function serializeAMimeType (mimeType) {
|
|
assert(mimeType !== 'failure')
|
|
const { parameters, essence } = mimeType
|
|
|
|
// 1. Let serialization be the concatenation of mimeType’s
|
|
// type, U+002F (/), and mimeType’s subtype.
|
|
let serialization = essence
|
|
|
|
// 2. For each name → value of mimeType’s parameters:
|
|
for (let [name, value] of parameters.entries()) {
|
|
// 1. Append U+003B (;) to serialization.
|
|
serialization += ';'
|
|
|
|
// 2. Append name to serialization.
|
|
serialization += name
|
|
|
|
// 3. Append U+003D (=) to serialization.
|
|
serialization += '='
|
|
|
|
// 4. If value does not solely contain HTTP token code
|
|
// points or value is the empty string, then:
|
|
if (!HTTP_TOKEN_CODEPOINTS.test(value)) {
|
|
// 1. Precede each occurrence of U+0022 (") or
|
|
// U+005C (\) in value with U+005C (\).
|
|
value = value.replace(/(\\|")/g, '\\$1')
|
|
|
|
// 2. Prepend U+0022 (") to value.
|
|
value = '"' + value
|
|
|
|
// 3. Append U+0022 (") to value.
|
|
value += '"'
|
|
}
|
|
|
|
// 5. Append value to serialization.
|
|
serialization += value
|
|
}
|
|
|
|
// 3. Return serialization.
|
|
return serialization
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#http-whitespace
|
|
* @param {number} char
|
|
*/
|
|
function isHTTPWhiteSpace (char) {
|
|
// "\r\n\t "
|
|
return char === 0x00d || char === 0x00a || char === 0x009 || char === 0x020
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#http-whitespace
|
|
* @param {string} str
|
|
* @param {boolean} [leading=true]
|
|
* @param {boolean} [trailing=true]
|
|
*/
|
|
function removeHTTPWhitespace (str, leading = true, trailing = true) {
|
|
return removeChars(str, leading, trailing, isHTTPWhiteSpace)
|
|
}
|
|
|
|
/**
|
|
* @see https://infra.spec.whatwg.org/#ascii-whitespace
|
|
* @param {number} char
|
|
*/
|
|
function isASCIIWhitespace (char) {
|
|
// "\r\n\t\f "
|
|
return char === 0x00d || char === 0x00a || char === 0x009 || char === 0x00c || char === 0x020
|
|
}
|
|
|
|
/**
|
|
* @see https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace
|
|
* @param {string} str
|
|
* @param {boolean} [leading=true]
|
|
* @param {boolean} [trailing=true]
|
|
*/
|
|
function removeASCIIWhitespace (str, leading = true, trailing = true) {
|
|
return removeChars(str, leading, trailing, isASCIIWhitespace)
|
|
}
|
|
|
|
/**
|
|
* @param {string} str
|
|
* @param {boolean} leading
|
|
* @param {boolean} trailing
|
|
* @param {(charCode: number) => boolean} predicate
|
|
* @returns
|
|
*/
|
|
function removeChars (str, leading, trailing, predicate) {
|
|
let lead = 0
|
|
let trail = str.length - 1
|
|
|
|
if (leading) {
|
|
while (lead < str.length && predicate(str.charCodeAt(lead))) lead++
|
|
}
|
|
|
|
if (trailing) {
|
|
while (trail > 0 && predicate(str.charCodeAt(trail))) trail--
|
|
}
|
|
|
|
return lead === 0 && trail === str.length - 1 ? str : str.slice(lead, trail + 1)
|
|
}
|
|
|
|
/**
|
|
* @see https://infra.spec.whatwg.org/#isomorphic-decode
|
|
* @param {Uint8Array} input
|
|
* @returns {string}
|
|
*/
|
|
function isomorphicDecode (input) {
|
|
// 1. To isomorphic decode a byte sequence input, return a string whose code point
|
|
// length is equal to input’s length and whose code points have the same values
|
|
// as the values of input’s bytes, in the same order.
|
|
const length = input.length
|
|
if ((2 << 15) - 1 > length) {
|
|
return String.fromCharCode.apply(null, input)
|
|
}
|
|
let result = ''; let i = 0
|
|
let addition = (2 << 15) - 1
|
|
while (i < length) {
|
|
if (i + addition > length) {
|
|
addition = length - i
|
|
}
|
|
result += String.fromCharCode.apply(null, input.subarray(i, i += addition))
|
|
}
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* @see https://mimesniff.spec.whatwg.org/#minimize-a-supported-mime-type
|
|
* @param {Exclude<ReturnType<typeof parseMIMEType>, 'failure'>} mimeType
|
|
*/
|
|
function minimizeSupportedMimeType (mimeType) {
|
|
switch (mimeType.essence) {
|
|
case 'application/ecmascript':
|
|
case 'application/javascript':
|
|
case 'application/x-ecmascript':
|
|
case 'application/x-javascript':
|
|
case 'text/ecmascript':
|
|
case 'text/javascript':
|
|
case 'text/javascript1.0':
|
|
case 'text/javascript1.1':
|
|
case 'text/javascript1.2':
|
|
case 'text/javascript1.3':
|
|
case 'text/javascript1.4':
|
|
case 'text/javascript1.5':
|
|
case 'text/jscript':
|
|
case 'text/livescript':
|
|
case 'text/x-ecmascript':
|
|
case 'text/x-javascript':
|
|
// 1. If mimeType is a JavaScript MIME type, then return "text/javascript".
|
|
return 'text/javascript'
|
|
case 'application/json':
|
|
case 'text/json':
|
|
// 2. If mimeType is a JSON MIME type, then return "application/json".
|
|
return 'application/json'
|
|
case 'image/svg+xml':
|
|
// 3. If mimeType’s essence is "image/svg+xml", then return "image/svg+xml".
|
|
return 'image/svg+xml'
|
|
case 'text/xml':
|
|
case 'application/xml':
|
|
// 4. If mimeType is an XML MIME type, then return "application/xml".
|
|
return 'application/xml'
|
|
}
|
|
|
|
// 2. If mimeType is a JSON MIME type, then return "application/json".
|
|
if (mimeType.subtype.endsWith('+json')) {
|
|
return 'application/json'
|
|
}
|
|
|
|
// 4. If mimeType is an XML MIME type, then return "application/xml".
|
|
if (mimeType.subtype.endsWith('+xml')) {
|
|
return 'application/xml'
|
|
}
|
|
|
|
// 5. If mimeType is supported by the user agent, then return mimeType’s essence.
|
|
// Technically, node doesn't support any mimetypes.
|
|
|
|
// 6. Return the empty string.
|
|
return ''
|
|
}
|
|
|
|
module.exports = {
|
|
dataURLProcessor,
|
|
URLSerializer,
|
|
collectASequenceOfCodePoints,
|
|
collectASequenceOfCodePointsFast,
|
|
stringPercentDecode,
|
|
parseMIMEType,
|
|
collectAnHTTPQuotedString,
|
|
serializeAMimeType,
|
|
removeChars,
|
|
removeHTTPWhitespace,
|
|
minimizeSupportedMimeType,
|
|
HTTP_TOKEN_CODEPOINTS,
|
|
isomorphicDecode
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6653:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { kConnected, kSize } = __nccwpck_require__(6443)
|
|
|
|
class CompatWeakRef {
|
|
constructor (value) {
|
|
this.value = value
|
|
}
|
|
|
|
deref () {
|
|
return this.value[kConnected] === 0 && this.value[kSize] === 0
|
|
? undefined
|
|
: this.value
|
|
}
|
|
}
|
|
|
|
class CompatFinalizer {
|
|
constructor (finalizer) {
|
|
this.finalizer = finalizer
|
|
}
|
|
|
|
register (dispatcher, key) {
|
|
if (dispatcher.on) {
|
|
dispatcher.on('disconnect', () => {
|
|
if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) {
|
|
this.finalizer(key)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
unregister (key) {}
|
|
}
|
|
|
|
module.exports = function () {
|
|
// FIXME: remove workaround when the Node bug is backported to v18
|
|
// https://github.com/nodejs/node/issues/49344#issuecomment-1741776308
|
|
if (process.env.NODE_V8_COVERAGE && process.version.startsWith('v18')) {
|
|
process._rawDebug('Using compatibility WeakRef and FinalizationRegistry')
|
|
return {
|
|
WeakRef: CompatWeakRef,
|
|
FinalizationRegistry: CompatFinalizer
|
|
}
|
|
}
|
|
return { WeakRef, FinalizationRegistry }
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7114:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { Blob, File } = __nccwpck_require__(4573)
|
|
const { kState } = __nccwpck_require__(3627)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
|
|
// TODO(@KhafraDev): remove
|
|
class FileLike {
|
|
constructor (blobLike, fileName, options = {}) {
|
|
// TODO: argument idl type check
|
|
|
|
// The File constructor is invoked with two or three parameters, depending
|
|
// on whether the optional dictionary parameter is used. When the File()
|
|
// constructor is invoked, user agents must run the following steps:
|
|
|
|
// 1. Let bytes be the result of processing blob parts given fileBits and
|
|
// options.
|
|
|
|
// 2. Let n be the fileName argument to the constructor.
|
|
const n = fileName
|
|
|
|
// 3. Process FilePropertyBag dictionary argument by running the following
|
|
// substeps:
|
|
|
|
// 1. If the type member is provided and is not the empty string, let t
|
|
// be set to the type dictionary member. If t contains any characters
|
|
// outside the range U+0020 to U+007E, then set t to the empty string
|
|
// and return from these substeps.
|
|
// TODO
|
|
const t = options.type
|
|
|
|
// 2. Convert every character in t to ASCII lowercase.
|
|
// TODO
|
|
|
|
// 3. If the lastModified member is provided, let d be set to the
|
|
// lastModified dictionary member. If it is not provided, set d to the
|
|
// current date and time represented as the number of milliseconds since
|
|
// the Unix Epoch (which is the equivalent of Date.now() [ECMA-262]).
|
|
const d = options.lastModified ?? Date.now()
|
|
|
|
// 4. Return a new File object F such that:
|
|
// F refers to the bytes byte sequence.
|
|
// F.size is set to the number of total bytes in bytes.
|
|
// F.name is set to n.
|
|
// F.type is set to t.
|
|
// F.lastModified is set to d.
|
|
|
|
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'
|
|
}
|
|
}
|
|
|
|
webidl.converters.Blob = webidl.interfaceConverter(Blob)
|
|
|
|
// If this function is moved to ./util.js, some tools (such as
|
|
// rollup) will warn about circular dependencies. See:
|
|
// https://github.com/nodejs/undici/issues/1629
|
|
function isFileLike (object) {
|
|
return (
|
|
(object instanceof File) ||
|
|
(
|
|
object &&
|
|
(typeof object.stream === 'function' ||
|
|
typeof object.arrayBuffer === 'function') &&
|
|
object[Symbol.toStringTag] === 'File'
|
|
)
|
|
)
|
|
}
|
|
|
|
module.exports = { FileLike, isFileLike }
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 116:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { isUSVString, bufferToLowerCasedHeaderName } = __nccwpck_require__(3440)
|
|
const { utf8DecodeBytes } = __nccwpck_require__(3168)
|
|
const { HTTP_TOKEN_CODEPOINTS, isomorphicDecode } = __nccwpck_require__(1900)
|
|
const { isFileLike } = __nccwpck_require__(7114)
|
|
const { makeEntry } = __nccwpck_require__(5910)
|
|
const assert = __nccwpck_require__(4589)
|
|
const { File: NodeFile } = __nccwpck_require__(4573)
|
|
|
|
const File = globalThis.File ?? NodeFile
|
|
|
|
const formDataNameBuffer = Buffer.from('form-data; name="')
|
|
const filenameBuffer = Buffer.from('; filename')
|
|
const dd = Buffer.from('--')
|
|
const ddcrlf = Buffer.from('--\r\n')
|
|
|
|
/**
|
|
* @param {string} chars
|
|
*/
|
|
function isAsciiString (chars) {
|
|
for (let i = 0; i < chars.length; ++i) {
|
|
if ((chars.charCodeAt(i) & ~0x7F) !== 0) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* @see https://andreubotella.github.io/multipart-form-data/#multipart-form-data-boundary
|
|
* @param {string} boundary
|
|
*/
|
|
function validateBoundary (boundary) {
|
|
const length = boundary.length
|
|
|
|
// - its length is greater or equal to 27 and lesser or equal to 70, and
|
|
if (length < 27 || length > 70) {
|
|
return false
|
|
}
|
|
|
|
// - it is composed by bytes in the ranges 0x30 to 0x39, 0x41 to 0x5A, or
|
|
// 0x61 to 0x7A, inclusive (ASCII alphanumeric), or which are 0x27 ('),
|
|
// 0x2D (-) or 0x5F (_).
|
|
for (let i = 0; i < length; ++i) {
|
|
const cp = boundary.charCodeAt(i)
|
|
|
|
if (!(
|
|
(cp >= 0x30 && cp <= 0x39) ||
|
|
(cp >= 0x41 && cp <= 0x5a) ||
|
|
(cp >= 0x61 && cp <= 0x7a) ||
|
|
cp === 0x27 ||
|
|
cp === 0x2d ||
|
|
cp === 0x5f
|
|
)) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* @see https://andreubotella.github.io/multipart-form-data/#multipart-form-data-parser
|
|
* @param {Buffer} input
|
|
* @param {ReturnType<import('./data-url')['parseMIMEType']>} mimeType
|
|
*/
|
|
function multipartFormDataParser (input, mimeType) {
|
|
// 1. Assert: mimeType’s essence is "multipart/form-data".
|
|
assert(mimeType !== 'failure' && mimeType.essence === 'multipart/form-data')
|
|
|
|
const boundaryString = mimeType.parameters.get('boundary')
|
|
|
|
// 2. If mimeType’s parameters["boundary"] does not exist, return failure.
|
|
// Otherwise, let boundary be the result of UTF-8 decoding mimeType’s
|
|
// parameters["boundary"].
|
|
if (boundaryString === undefined) {
|
|
return 'failure'
|
|
}
|
|
|
|
const boundary = Buffer.from(`--${boundaryString}`, 'utf8')
|
|
|
|
// 3. Let entry list be an empty entry list.
|
|
const entryList = []
|
|
|
|
// 4. Let position be a pointer to a byte in input, initially pointing at
|
|
// the first byte.
|
|
const position = { position: 0 }
|
|
|
|
// Note: undici addition, allows leading and trailing CRLFs.
|
|
while (input[position.position] === 0x0d && input[position.position + 1] === 0x0a) {
|
|
position.position += 2
|
|
}
|
|
|
|
let trailing = input.length
|
|
|
|
while (input[trailing - 1] === 0x0a && input[trailing - 2] === 0x0d) {
|
|
trailing -= 2
|
|
}
|
|
|
|
if (trailing !== input.length) {
|
|
input = input.subarray(0, trailing)
|
|
}
|
|
|
|
// 5. While true:
|
|
while (true) {
|
|
// 5.1. If position points to a sequence of bytes starting with 0x2D 0x2D
|
|
// (`--`) followed by boundary, advance position by 2 + the length of
|
|
// boundary. Otherwise, return failure.
|
|
// Note: boundary is padded with 2 dashes already, no need to add 2.
|
|
if (input.subarray(position.position, position.position + boundary.length).equals(boundary)) {
|
|
position.position += boundary.length
|
|
} else {
|
|
return 'failure'
|
|
}
|
|
|
|
// 5.2. If position points to the sequence of bytes 0x2D 0x2D 0x0D 0x0A
|
|
// (`--` followed by CR LF) followed by the end of input, return entry list.
|
|
// Note: a body does NOT need to end with CRLF. It can end with --.
|
|
if (
|
|
(position.position === input.length - 2 && bufferStartsWith(input, dd, position)) ||
|
|
(position.position === input.length - 4 && bufferStartsWith(input, ddcrlf, position))
|
|
) {
|
|
return entryList
|
|
}
|
|
|
|
// 5.3. If position does not point to a sequence of bytes starting with 0x0D
|
|
// 0x0A (CR LF), return failure.
|
|
if (input[position.position] !== 0x0d || input[position.position + 1] !== 0x0a) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 5.4. Advance position by 2. (This skips past the newline.)
|
|
position.position += 2
|
|
|
|
// 5.5. Let name, filename and contentType be the result of parsing
|
|
// multipart/form-data headers on input and position, if the result
|
|
// is not failure. Otherwise, return failure.
|
|
const result = parseMultipartFormDataHeaders(input, position)
|
|
|
|
if (result === 'failure') {
|
|
return 'failure'
|
|
}
|
|
|
|
let { name, filename, contentType, encoding } = result
|
|
|
|
// 5.6. Advance position by 2. (This skips past the empty line that marks
|
|
// the end of the headers.)
|
|
position.position += 2
|
|
|
|
// 5.7. Let body be the empty byte sequence.
|
|
let body
|
|
|
|
// 5.8. Body loop: While position is not past the end of input:
|
|
// TODO: the steps here are completely wrong
|
|
{
|
|
const boundaryIndex = input.indexOf(boundary.subarray(2), position.position)
|
|
|
|
if (boundaryIndex === -1) {
|
|
return 'failure'
|
|
}
|
|
|
|
body = input.subarray(position.position, boundaryIndex - 4)
|
|
|
|
position.position += body.length
|
|
|
|
// Note: position must be advanced by the body's length before being
|
|
// decoded, otherwise the parsing will fail.
|
|
if (encoding === 'base64') {
|
|
body = Buffer.from(body.toString(), 'base64')
|
|
}
|
|
}
|
|
|
|
// 5.9. If position does not point to a sequence of bytes starting with
|
|
// 0x0D 0x0A (CR LF), return failure. Otherwise, advance position by 2.
|
|
if (input[position.position] !== 0x0d || input[position.position + 1] !== 0x0a) {
|
|
return 'failure'
|
|
} else {
|
|
position.position += 2
|
|
}
|
|
|
|
// 5.10. If filename is not null:
|
|
let value
|
|
|
|
if (filename !== null) {
|
|
// 5.10.1. If contentType is null, set contentType to "text/plain".
|
|
contentType ??= 'text/plain'
|
|
|
|
// 5.10.2. If contentType is not an ASCII string, set contentType to the empty string.
|
|
|
|
// Note: `buffer.isAscii` can be used at zero-cost, but converting a string to a buffer is a high overhead.
|
|
// Content-Type is a relatively small string, so it is faster to use `String#charCodeAt`.
|
|
if (!isAsciiString(contentType)) {
|
|
contentType = ''
|
|
}
|
|
|
|
// 5.10.3. Let value be a new File object with name filename, type contentType, and body body.
|
|
value = new File([body], filename, { type: contentType })
|
|
} else {
|
|
// 5.11. Otherwise:
|
|
|
|
// 5.11.1. Let value be the UTF-8 decoding without BOM of body.
|
|
value = utf8DecodeBytes(Buffer.from(body))
|
|
}
|
|
|
|
// 5.12. Assert: name is a scalar value string and value is either a scalar value string or a File object.
|
|
assert(isUSVString(name))
|
|
assert((typeof value === 'string' && isUSVString(value)) || isFileLike(value))
|
|
|
|
// 5.13. Create an entry with name and value, and append it to entry list.
|
|
entryList.push(makeEntry(name, value, filename))
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://andreubotella.github.io/multipart-form-data/#parse-multipart-form-data-headers
|
|
* @param {Buffer} input
|
|
* @param {{ position: number }} position
|
|
*/
|
|
function parseMultipartFormDataHeaders (input, position) {
|
|
// 1. Let name, filename and contentType be null.
|
|
let name = null
|
|
let filename = null
|
|
let contentType = null
|
|
let encoding = null
|
|
|
|
// 2. While true:
|
|
while (true) {
|
|
// 2.1. If position points to a sequence of bytes starting with 0x0D 0x0A (CR LF):
|
|
if (input[position.position] === 0x0d && input[position.position + 1] === 0x0a) {
|
|
// 2.1.1. If name is null, return failure.
|
|
if (name === null) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 2.1.2. Return name, filename and contentType.
|
|
return { name, filename, contentType, encoding }
|
|
}
|
|
|
|
// 2.2. Let header name be the result of collecting a sequence of bytes that are
|
|
// not 0x0A (LF), 0x0D (CR) or 0x3A (:), given position.
|
|
let headerName = collectASequenceOfBytes(
|
|
(char) => char !== 0x0a && char !== 0x0d && char !== 0x3a,
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 2.3. Remove any HTTP tab or space bytes from the start or end of header name.
|
|
headerName = removeChars(headerName, true, true, (char) => char === 0x9 || char === 0x20)
|
|
|
|
// 2.4. If header name does not match the field-name token production, return failure.
|
|
if (!HTTP_TOKEN_CODEPOINTS.test(headerName.toString())) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 2.5. If the byte at position is not 0x3A (:), return failure.
|
|
if (input[position.position] !== 0x3a) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 2.6. Advance position by 1.
|
|
position.position++
|
|
|
|
// 2.7. Collect a sequence of bytes that are HTTP tab or space bytes given position.
|
|
// (Do nothing with those bytes.)
|
|
collectASequenceOfBytes(
|
|
(char) => char === 0x20 || char === 0x09,
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 2.8. Byte-lowercase header name and switch on the result:
|
|
switch (bufferToLowerCasedHeaderName(headerName)) {
|
|
case 'content-disposition': {
|
|
// 1. Set name and filename to null.
|
|
name = filename = null
|
|
|
|
// 2. If position does not point to a sequence of bytes starting with
|
|
// `form-data; name="`, return failure.
|
|
if (!bufferStartsWith(input, formDataNameBuffer, position)) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 3. Advance position so it points at the byte after the next 0x22 (")
|
|
// byte (the one in the sequence of bytes matched above).
|
|
position.position += 17
|
|
|
|
// 4. Set name to the result of parsing a multipart/form-data name given
|
|
// input and position, if the result is not failure. Otherwise, return
|
|
// failure.
|
|
name = parseMultipartFormDataName(input, position)
|
|
|
|
if (name === null) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 5. If position points to a sequence of bytes starting with `; filename="`:
|
|
if (bufferStartsWith(input, filenameBuffer, position)) {
|
|
// Note: undici also handles filename*
|
|
let check = position.position + filenameBuffer.length
|
|
|
|
if (input[check] === 0x2a) {
|
|
position.position += 1
|
|
check += 1
|
|
}
|
|
|
|
if (input[check] !== 0x3d || input[check + 1] !== 0x22) { // ="
|
|
return 'failure'
|
|
}
|
|
|
|
// 1. Advance position so it points at the byte after the next 0x22 (") byte
|
|
// (the one in the sequence of bytes matched above).
|
|
position.position += 12
|
|
|
|
// 2. Set filename to the result of parsing a multipart/form-data name given
|
|
// input and position, if the result is not failure. Otherwise, return failure.
|
|
filename = parseMultipartFormDataName(input, position)
|
|
|
|
if (filename === null) {
|
|
return 'failure'
|
|
}
|
|
}
|
|
|
|
break
|
|
}
|
|
case 'content-type': {
|
|
// 1. Let header value be the result of collecting a sequence of bytes that are
|
|
// not 0x0A (LF) or 0x0D (CR), given position.
|
|
let headerValue = collectASequenceOfBytes(
|
|
(char) => char !== 0x0a && char !== 0x0d,
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 2. Remove any HTTP tab or space bytes from the end of header value.
|
|
headerValue = removeChars(headerValue, false, true, (char) => char === 0x9 || char === 0x20)
|
|
|
|
// 3. Set contentType to the isomorphic decoding of header value.
|
|
contentType = isomorphicDecode(headerValue)
|
|
|
|
break
|
|
}
|
|
case 'content-transfer-encoding': {
|
|
let headerValue = collectASequenceOfBytes(
|
|
(char) => char !== 0x0a && char !== 0x0d,
|
|
input,
|
|
position
|
|
)
|
|
|
|
headerValue = removeChars(headerValue, false, true, (char) => char === 0x9 || char === 0x20)
|
|
|
|
encoding = isomorphicDecode(headerValue)
|
|
|
|
break
|
|
}
|
|
default: {
|
|
// Collect a sequence of bytes that are not 0x0A (LF) or 0x0D (CR), given position.
|
|
// (Do nothing with those bytes.)
|
|
collectASequenceOfBytes(
|
|
(char) => char !== 0x0a && char !== 0x0d,
|
|
input,
|
|
position
|
|
)
|
|
}
|
|
}
|
|
|
|
// 2.9. If position does not point to a sequence of bytes starting with 0x0D 0x0A
|
|
// (CR LF), return failure. Otherwise, advance position by 2 (past the newline).
|
|
if (input[position.position] !== 0x0d && input[position.position + 1] !== 0x0a) {
|
|
return 'failure'
|
|
} else {
|
|
position.position += 2
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://andreubotella.github.io/multipart-form-data/#parse-a-multipart-form-data-name
|
|
* @param {Buffer} input
|
|
* @param {{ position: number }} position
|
|
*/
|
|
function parseMultipartFormDataName (input, position) {
|
|
// 1. Assert: The byte at (position - 1) is 0x22 (").
|
|
assert(input[position.position - 1] === 0x22)
|
|
|
|
// 2. Let name be the result of collecting a sequence of bytes that are not 0x0A (LF), 0x0D (CR) or 0x22 ("), given position.
|
|
/** @type {string | Buffer} */
|
|
let name = collectASequenceOfBytes(
|
|
(char) => char !== 0x0a && char !== 0x0d && char !== 0x22,
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 3. If the byte at position is not 0x22 ("), return failure. Otherwise, advance position by 1.
|
|
if (input[position.position] !== 0x22) {
|
|
return null // name could be 'failure'
|
|
} else {
|
|
position.position++
|
|
}
|
|
|
|
// 4. Replace any occurrence of the following subsequences in name with the given byte:
|
|
// - `%0A`: 0x0A (LF)
|
|
// - `%0D`: 0x0D (CR)
|
|
// - `%22`: 0x22 (")
|
|
name = new TextDecoder().decode(name)
|
|
.replace(/%0A/ig, '\n')
|
|
.replace(/%0D/ig, '\r')
|
|
.replace(/%22/g, '"')
|
|
|
|
// 5. Return the UTF-8 decoding without BOM of name.
|
|
return name
|
|
}
|
|
|
|
/**
|
|
* @param {(char: number) => boolean} condition
|
|
* @param {Buffer} input
|
|
* @param {{ position: number }} position
|
|
*/
|
|
function collectASequenceOfBytes (condition, input, position) {
|
|
let start = position.position
|
|
|
|
while (start < input.length && condition(input[start])) {
|
|
++start
|
|
}
|
|
|
|
return input.subarray(position.position, (position.position = start))
|
|
}
|
|
|
|
/**
|
|
* @param {Buffer} buf
|
|
* @param {boolean} leading
|
|
* @param {boolean} trailing
|
|
* @param {(charCode: number) => boolean} predicate
|
|
* @returns {Buffer}
|
|
*/
|
|
function removeChars (buf, leading, trailing, predicate) {
|
|
let lead = 0
|
|
let trail = buf.length - 1
|
|
|
|
if (leading) {
|
|
while (lead < buf.length && predicate(buf[lead])) lead++
|
|
}
|
|
|
|
if (trailing) {
|
|
while (trail > 0 && predicate(buf[trail])) trail--
|
|
}
|
|
|
|
return lead === 0 && trail === buf.length - 1 ? buf : buf.subarray(lead, trail + 1)
|
|
}
|
|
|
|
/**
|
|
* Checks if {@param buffer} starts with {@param start}
|
|
* @param {Buffer} buffer
|
|
* @param {Buffer} start
|
|
* @param {{ position: number }} position
|
|
*/
|
|
function bufferStartsWith (buffer, start, position) {
|
|
if (buffer.length < start.length) {
|
|
return false
|
|
}
|
|
|
|
for (let i = 0; i < start.length; i++) {
|
|
if (start[i] !== buffer[position.position + i]) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
module.exports = {
|
|
multipartFormDataParser,
|
|
validateBoundary
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5910:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { isBlobLike, iteratorMixin } = __nccwpck_require__(3168)
|
|
const { kState } = __nccwpck_require__(3627)
|
|
const { kEnumerableProperty } = __nccwpck_require__(3440)
|
|
const { FileLike, isFileLike } = __nccwpck_require__(7114)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const { File: NativeFile } = __nccwpck_require__(4573)
|
|
const nodeUtil = __nccwpck_require__(7975)
|
|
|
|
/** @type {globalThis['File']} */
|
|
const File = globalThis.File ?? NativeFile
|
|
|
|
// https://xhr.spec.whatwg.org/#formdata
|
|
class FormData {
|
|
constructor (form) {
|
|
webidl.util.markAsUncloneable(this)
|
|
|
|
if (form !== undefined) {
|
|
throw webidl.errors.conversionFailed({
|
|
prefix: 'FormData constructor',
|
|
argument: 'Argument 1',
|
|
types: ['undefined']
|
|
})
|
|
}
|
|
|
|
this[kState] = []
|
|
}
|
|
|
|
append (name, value, filename = undefined) {
|
|
webidl.brandCheck(this, FormData)
|
|
|
|
const prefix = 'FormData.append'
|
|
webidl.argumentLengthCheck(arguments, 2, prefix)
|
|
|
|
if (arguments.length === 3 && !isBlobLike(value)) {
|
|
throw new TypeError(
|
|
"Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'"
|
|
)
|
|
}
|
|
|
|
// 1. Let value be value if given; otherwise blobValue.
|
|
|
|
name = webidl.converters.USVString(name, prefix, 'name')
|
|
value = isBlobLike(value)
|
|
? webidl.converters.Blob(value, prefix, 'value', { strict: false })
|
|
: webidl.converters.USVString(value, prefix, 'value')
|
|
filename = arguments.length === 3
|
|
? webidl.converters.USVString(filename, prefix, 'filename')
|
|
: undefined
|
|
|
|
// 2. Let entry be the result of creating an entry with
|
|
// name, value, and filename if given.
|
|
const entry = makeEntry(name, value, filename)
|
|
|
|
// 3. Append entry to this’s entry list.
|
|
this[kState].push(entry)
|
|
}
|
|
|
|
delete (name) {
|
|
webidl.brandCheck(this, FormData)
|
|
|
|
const prefix = 'FormData.delete'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
name = webidl.converters.USVString(name, prefix, 'name')
|
|
|
|
// The delete(name) method steps are to remove all entries whose name
|
|
// is name from this’s entry list.
|
|
this[kState] = this[kState].filter(entry => entry.name !== name)
|
|
}
|
|
|
|
get (name) {
|
|
webidl.brandCheck(this, FormData)
|
|
|
|
const prefix = 'FormData.get'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
name = webidl.converters.USVString(name, prefix, 'name')
|
|
|
|
// 1. If there is no entry whose name is name in this’s entry list,
|
|
// then return null.
|
|
const idx = this[kState].findIndex((entry) => entry.name === name)
|
|
if (idx === -1) {
|
|
return null
|
|
}
|
|
|
|
// 2. Return the value of the first entry whose name is name from
|
|
// this’s entry list.
|
|
return this[kState][idx].value
|
|
}
|
|
|
|
getAll (name) {
|
|
webidl.brandCheck(this, FormData)
|
|
|
|
const prefix = 'FormData.getAll'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
name = webidl.converters.USVString(name, prefix, 'name')
|
|
|
|
// 1. If there is no entry whose name is name in this’s entry list,
|
|
// then return the empty list.
|
|
// 2. Return the values of all entries whose name is name, in order,
|
|
// from this’s entry list.
|
|
return this[kState]
|
|
.filter((entry) => entry.name === name)
|
|
.map((entry) => entry.value)
|
|
}
|
|
|
|
has (name) {
|
|
webidl.brandCheck(this, FormData)
|
|
|
|
const prefix = 'FormData.has'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
name = webidl.converters.USVString(name, prefix, 'name')
|
|
|
|
// The has(name) method steps are to return true if there is an entry
|
|
// whose name is name in this’s entry list; otherwise false.
|
|
return this[kState].findIndex((entry) => entry.name === name) !== -1
|
|
}
|
|
|
|
set (name, value, filename = undefined) {
|
|
webidl.brandCheck(this, FormData)
|
|
|
|
const prefix = 'FormData.set'
|
|
webidl.argumentLengthCheck(arguments, 2, prefix)
|
|
|
|
if (arguments.length === 3 && !isBlobLike(value)) {
|
|
throw new TypeError(
|
|
"Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'"
|
|
)
|
|
}
|
|
|
|
// The set(name, value) and set(name, blobValue, filename) method steps
|
|
// are:
|
|
|
|
// 1. Let value be value if given; otherwise blobValue.
|
|
|
|
name = webidl.converters.USVString(name, prefix, 'name')
|
|
value = isBlobLike(value)
|
|
? webidl.converters.Blob(value, prefix, 'name', { strict: false })
|
|
: webidl.converters.USVString(value, prefix, 'name')
|
|
filename = arguments.length === 3
|
|
? webidl.converters.USVString(filename, prefix, 'name')
|
|
: undefined
|
|
|
|
// 2. Let entry be the result of creating an entry with name, value, and
|
|
// filename if given.
|
|
const entry = makeEntry(name, value, filename)
|
|
|
|
// 3. If there are entries in this’s entry list whose name is name, then
|
|
// replace the first such entry with entry and remove the others.
|
|
const idx = this[kState].findIndex((entry) => entry.name === name)
|
|
if (idx !== -1) {
|
|
this[kState] = [
|
|
...this[kState].slice(0, idx),
|
|
entry,
|
|
...this[kState].slice(idx + 1).filter((entry) => entry.name !== name)
|
|
]
|
|
} else {
|
|
// 4. Otherwise, append entry to this’s entry list.
|
|
this[kState].push(entry)
|
|
}
|
|
}
|
|
|
|
[nodeUtil.inspect.custom] (depth, options) {
|
|
const state = this[kState].reduce((a, b) => {
|
|
if (a[b.name]) {
|
|
if (Array.isArray(a[b.name])) {
|
|
a[b.name].push(b.value)
|
|
} else {
|
|
a[b.name] = [a[b.name], b.value]
|
|
}
|
|
} else {
|
|
a[b.name] = b.value
|
|
}
|
|
|
|
return a
|
|
}, { __proto__: null })
|
|
|
|
options.depth ??= depth
|
|
options.colors ??= true
|
|
|
|
const output = nodeUtil.formatWithOptions(options, state)
|
|
|
|
// remove [Object null prototype]
|
|
return `FormData ${output.slice(output.indexOf(']') + 2)}`
|
|
}
|
|
}
|
|
|
|
iteratorMixin('FormData', FormData, kState, 'name', 'value')
|
|
|
|
Object.defineProperties(FormData.prototype, {
|
|
append: kEnumerableProperty,
|
|
delete: kEnumerableProperty,
|
|
get: kEnumerableProperty,
|
|
getAll: kEnumerableProperty,
|
|
has: kEnumerableProperty,
|
|
set: kEnumerableProperty,
|
|
[Symbol.toStringTag]: {
|
|
value: 'FormData',
|
|
configurable: true
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#create-an-entry
|
|
* @param {string} name
|
|
* @param {string|Blob} value
|
|
* @param {?string} filename
|
|
* @returns
|
|
*/
|
|
function makeEntry (name, value, filename) {
|
|
// 1. Set name to the result of converting name into a scalar value string.
|
|
// Note: This operation was done by the webidl converter USVString.
|
|
|
|
// 2. If value is a string, then set value to the result of converting
|
|
// value into a scalar value string.
|
|
if (typeof value === 'string') {
|
|
// Note: This operation was done by the webidl converter USVString.
|
|
} else {
|
|
// 3. Otherwise:
|
|
|
|
// 1. If value is not a File object, then set value to a new File object,
|
|
// representing the same bytes, whose name attribute value is "blob"
|
|
if (!isFileLike(value)) {
|
|
value = value instanceof Blob
|
|
? new File([value], 'blob', { type: value.type })
|
|
: new FileLike(value, 'blob', { type: value.type })
|
|
}
|
|
|
|
// 2. If filename is given, then set value to a new File object,
|
|
// representing the same bytes, whose name attribute is filename.
|
|
if (filename !== undefined) {
|
|
/** @type {FilePropertyBag} */
|
|
const options = {
|
|
type: value.type,
|
|
lastModified: value.lastModified
|
|
}
|
|
|
|
value = value instanceof NativeFile
|
|
? new File([value], filename, options)
|
|
: new FileLike(value, filename, options)
|
|
}
|
|
}
|
|
|
|
// 4. Return an entry whose name is name and whose value is value.
|
|
return { name, value }
|
|
}
|
|
|
|
module.exports = { FormData, makeEntry }
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1059:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
// In case of breaking changes, increase the version
|
|
// number to avoid conflicts.
|
|
const globalOrigin = Symbol.for('undici.globalOrigin.1')
|
|
|
|
function getGlobalOrigin () {
|
|
return globalThis[globalOrigin]
|
|
}
|
|
|
|
function setGlobalOrigin (newOrigin) {
|
|
if (newOrigin === undefined) {
|
|
Object.defineProperty(globalThis, globalOrigin, {
|
|
value: undefined,
|
|
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
|
|
})
|
|
}
|
|
|
|
module.exports = {
|
|
getGlobalOrigin,
|
|
setGlobalOrigin
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 660:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
// https://github.com/Ethan-Arrowood/undici-fetch
|
|
|
|
|
|
|
|
const { kConstruct } = __nccwpck_require__(6443)
|
|
const { kEnumerableProperty } = __nccwpck_require__(3440)
|
|
const {
|
|
iteratorMixin,
|
|
isValidHeaderName,
|
|
isValidHeaderValue
|
|
} = __nccwpck_require__(3168)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const assert = __nccwpck_require__(4589)
|
|
const util = __nccwpck_require__(7975)
|
|
|
|
const kHeadersMap = Symbol('headers map')
|
|
const kHeadersSortedMap = Symbol('headers map sorted')
|
|
|
|
/**
|
|
* @param {number} code
|
|
*/
|
|
function isHTTPWhiteSpaceCharCode (code) {
|
|
return code === 0x00a || code === 0x00d || code === 0x009 || code === 0x020
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#concept-header-value-normalize
|
|
* @param {string} potentialValue
|
|
*/
|
|
function headerValueNormalize (potentialValue) {
|
|
// To normalize a byte sequence potentialValue, remove
|
|
// any leading and trailing HTTP whitespace bytes from
|
|
// potentialValue.
|
|
let i = 0; let j = potentialValue.length
|
|
|
|
while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1))) --j
|
|
while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i))) ++i
|
|
|
|
return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j)
|
|
}
|
|
|
|
function fill (headers, object) {
|
|
// To fill a Headers object headers with a given object object, run these steps:
|
|
|
|
// 1. If object is a sequence, then for each header in object:
|
|
// Note: webidl conversion to array has already been done.
|
|
if (Array.isArray(object)) {
|
|
for (let i = 0; i < object.length; ++i) {
|
|
const header = object[i]
|
|
// 1. If header does not contain exactly two items, then throw a TypeError.
|
|
if (header.length !== 2) {
|
|
throw webidl.errors.exception({
|
|
header: 'Headers constructor',
|
|
message: `expected name/value pair to be length 2, found ${header.length}.`
|
|
})
|
|
}
|
|
|
|
// 2. Append (header’s first item, header’s second item) to headers.
|
|
appendHeader(headers, header[0], header[1])
|
|
}
|
|
} else if (typeof object === 'object' && object !== null) {
|
|
// Note: null should throw
|
|
|
|
// 2. Otherwise, object is a record, then for each key → value in object,
|
|
// append (key, value) to headers
|
|
const keys = Object.keys(object)
|
|
for (let i = 0; i < keys.length; ++i) {
|
|
appendHeader(headers, keys[i], object[keys[i]])
|
|
}
|
|
} else {
|
|
throw webidl.errors.conversionFailed({
|
|
prefix: 'Headers constructor',
|
|
argument: 'Argument 1',
|
|
types: ['sequence<sequence<ByteString>>', 'record<ByteString, ByteString>']
|
|
})
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#concept-headers-append
|
|
*/
|
|
function appendHeader (headers, name, value) {
|
|
// 1. Normalize value.
|
|
value = headerValueNormalize(value)
|
|
|
|
// 2. If name is not a header name or value is not a
|
|
// header value, then throw a TypeError.
|
|
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'
|
|
})
|
|
}
|
|
|
|
// 3. If headers’s guard is "immutable", then throw a TypeError.
|
|
// 4. Otherwise, if headers’s guard is "request" and name is a
|
|
// forbidden header name, return.
|
|
// 5. Otherwise, if headers’s guard is "request-no-cors":
|
|
// TODO
|
|
// Note: undici does not implement forbidden header names
|
|
if (getHeadersGuard(headers) === 'immutable') {
|
|
throw new TypeError('immutable')
|
|
}
|
|
|
|
// 6. Otherwise, if headers’s guard is "response" and name is a
|
|
// forbidden response-header name, return.
|
|
|
|
// 7. Append (name, value) to headers’s header list.
|
|
return getHeadersList(headers).append(name, value, false)
|
|
|
|
// 8. If headers’s guard is "request-no-cors", then remove
|
|
// privileged no-CORS request headers from headers
|
|
}
|
|
|
|
function compareHeaderName (a, b) {
|
|
return a[0] < b[0] ? -1 : 1
|
|
}
|
|
|
|
class HeadersList {
|
|
/** @type {[string, string][]|null} */
|
|
cookies = null
|
|
|
|
constructor (init) {
|
|
if (init instanceof HeadersList) {
|
|
this[kHeadersMap] = new Map(init[kHeadersMap])
|
|
this[kHeadersSortedMap] = init[kHeadersSortedMap]
|
|
this.cookies = init.cookies === null ? null : [...init.cookies]
|
|
} else {
|
|
this[kHeadersMap] = new Map(init)
|
|
this[kHeadersSortedMap] = null
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#header-list-contains
|
|
* @param {string} name
|
|
* @param {boolean} isLowerCase
|
|
*/
|
|
contains (name, isLowerCase) {
|
|
// A header list list contains a header name name if list
|
|
// contains a header whose name is a byte-case-insensitive
|
|
// match for name.
|
|
|
|
return this[kHeadersMap].has(isLowerCase ? name : name.toLowerCase())
|
|
}
|
|
|
|
clear () {
|
|
this[kHeadersMap].clear()
|
|
this[kHeadersSortedMap] = null
|
|
this.cookies = null
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#concept-header-list-append
|
|
* @param {string} name
|
|
* @param {string} value
|
|
* @param {boolean} isLowerCase
|
|
*/
|
|
append (name, value, isLowerCase) {
|
|
this[kHeadersSortedMap] = null
|
|
|
|
// 1. If list contains name, then set name to the first such
|
|
// header’s name.
|
|
const lowercaseName = isLowerCase ? name : name.toLowerCase()
|
|
const exists = this[kHeadersMap].get(lowercaseName)
|
|
|
|
// 2. Append (name, value) to list.
|
|
if (exists) {
|
|
const delimiter = lowercaseName === 'cookie' ? '; ' : ', '
|
|
this[kHeadersMap].set(lowercaseName, {
|
|
name: exists.name,
|
|
value: `${exists.value}${delimiter}${value}`
|
|
})
|
|
} else {
|
|
this[kHeadersMap].set(lowercaseName, { name, value })
|
|
}
|
|
|
|
if (lowercaseName === 'set-cookie') {
|
|
(this.cookies ??= []).push(value)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#concept-header-list-set
|
|
* @param {string} name
|
|
* @param {string} value
|
|
* @param {boolean} isLowerCase
|
|
*/
|
|
set (name, value, isLowerCase) {
|
|
this[kHeadersSortedMap] = null
|
|
const lowercaseName = isLowerCase ? name : name.toLowerCase()
|
|
|
|
if (lowercaseName === 'set-cookie') {
|
|
this.cookies = [value]
|
|
}
|
|
|
|
// 1. If list contains name, then set the value of
|
|
// the first such header to value and remove the
|
|
// others.
|
|
// 2. Otherwise, append header (name, value) to list.
|
|
this[kHeadersMap].set(lowercaseName, { name, value })
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#concept-header-list-delete
|
|
* @param {string} name
|
|
* @param {boolean} isLowerCase
|
|
*/
|
|
delete (name, isLowerCase) {
|
|
this[kHeadersSortedMap] = null
|
|
if (!isLowerCase) name = name.toLowerCase()
|
|
|
|
if (name === 'set-cookie') {
|
|
this.cookies = null
|
|
}
|
|
|
|
this[kHeadersMap].delete(name)
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#concept-header-list-get
|
|
* @param {string} name
|
|
* @param {boolean} isLowerCase
|
|
* @returns {string | null}
|
|
*/
|
|
get (name, isLowerCase) {
|
|
// 1. If list does not contain name, then return null.
|
|
// 2. Return the values of all headers in list whose name
|
|
// is a byte-case-insensitive match for name,
|
|
// separated from each other by 0x2C 0x20, in order.
|
|
return this[kHeadersMap].get(isLowerCase ? name : name.toLowerCase())?.value ?? null
|
|
}
|
|
|
|
* [Symbol.iterator] () {
|
|
// use the lowercased name
|
|
for (const { 0: name, 1: { value } } of this[kHeadersMap]) {
|
|
yield [name, value]
|
|
}
|
|
}
|
|
|
|
get entries () {
|
|
const headers = {}
|
|
|
|
if (this[kHeadersMap].size !== 0) {
|
|
for (const { name, value } of this[kHeadersMap].values()) {
|
|
headers[name] = value
|
|
}
|
|
}
|
|
|
|
return headers
|
|
}
|
|
|
|
rawValues () {
|
|
return this[kHeadersMap].values()
|
|
}
|
|
|
|
get entriesList () {
|
|
const headers = []
|
|
|
|
if (this[kHeadersMap].size !== 0) {
|
|
for (const { 0: lowerName, 1: { name, value } } of this[kHeadersMap]) {
|
|
if (lowerName === 'set-cookie') {
|
|
for (const cookie of this.cookies) {
|
|
headers.push([name, cookie])
|
|
}
|
|
} else {
|
|
headers.push([name, value])
|
|
}
|
|
}
|
|
}
|
|
|
|
return headers
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#convert-header-names-to-a-sorted-lowercase-set
|
|
toSortedArray () {
|
|
const size = this[kHeadersMap].size
|
|
const array = new Array(size)
|
|
// In most cases, you will use the fast-path.
|
|
// fast-path: Use binary insertion sort for small arrays.
|
|
if (size <= 32) {
|
|
if (size === 0) {
|
|
// If empty, it is an empty array. To avoid the first index assignment.
|
|
return array
|
|
}
|
|
// Improve performance by unrolling loop and avoiding double-loop.
|
|
// Double-loop-less version of the binary insertion sort.
|
|
const iterator = this[kHeadersMap][Symbol.iterator]()
|
|
const firstValue = iterator.next().value
|
|
// set [name, value] to first index.
|
|
array[0] = [firstValue[0], firstValue[1].value]
|
|
// https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
|
|
// 3.2.2. Assert: value is non-null.
|
|
assert(firstValue[1].value !== null)
|
|
for (
|
|
let i = 1, j = 0, right = 0, left = 0, pivot = 0, x, value;
|
|
i < size;
|
|
++i
|
|
) {
|
|
// get next value
|
|
value = iterator.next().value
|
|
// set [name, value] to current index.
|
|
x = array[i] = [value[0], value[1].value]
|
|
// https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
|
|
// 3.2.2. Assert: value is non-null.
|
|
assert(x[1] !== null)
|
|
left = 0
|
|
right = i
|
|
// binary search
|
|
while (left < right) {
|
|
// middle index
|
|
pivot = left + ((right - left) >> 1)
|
|
// compare header name
|
|
if (array[pivot][0] <= x[0]) {
|
|
left = pivot + 1
|
|
} else {
|
|
right = pivot
|
|
}
|
|
}
|
|
if (i !== pivot) {
|
|
j = i
|
|
while (j > left) {
|
|
array[j] = array[--j]
|
|
}
|
|
array[left] = x
|
|
}
|
|
}
|
|
/* c8 ignore next 4 */
|
|
if (!iterator.next().done) {
|
|
// This is for debugging and will never be called.
|
|
throw new TypeError('Unreachable')
|
|
}
|
|
return array
|
|
} else {
|
|
// This case would be a rare occurrence.
|
|
// slow-path: fallback
|
|
let i = 0
|
|
for (const { 0: name, 1: { value } } of this[kHeadersMap]) {
|
|
array[i++] = [name, value]
|
|
// https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
|
|
// 3.2.2. Assert: value is non-null.
|
|
assert(value !== null)
|
|
}
|
|
return array.sort(compareHeaderName)
|
|
}
|
|
}
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#headers-class
|
|
class Headers {
|
|
#guard
|
|
#headersList
|
|
|
|
constructor (init = undefined) {
|
|
webidl.util.markAsUncloneable(this)
|
|
|
|
if (init === kConstruct) {
|
|
return
|
|
}
|
|
|
|
this.#headersList = new HeadersList()
|
|
|
|
// The new Headers(init) constructor steps are:
|
|
|
|
// 1. Set this’s guard to "none".
|
|
this.#guard = 'none'
|
|
|
|
// 2. If init is given, then fill this with init.
|
|
if (init !== undefined) {
|
|
init = webidl.converters.HeadersInit(init, 'Headers contructor', 'init')
|
|
fill(this, init)
|
|
}
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#dom-headers-append
|
|
append (name, value) {
|
|
webidl.brandCheck(this, Headers)
|
|
|
|
webidl.argumentLengthCheck(arguments, 2, 'Headers.append')
|
|
|
|
const prefix = 'Headers.append'
|
|
name = webidl.converters.ByteString(name, prefix, 'name')
|
|
value = webidl.converters.ByteString(value, prefix, 'value')
|
|
|
|
return appendHeader(this, name, value)
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#dom-headers-delete
|
|
delete (name) {
|
|
webidl.brandCheck(this, Headers)
|
|
|
|
webidl.argumentLengthCheck(arguments, 1, 'Headers.delete')
|
|
|
|
const prefix = 'Headers.delete'
|
|
name = webidl.converters.ByteString(name, prefix, 'name')
|
|
|
|
// 1. If name is not a header name, then throw a TypeError.
|
|
if (!isValidHeaderName(name)) {
|
|
throw webidl.errors.invalidArgument({
|
|
prefix: 'Headers.delete',
|
|
value: name,
|
|
type: 'header name'
|
|
})
|
|
}
|
|
|
|
// 2. If this’s guard is "immutable", then throw a TypeError.
|
|
// 3. Otherwise, if this’s guard is "request" and name is a
|
|
// forbidden header name, return.
|
|
// 4. Otherwise, if this’s guard is "request-no-cors", name
|
|
// is not a no-CORS-safelisted request-header name, and
|
|
// name is not a privileged no-CORS request-header name,
|
|
// return.
|
|
// 5. Otherwise, if this’s guard is "response" and name is
|
|
// a forbidden response-header name, return.
|
|
// Note: undici does not implement forbidden header names
|
|
if (this.#guard === 'immutable') {
|
|
throw new TypeError('immutable')
|
|
}
|
|
|
|
// 6. If this’s header list does not contain name, then
|
|
// return.
|
|
if (!this.#headersList.contains(name, false)) {
|
|
return
|
|
}
|
|
|
|
// 7. Delete name from this’s header list.
|
|
// 8. If this’s guard is "request-no-cors", then remove
|
|
// privileged no-CORS request headers from this.
|
|
this.#headersList.delete(name, false)
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#dom-headers-get
|
|
get (name) {
|
|
webidl.brandCheck(this, Headers)
|
|
|
|
webidl.argumentLengthCheck(arguments, 1, 'Headers.get')
|
|
|
|
const prefix = 'Headers.get'
|
|
name = webidl.converters.ByteString(name, prefix, 'name')
|
|
|
|
// 1. If name is not a header name, then throw a TypeError.
|
|
if (!isValidHeaderName(name)) {
|
|
throw webidl.errors.invalidArgument({
|
|
prefix,
|
|
value: name,
|
|
type: 'header name'
|
|
})
|
|
}
|
|
|
|
// 2. Return the result of getting name from this’s header
|
|
// list.
|
|
return this.#headersList.get(name, false)
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#dom-headers-has
|
|
has (name) {
|
|
webidl.brandCheck(this, Headers)
|
|
|
|
webidl.argumentLengthCheck(arguments, 1, 'Headers.has')
|
|
|
|
const prefix = 'Headers.has'
|
|
name = webidl.converters.ByteString(name, prefix, 'name')
|
|
|
|
// 1. If name is not a header name, then throw a TypeError.
|
|
if (!isValidHeaderName(name)) {
|
|
throw webidl.errors.invalidArgument({
|
|
prefix,
|
|
value: name,
|
|
type: 'header name'
|
|
})
|
|
}
|
|
|
|
// 2. Return true if this’s header list contains name;
|
|
// otherwise false.
|
|
return this.#headersList.contains(name, false)
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#dom-headers-set
|
|
set (name, value) {
|
|
webidl.brandCheck(this, Headers)
|
|
|
|
webidl.argumentLengthCheck(arguments, 2, 'Headers.set')
|
|
|
|
const prefix = 'Headers.set'
|
|
name = webidl.converters.ByteString(name, prefix, 'name')
|
|
value = webidl.converters.ByteString(value, prefix, 'value')
|
|
|
|
// 1. Normalize value.
|
|
value = headerValueNormalize(value)
|
|
|
|
// 2. If name is not a header name or value is not a
|
|
// header value, then throw a TypeError.
|
|
if (!isValidHeaderName(name)) {
|
|
throw webidl.errors.invalidArgument({
|
|
prefix,
|
|
value: name,
|
|
type: 'header name'
|
|
})
|
|
} else if (!isValidHeaderValue(value)) {
|
|
throw webidl.errors.invalidArgument({
|
|
prefix,
|
|
value,
|
|
type: 'header value'
|
|
})
|
|
}
|
|
|
|
// 3. If this’s guard is "immutable", then throw a TypeError.
|
|
// 4. Otherwise, if this’s guard is "request" and name is a
|
|
// forbidden header name, return.
|
|
// 5. Otherwise, if this’s guard is "request-no-cors" and
|
|
// name/value is not a no-CORS-safelisted request-header,
|
|
// return.
|
|
// 6. Otherwise, if this’s guard is "response" and name is a
|
|
// forbidden response-header name, return.
|
|
// Note: undici does not implement forbidden header names
|
|
if (this.#guard === 'immutable') {
|
|
throw new TypeError('immutable')
|
|
}
|
|
|
|
// 7. Set (name, value) in this’s header list.
|
|
// 8. If this’s guard is "request-no-cors", then remove
|
|
// privileged no-CORS request headers from this
|
|
this.#headersList.set(name, value, false)
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#dom-headers-getsetcookie
|
|
getSetCookie () {
|
|
webidl.brandCheck(this, Headers)
|
|
|
|
// 1. If this’s header list does not contain `Set-Cookie`, then return « ».
|
|
// 2. Return the values of all headers in this’s header list whose name is
|
|
// a byte-case-insensitive match for `Set-Cookie`, in order.
|
|
|
|
const list = this.#headersList.cookies
|
|
|
|
if (list) {
|
|
return [...list]
|
|
}
|
|
|
|
return []
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
|
|
get [kHeadersSortedMap] () {
|
|
if (this.#headersList[kHeadersSortedMap]) {
|
|
return this.#headersList[kHeadersSortedMap]
|
|
}
|
|
|
|
// 1. Let headers be an empty list of headers with the key being the name
|
|
// and value the value.
|
|
const headers = []
|
|
|
|
// 2. Let names be the result of convert header names to a sorted-lowercase
|
|
// set with all the names of the headers in list.
|
|
const names = this.#headersList.toSortedArray()
|
|
|
|
const cookies = this.#headersList.cookies
|
|
|
|
// fast-path
|
|
if (cookies === null || cookies.length === 1) {
|
|
// Note: The non-null assertion of value has already been done by `HeadersList#toSortedArray`
|
|
return (this.#headersList[kHeadersSortedMap] = names)
|
|
}
|
|
|
|
// 3. For each name of names:
|
|
for (let i = 0; i < names.length; ++i) {
|
|
const { 0: name, 1: value } = names[i]
|
|
// 1. If name is `set-cookie`, then:
|
|
if (name === 'set-cookie') {
|
|
// 1. Let values be a list of all values of headers in list whose name
|
|
// is a byte-case-insensitive match for name, in order.
|
|
|
|
// 2. For each value of values:
|
|
// 1. Append (name, value) to headers.
|
|
for (let j = 0; j < cookies.length; ++j) {
|
|
headers.push([name, cookies[j]])
|
|
}
|
|
} else {
|
|
// 2. Otherwise:
|
|
|
|
// 1. Let value be the result of getting name from list.
|
|
|
|
// 2. Assert: value is non-null.
|
|
// Note: This operation was done by `HeadersList#toSortedArray`.
|
|
|
|
// 3. Append (name, value) to headers.
|
|
headers.push([name, value])
|
|
}
|
|
}
|
|
|
|
// 4. Return headers.
|
|
return (this.#headersList[kHeadersSortedMap] = headers)
|
|
}
|
|
|
|
[util.inspect.custom] (depth, options) {
|
|
options.depth ??= depth
|
|
|
|
return `Headers ${util.formatWithOptions(options, this.#headersList.entries)}`
|
|
}
|
|
|
|
static getHeadersGuard (o) {
|
|
return o.#guard
|
|
}
|
|
|
|
static setHeadersGuard (o, guard) {
|
|
o.#guard = guard
|
|
}
|
|
|
|
static getHeadersList (o) {
|
|
return o.#headersList
|
|
}
|
|
|
|
static setHeadersList (o, list) {
|
|
o.#headersList = list
|
|
}
|
|
}
|
|
|
|
const { getHeadersGuard, setHeadersGuard, getHeadersList, setHeadersList } = Headers
|
|
Reflect.deleteProperty(Headers, 'getHeadersGuard')
|
|
Reflect.deleteProperty(Headers, 'setHeadersGuard')
|
|
Reflect.deleteProperty(Headers, 'getHeadersList')
|
|
Reflect.deleteProperty(Headers, 'setHeadersList')
|
|
|
|
iteratorMixin('Headers', Headers, kHeadersSortedMap, 0, 1)
|
|
|
|
Object.defineProperties(Headers.prototype, {
|
|
append: kEnumerableProperty,
|
|
delete: kEnumerableProperty,
|
|
get: kEnumerableProperty,
|
|
has: kEnumerableProperty,
|
|
set: kEnumerableProperty,
|
|
getSetCookie: kEnumerableProperty,
|
|
[Symbol.toStringTag]: {
|
|
value: 'Headers',
|
|
configurable: true
|
|
},
|
|
[util.inspect.custom]: {
|
|
enumerable: false
|
|
}
|
|
})
|
|
|
|
webidl.converters.HeadersInit = function (V, prefix, argument) {
|
|
if (webidl.util.Type(V) === 'Object') {
|
|
const iterator = Reflect.get(V, Symbol.iterator)
|
|
|
|
// A work-around to ensure we send the properly-cased Headers when V is a Headers object.
|
|
// Read https://github.com/nodejs/undici/pull/3159#issuecomment-2075537226 before touching, please.
|
|
if (!util.types.isProxy(V) && iterator === Headers.prototype.entries) { // Headers object
|
|
try {
|
|
return getHeadersList(V).entriesList
|
|
} catch {
|
|
// fall-through
|
|
}
|
|
}
|
|
|
|
if (typeof iterator === 'function') {
|
|
return webidl.converters['sequence<sequence<ByteString>>'](V, prefix, argument, iterator.bind(V))
|
|
}
|
|
|
|
return webidl.converters['record<ByteString, ByteString>'](V, prefix, argument)
|
|
}
|
|
|
|
throw webidl.errors.conversionFailed({
|
|
prefix: 'Headers constructor',
|
|
argument: 'Argument 1',
|
|
types: ['sequence<sequence<ByteString>>', 'record<ByteString, ByteString>']
|
|
})
|
|
}
|
|
|
|
module.exports = {
|
|
fill,
|
|
// for test.
|
|
compareHeaderName,
|
|
Headers,
|
|
HeadersList,
|
|
getHeadersGuard,
|
|
setHeadersGuard,
|
|
setHeadersList,
|
|
getHeadersList
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4398:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
// https://github.com/Ethan-Arrowood/undici-fetch
|
|
|
|
|
|
|
|
const {
|
|
makeNetworkError,
|
|
makeAppropriateNetworkError,
|
|
filterResponse,
|
|
makeResponse,
|
|
fromInnerResponse
|
|
} = __nccwpck_require__(9051)
|
|
const { HeadersList } = __nccwpck_require__(660)
|
|
const { Request, cloneRequest } = __nccwpck_require__(9967)
|
|
const zlib = __nccwpck_require__(8522)
|
|
const {
|
|
bytesMatch,
|
|
makePolicyContainer,
|
|
clonePolicyContainer,
|
|
requestBadPort,
|
|
TAOCheck,
|
|
appendRequestOriginHeader,
|
|
responseLocationURL,
|
|
requestCurrentURL,
|
|
setRequestReferrerPolicyOnRedirect,
|
|
tryUpgradeRequestToAPotentiallyTrustworthyURL,
|
|
createOpaqueTimingInfo,
|
|
appendFetchMetadata,
|
|
corsCheck,
|
|
crossOriginResourcePolicyCheck,
|
|
determineRequestsReferrer,
|
|
coarsenedSharedCurrentTime,
|
|
createDeferredPromise,
|
|
isBlobLike,
|
|
sameOrigin,
|
|
isCancelled,
|
|
isAborted,
|
|
isErrorLike,
|
|
fullyReadBody,
|
|
readableStreamClose,
|
|
isomorphicEncode,
|
|
urlIsLocal,
|
|
urlIsHttpHttpsScheme,
|
|
urlHasHttpsScheme,
|
|
clampAndCoarsenConnectionTimingInfo,
|
|
simpleRangeHeaderValue,
|
|
buildContentRange,
|
|
createInflate,
|
|
extractMimeType
|
|
} = __nccwpck_require__(3168)
|
|
const { kState, kDispatcher } = __nccwpck_require__(3627)
|
|
const assert = __nccwpck_require__(4589)
|
|
const { safelyExtractBody, extractBody } = __nccwpck_require__(4492)
|
|
const {
|
|
redirectStatusSet,
|
|
nullBodyStatus,
|
|
safeMethodsSet,
|
|
requestBodyHeader,
|
|
subresourceSet
|
|
} = __nccwpck_require__(4495)
|
|
const EE = __nccwpck_require__(8474)
|
|
const { Readable, pipeline, finished } = __nccwpck_require__(7075)
|
|
const { addAbortListener, isErrored, isReadable, bufferToLowerCasedHeaderName } = __nccwpck_require__(3440)
|
|
const { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = __nccwpck_require__(1900)
|
|
const { getGlobalDispatcher } = __nccwpck_require__(2581)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const { STATUS_CODES } = __nccwpck_require__(7067)
|
|
const GET_OR_HEAD = ['GET', 'HEAD']
|
|
|
|
const defaultUserAgent = typeof __UNDICI_IS_NODE__ !== 'undefined' || typeof esbuildDetection !== 'undefined'
|
|
? 'node'
|
|
: 'undici'
|
|
|
|
/** @type {import('buffer').resolveObjectURL} */
|
|
let resolveObjectURL
|
|
|
|
class Fetch extends EE {
|
|
constructor (dispatcher) {
|
|
super()
|
|
|
|
this.dispatcher = dispatcher
|
|
this.connection = null
|
|
this.dump = false
|
|
this.state = 'ongoing'
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
// 1. Set controller’s state to "aborted".
|
|
this.state = 'aborted'
|
|
|
|
// 2. Let fallbackError be an "AbortError" DOMException.
|
|
// 3. Set error to fallbackError if it is not given.
|
|
if (!error) {
|
|
error = new DOMException('The operation was aborted.', 'AbortError')
|
|
}
|
|
|
|
// 4. Let serializedError be StructuredSerialize(error).
|
|
// If that threw an exception, catch it, and let
|
|
// serializedError be StructuredSerialize(fallbackError).
|
|
|
|
// 5. Set controller’s serialized abort reason to serializedError.
|
|
this.serializedAbortReason = error
|
|
|
|
this.connection?.destroy(error)
|
|
this.emit('terminated', error)
|
|
}
|
|
}
|
|
|
|
function handleFetchDone (response) {
|
|
finalizeAndReportTiming(response, 'fetch')
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#fetch-method
|
|
function fetch (input, init = undefined) {
|
|
webidl.argumentLengthCheck(arguments, 1, 'globalThis.fetch')
|
|
|
|
// 1. Let p be a new promise.
|
|
let p = createDeferredPromise()
|
|
|
|
// 2. Let requestObject be the result of invoking the initial value of
|
|
// Request as constructor with input and init as arguments. If this throws
|
|
// an exception, reject p with it and return p.
|
|
let requestObject
|
|
|
|
try {
|
|
requestObject = new Request(input, init)
|
|
} catch (e) {
|
|
p.reject(e)
|
|
return p.promise
|
|
}
|
|
|
|
// 3. Let request be requestObject’s request.
|
|
const request = requestObject[kState]
|
|
|
|
// 4. If requestObject’s signal’s aborted flag is set, then:
|
|
if (requestObject.signal.aborted) {
|
|
// 1. Abort the fetch() call with p, request, null, and
|
|
// requestObject’s signal’s abort reason.
|
|
abortFetch(p, request, null, requestObject.signal.reason)
|
|
|
|
// 2. Return p.
|
|
return p.promise
|
|
}
|
|
|
|
// 5. Let globalObject be request’s client’s global object.
|
|
const globalObject = request.client.globalObject
|
|
|
|
// 6. If globalObject is a ServiceWorkerGlobalScope object, then set
|
|
// request’s service-workers mode to "none".
|
|
if (globalObject?.constructor?.name === 'ServiceWorkerGlobalScope') {
|
|
request.serviceWorkers = 'none'
|
|
}
|
|
|
|
// 7. Let responseObject be null.
|
|
let responseObject = null
|
|
|
|
// 8. Let relevantRealm be this’s relevant Realm.
|
|
|
|
// 9. Let locallyAborted be false.
|
|
let locallyAborted = false
|
|
|
|
// 10. Let controller be null.
|
|
let controller = null
|
|
|
|
// 11. Add the following abort steps to requestObject’s signal:
|
|
addAbortListener(
|
|
requestObject.signal,
|
|
() => {
|
|
// 1. Set locallyAborted to true.
|
|
locallyAborted = true
|
|
|
|
// 2. Assert: controller is non-null.
|
|
assert(controller != null)
|
|
|
|
// 3. Abort controller with requestObject’s signal’s abort reason.
|
|
controller.abort(requestObject.signal.reason)
|
|
|
|
const realResponse = responseObject?.deref()
|
|
|
|
// 4. Abort the fetch() call with p, request, responseObject,
|
|
// and requestObject’s signal’s abort reason.
|
|
abortFetch(p, request, realResponse, requestObject.signal.reason)
|
|
}
|
|
)
|
|
|
|
// 12. Let handleFetchDone given response response be to finalize and
|
|
// report timing with response, globalObject, and "fetch".
|
|
// see function handleFetchDone
|
|
|
|
// 13. Set controller to the result of calling fetch given request,
|
|
// with processResponseEndOfBody set to handleFetchDone, and processResponse
|
|
// given response being these substeps:
|
|
|
|
const processResponse = (response) => {
|
|
// 1. If locallyAborted is true, terminate these substeps.
|
|
if (locallyAborted) {
|
|
return
|
|
}
|
|
|
|
// 2. If response’s aborted flag is set, then:
|
|
if (response.aborted) {
|
|
// 1. Let deserializedError be the result of deserialize a serialized
|
|
// abort reason given controller’s serialized abort reason and
|
|
// relevantRealm.
|
|
|
|
// 2. Abort the fetch() call with p, request, responseObject, and
|
|
// deserializedError.
|
|
|
|
abortFetch(p, request, responseObject, controller.serializedAbortReason)
|
|
return
|
|
}
|
|
|
|
// 3. If response is a network error, then reject p with a TypeError
|
|
// and terminate these substeps.
|
|
if (response.type === 'error') {
|
|
p.reject(new TypeError('fetch failed', { cause: response.error }))
|
|
return
|
|
}
|
|
|
|
// 4. Set responseObject to the result of creating a Response object,
|
|
// given response, "immutable", and relevantRealm.
|
|
responseObject = new WeakRef(fromInnerResponse(response, 'immutable'))
|
|
|
|
// 5. Resolve p with responseObject.
|
|
p.resolve(responseObject.deref())
|
|
p = null
|
|
}
|
|
|
|
controller = fetching({
|
|
request,
|
|
processResponseEndOfBody: handleFetchDone,
|
|
processResponse,
|
|
dispatcher: requestObject[kDispatcher] // undici
|
|
})
|
|
|
|
// 14. Return p.
|
|
return p.promise
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#finalize-and-report-timing
|
|
function finalizeAndReportTiming (response, initiatorType = 'other') {
|
|
// 1. If response is an aborted network error, then return.
|
|
if (response.type === 'error' && response.aborted) {
|
|
return
|
|
}
|
|
|
|
// 2. If response’s URL list is null or empty, then return.
|
|
if (!response.urlList?.length) {
|
|
return
|
|
}
|
|
|
|
// 3. Let originalURL be response’s URL list[0].
|
|
const originalURL = response.urlList[0]
|
|
|
|
// 4. Let timingInfo be response’s timing info.
|
|
let timingInfo = response.timingInfo
|
|
|
|
// 5. Let cacheState be response’s cache state.
|
|
let cacheState = response.cacheState
|
|
|
|
// 6. If originalURL’s scheme is not an HTTP(S) scheme, then return.
|
|
if (!urlIsHttpHttpsScheme(originalURL)) {
|
|
return
|
|
}
|
|
|
|
// 7. If timingInfo is null, then return.
|
|
if (timingInfo === null) {
|
|
return
|
|
}
|
|
|
|
// 8. If response’s timing allow passed flag is not set, then:
|
|
if (!response.timingAllowPassed) {
|
|
// 1. Set timingInfo to a the result of creating an opaque timing info for timingInfo.
|
|
timingInfo = createOpaqueTimingInfo({
|
|
startTime: timingInfo.startTime
|
|
})
|
|
|
|
// 2. Set cacheState to the empty string.
|
|
cacheState = ''
|
|
}
|
|
|
|
// 9. Set timingInfo’s end time to the coarsened shared current time
|
|
// given global’s relevant settings object’s cross-origin isolated
|
|
// capability.
|
|
// TODO: given global’s relevant settings object’s cross-origin isolated
|
|
// capability?
|
|
timingInfo.endTime = coarsenedSharedCurrentTime()
|
|
|
|
// 10. Set response’s timing info to timingInfo.
|
|
response.timingInfo = timingInfo
|
|
|
|
// 11. Mark resource timing for timingInfo, originalURL, initiatorType,
|
|
// global, and cacheState.
|
|
markResourceTiming(
|
|
timingInfo,
|
|
originalURL.href,
|
|
initiatorType,
|
|
globalThis,
|
|
cacheState
|
|
)
|
|
}
|
|
|
|
// https://w3c.github.io/resource-timing/#dfn-mark-resource-timing
|
|
const markResourceTiming = performance.markResourceTiming
|
|
|
|
// https://fetch.spec.whatwg.org/#abort-fetch
|
|
function abortFetch (p, request, responseObject, error) {
|
|
// 1. Reject promise with error.
|
|
if (p) {
|
|
// We might have already resolved the promise at this stage
|
|
p.reject(error)
|
|
}
|
|
|
|
// 2. If request’s body is not null and is readable, then cancel request’s
|
|
// body with error.
|
|
if (request.body != null && isReadable(request.body?.stream)) {
|
|
request.body.stream.cancel(error).catch((err) => {
|
|
if (err.code === 'ERR_INVALID_STATE') {
|
|
// Node bug?
|
|
return
|
|
}
|
|
throw err
|
|
})
|
|
}
|
|
|
|
// 3. If responseObject is null, then return.
|
|
if (responseObject == null) {
|
|
return
|
|
}
|
|
|
|
// 4. Let response be responseObject’s response.
|
|
const response = responseObject[kState]
|
|
|
|
// 5. If response’s body is not null and is readable, then error response’s
|
|
// body with error.
|
|
if (response.body != null && isReadable(response.body?.stream)) {
|
|
response.body.stream.cancel(error).catch((err) => {
|
|
if (err.code === 'ERR_INVALID_STATE') {
|
|
// Node bug?
|
|
return
|
|
}
|
|
throw err
|
|
})
|
|
}
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#fetching
|
|
function fetching ({
|
|
request,
|
|
processRequestBodyChunkLength,
|
|
processRequestEndOfBody,
|
|
processResponse,
|
|
processResponseEndOfBody,
|
|
processResponseConsumeBody,
|
|
useParallelQueue = false,
|
|
dispatcher = getGlobalDispatcher() // undici
|
|
}) {
|
|
// Ensure that the dispatcher is set accordingly
|
|
assert(dispatcher)
|
|
|
|
// 1. Let taskDestination be null.
|
|
let taskDestination = null
|
|
|
|
// 2. Let crossOriginIsolatedCapability be false.
|
|
let crossOriginIsolatedCapability = false
|
|
|
|
// 3. If request’s client is non-null, then:
|
|
if (request.client != null) {
|
|
// 1. Set taskDestination to request’s client’s global object.
|
|
taskDestination = request.client.globalObject
|
|
|
|
// 2. Set crossOriginIsolatedCapability to request’s client’s cross-origin
|
|
// isolated capability.
|
|
crossOriginIsolatedCapability =
|
|
request.client.crossOriginIsolatedCapability
|
|
}
|
|
|
|
// 4. If useParallelQueue is true, then set taskDestination to the result of
|
|
// starting a new parallel queue.
|
|
// TODO
|
|
|
|
// 5. Let timingInfo be a new fetch timing info whose start time and
|
|
// post-redirect start time are the coarsened shared current time given
|
|
// crossOriginIsolatedCapability.
|
|
const currentTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability)
|
|
const timingInfo = createOpaqueTimingInfo({
|
|
startTime: currentTime
|
|
})
|
|
|
|
// 6. Let fetchParams be a new fetch params whose
|
|
// request is request,
|
|
// timing info is timingInfo,
|
|
// process request body chunk length is processRequestBodyChunkLength,
|
|
// process request end-of-body is processRequestEndOfBody,
|
|
// process response is processResponse,
|
|
// process response consume body is processResponseConsumeBody,
|
|
// process response end-of-body is processResponseEndOfBody,
|
|
// task destination is taskDestination,
|
|
// and cross-origin isolated capability is crossOriginIsolatedCapability.
|
|
const fetchParams = {
|
|
controller: new Fetch(dispatcher),
|
|
request,
|
|
timingInfo,
|
|
processRequestBodyChunkLength,
|
|
processRequestEndOfBody,
|
|
processResponse,
|
|
processResponseConsumeBody,
|
|
processResponseEndOfBody,
|
|
taskDestination,
|
|
crossOriginIsolatedCapability
|
|
}
|
|
|
|
// 7. If request’s body is a byte sequence, then set request’s body to
|
|
// request’s body as a body.
|
|
// NOTE: Since fetching is only called from fetch, body should already be
|
|
// extracted.
|
|
assert(!request.body || request.body.stream)
|
|
|
|
// 8. If request’s window is "client", then set request’s window to request’s
|
|
// client, if request’s client’s global object is a Window object; otherwise
|
|
// "no-window".
|
|
if (request.window === 'client') {
|
|
// TODO: What if request.client is null?
|
|
request.window =
|
|
request.client?.globalObject?.constructor?.name === 'Window'
|
|
? request.client
|
|
: 'no-window'
|
|
}
|
|
|
|
// 9. If request’s origin is "client", then set request’s origin to request’s
|
|
// client’s origin.
|
|
if (request.origin === 'client') {
|
|
request.origin = request.client.origin
|
|
}
|
|
|
|
// 10. If all of the following conditions are true:
|
|
// TODO
|
|
|
|
// 11. If request’s policy container is "client", then:
|
|
if (request.policyContainer === 'client') {
|
|
// 1. If request’s client is non-null, then set request’s policy
|
|
// container to a clone of request’s client’s policy container. [HTML]
|
|
if (request.client != null) {
|
|
request.policyContainer = clonePolicyContainer(
|
|
request.client.policyContainer
|
|
)
|
|
} else {
|
|
// 2. Otherwise, set request’s policy container to a new policy
|
|
// container.
|
|
request.policyContainer = makePolicyContainer()
|
|
}
|
|
}
|
|
|
|
// 12. If request’s header list does not contain `Accept`, then:
|
|
if (!request.headersList.contains('accept', true)) {
|
|
// 1. Let value be `*/*`.
|
|
const value = '*/*'
|
|
|
|
// 2. A user agent should set value to the first matching statement, if
|
|
// any, switching on request’s destination:
|
|
// "document"
|
|
// "frame"
|
|
// "iframe"
|
|
// `text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8`
|
|
// "image"
|
|
// `image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5`
|
|
// "style"
|
|
// `text/css,*/*;q=0.1`
|
|
// TODO
|
|
|
|
// 3. Append `Accept`/value to request’s header list.
|
|
request.headersList.append('accept', value, true)
|
|
}
|
|
|
|
// 13. If request’s header list does not contain `Accept-Language`, then
|
|
// user agents should append `Accept-Language`/an appropriate value to
|
|
// request’s header list.
|
|
if (!request.headersList.contains('accept-language', true)) {
|
|
request.headersList.append('accept-language', '*', true)
|
|
}
|
|
|
|
// 14. If request’s priority is null, then use request’s initiator and
|
|
// destination appropriately in setting request’s priority to a
|
|
// user-agent-defined object.
|
|
if (request.priority === null) {
|
|
// TODO
|
|
}
|
|
|
|
// 15. If request is a subresource request, then:
|
|
if (subresourceSet.has(request.destination)) {
|
|
// TODO
|
|
}
|
|
|
|
// 16. Run main fetch given fetchParams.
|
|
mainFetch(fetchParams)
|
|
.catch(err => {
|
|
fetchParams.controller.terminate(err)
|
|
})
|
|
|
|
// 17. Return fetchParam's controller
|
|
return fetchParams.controller
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#concept-main-fetch
|
|
async function mainFetch (fetchParams, recursive = false) {
|
|
// 1. Let request be fetchParams’s request.
|
|
const request = fetchParams.request
|
|
|
|
// 2. Let response be null.
|
|
let response = null
|
|
|
|
// 3. If request’s local-URLs-only flag is set and request’s current URL is
|
|
// not local, then set response to a network error.
|
|
if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) {
|
|
response = makeNetworkError('local URLs only')
|
|
}
|
|
|
|
// 4. Run report Content Security Policy violations for request.
|
|
// TODO
|
|
|
|
// 5. Upgrade request to a potentially trustworthy URL, if appropriate.
|
|
tryUpgradeRequestToAPotentiallyTrustworthyURL(request)
|
|
|
|
// 6. If should request be blocked due to a bad port, should fetching request
|
|
// be blocked as mixed content, or should request be blocked by Content
|
|
// Security Policy returns blocked, then set response to a network error.
|
|
if (requestBadPort(request) === 'blocked') {
|
|
response = makeNetworkError('bad port')
|
|
}
|
|
// TODO: should fetching request be blocked as mixed content?
|
|
// TODO: should request be blocked by Content Security Policy?
|
|
|
|
// 7. If request’s referrer policy is the empty string, then set request’s
|
|
// referrer policy to request’s policy container’s referrer policy.
|
|
if (request.referrerPolicy === '') {
|
|
request.referrerPolicy = request.policyContainer.referrerPolicy
|
|
}
|
|
|
|
// 8. If request’s referrer is not "no-referrer", then set request’s
|
|
// referrer to the result of invoking determine request’s referrer.
|
|
if (request.referrer !== 'no-referrer') {
|
|
request.referrer = determineRequestsReferrer(request)
|
|
}
|
|
|
|
// 9. Set request’s current URL’s scheme to "https" if all of the following
|
|
// conditions are true:
|
|
// - request’s current URL’s scheme is "http"
|
|
// - request’s current URL’s host is a domain
|
|
// - Matching request’s current URL’s host per Known HSTS Host Domain Name
|
|
// Matching results in either a superdomain match with an asserted
|
|
// includeSubDomains directive or a congruent match (with or without an
|
|
// asserted includeSubDomains directive). [HSTS]
|
|
// TODO
|
|
|
|
// 10. If recursive is false, then run the remaining steps in parallel.
|
|
// TODO
|
|
|
|
// 11. If response is null, then set response to the result of running
|
|
// the steps corresponding to the first matching statement:
|
|
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')
|
|
) {
|
|
// 1. Set request’s response tainting to "basic".
|
|
request.responseTainting = 'basic'
|
|
|
|
// 2. Return the result of running scheme fetch given fetchParams.
|
|
return await schemeFetch(fetchParams)
|
|
}
|
|
|
|
// request’s mode is "same-origin"
|
|
if (request.mode === 'same-origin') {
|
|
// 1. Return a network error.
|
|
return makeNetworkError('request mode cannot be "same-origin"')
|
|
}
|
|
|
|
// request’s mode is "no-cors"
|
|
if (request.mode === 'no-cors') {
|
|
// 1. If request’s redirect mode is not "follow", then return a network
|
|
// error.
|
|
if (request.redirect !== 'follow') {
|
|
return makeNetworkError(
|
|
'redirect mode cannot be "follow" for "no-cors" request'
|
|
)
|
|
}
|
|
|
|
// 2. Set request’s response tainting to "opaque".
|
|
request.responseTainting = 'opaque'
|
|
|
|
// 3. Return the result of running scheme fetch given fetchParams.
|
|
return await schemeFetch(fetchParams)
|
|
}
|
|
|
|
// request’s current URL’s scheme is not an HTTP(S) scheme
|
|
if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) {
|
|
// Return a network error.
|
|
return makeNetworkError('URL scheme must be a HTTP(S) scheme')
|
|
}
|
|
|
|
// - request’s use-CORS-preflight flag is set
|
|
// - request’s unsafe-request flag is set and either request’s method is
|
|
// not a CORS-safelisted method or CORS-unsafe request-header names with
|
|
// request’s header list is not empty
|
|
// 1. Set request’s response tainting to "cors".
|
|
// 2. Let corsWithPreflightResponse be the result of running HTTP fetch
|
|
// given fetchParams and true.
|
|
// 3. If corsWithPreflightResponse is a network error, then clear cache
|
|
// entries using request.
|
|
// 4. Return corsWithPreflightResponse.
|
|
// TODO
|
|
|
|
// Otherwise
|
|
// 1. Set request’s response tainting to "cors".
|
|
request.responseTainting = 'cors'
|
|
|
|
// 2. Return the result of running HTTP fetch given fetchParams.
|
|
return await httpFetch(fetchParams)
|
|
})()
|
|
}
|
|
|
|
// 12. If recursive is true, then return response.
|
|
if (recursive) {
|
|
return response
|
|
}
|
|
|
|
// 13. If response is not a network error and response is not a filtered
|
|
// response, then:
|
|
if (response.status !== 0 && !response.internalResponse) {
|
|
// If request’s response tainting is "cors", then:
|
|
if (request.responseTainting === 'cors') {
|
|
// 1. Let headerNames be the result of extracting header list values
|
|
// given `Access-Control-Expose-Headers` and response’s header list.
|
|
// TODO
|
|
// 2. If request’s credentials mode is not "include" and headerNames
|
|
// contains `*`, then set response’s CORS-exposed header-name list to
|
|
// all unique header names in response’s header list.
|
|
// TODO
|
|
// 3. Otherwise, if headerNames is not null or failure, then set
|
|
// response’s CORS-exposed header-name list to headerNames.
|
|
// TODO
|
|
}
|
|
|
|
// Set response to the following filtered response with response as its
|
|
// internal response, depending on request’s response tainting:
|
|
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)
|
|
}
|
|
}
|
|
|
|
// 14. Let internalResponse be response, if response is a network error,
|
|
// and response’s internal response otherwise.
|
|
let internalResponse =
|
|
response.status === 0 ? response : response.internalResponse
|
|
|
|
// 15. If internalResponse’s URL list is empty, then set it to a clone of
|
|
// request’s URL list.
|
|
if (internalResponse.urlList.length === 0) {
|
|
internalResponse.urlList.push(...request.urlList)
|
|
}
|
|
|
|
// 16. If request’s timing allow failed flag is unset, then set
|
|
// internalResponse’s timing allow passed flag.
|
|
if (!request.timingAllowFailed) {
|
|
response.timingAllowPassed = true
|
|
}
|
|
|
|
// 17. If response is not a network error and any of the following returns
|
|
// blocked
|
|
// - should internalResponse to request be blocked as mixed content
|
|
// - should internalResponse to request be blocked by Content Security Policy
|
|
// - should internalResponse to request be blocked due to its MIME type
|
|
// - should internalResponse to request be blocked due to nosniff
|
|
// TODO
|
|
|
|
// 18. If response’s type is "opaque", internalResponse’s status is 206,
|
|
// internalResponse’s range-requested flag is set, and request’s header
|
|
// list does not contain `Range`, then set response and internalResponse
|
|
// to a network error.
|
|
if (
|
|
response.type === 'opaque' &&
|
|
internalResponse.status === 206 &&
|
|
internalResponse.rangeRequested &&
|
|
!request.headers.contains('range', true)
|
|
) {
|
|
response = internalResponse = makeNetworkError()
|
|
}
|
|
|
|
// 19. If response is not a network error and either request’s method is
|
|
// `HEAD` or `CONNECT`, or internalResponse’s status is a null body status,
|
|
// set internalResponse’s body to null and disregard any enqueuing toward
|
|
// it (if any).
|
|
if (
|
|
response.status !== 0 &&
|
|
(request.method === 'HEAD' ||
|
|
request.method === 'CONNECT' ||
|
|
nullBodyStatus.includes(internalResponse.status))
|
|
) {
|
|
internalResponse.body = null
|
|
fetchParams.controller.dump = true
|
|
}
|
|
|
|
// 20. If request’s integrity metadata is not the empty string, then:
|
|
if (request.integrity) {
|
|
// 1. Let processBodyError be this step: run fetch finale given fetchParams
|
|
// and a network error.
|
|
const processBodyError = (reason) =>
|
|
fetchFinale(fetchParams, makeNetworkError(reason))
|
|
|
|
// 2. If request’s response tainting is "opaque", or response’s body is null,
|
|
// then run processBodyError and abort these steps.
|
|
if (request.responseTainting === 'opaque' || response.body == null) {
|
|
processBodyError(response.error)
|
|
return
|
|
}
|
|
|
|
// 3. Let processBody given bytes be these steps:
|
|
const processBody = (bytes) => {
|
|
// 1. If bytes do not match request’s integrity metadata,
|
|
// then run processBodyError and abort these steps. [SRI]
|
|
if (!bytesMatch(bytes, request.integrity)) {
|
|
processBodyError('integrity mismatch')
|
|
return
|
|
}
|
|
|
|
// 2. Set response’s body to bytes as a body.
|
|
response.body = safelyExtractBody(bytes)[0]
|
|
|
|
// 3. Run fetch finale given fetchParams and response.
|
|
fetchFinale(fetchParams, response)
|
|
}
|
|
|
|
// 4. Fully read response’s body given processBody and processBodyError.
|
|
await fullyReadBody(response.body, processBody, processBodyError)
|
|
} else {
|
|
// 21. Otherwise, run fetch finale given fetchParams and response.
|
|
fetchFinale(fetchParams, response)
|
|
}
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#concept-scheme-fetch
|
|
// given a fetch params fetchParams
|
|
function schemeFetch (fetchParams) {
|
|
// Note: since the connection is destroyed on redirect, which sets fetchParams to a
|
|
// cancelled state, we do not want this condition to trigger *unless* there have been
|
|
// no redirects. See https://github.com/nodejs/undici/issues/1776
|
|
// 1. If fetchParams is canceled, then return the appropriate network error for fetchParams.
|
|
if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
|
|
return Promise.resolve(makeAppropriateNetworkError(fetchParams))
|
|
}
|
|
|
|
// 2. Let request be fetchParams’s request.
|
|
const { request } = fetchParams
|
|
|
|
const { protocol: scheme } = requestCurrentURL(request)
|
|
|
|
// 3. Switch on request’s current URL’s scheme and run the associated steps:
|
|
switch (scheme) {
|
|
case 'about:': {
|
|
// If request’s current URL’s path is the string "blank", then return a new response
|
|
// whose status message is `OK`, header list is « (`Content-Type`, `text/html;charset=utf-8`) »,
|
|
// and body is the empty byte sequence as a body.
|
|
|
|
// Otherwise, return a network error.
|
|
return Promise.resolve(makeNetworkError('about scheme is not supported'))
|
|
}
|
|
case 'blob:': {
|
|
if (!resolveObjectURL) {
|
|
resolveObjectURL = (__nccwpck_require__(4573).resolveObjectURL)
|
|
}
|
|
|
|
// 1. Let blobURLEntry be request’s current URL’s blob URL entry.
|
|
const blobURLEntry = requestCurrentURL(request)
|
|
|
|
// https://github.com/web-platform-tests/wpt/blob/7b0ebaccc62b566a1965396e5be7bb2bc06f841f/FileAPI/url/resources/fetch-tests.js#L52-L56
|
|
// Buffer.resolveObjectURL does not ignore URL queries.
|
|
if (blobURLEntry.search.length !== 0) {
|
|
return Promise.resolve(makeNetworkError('NetworkError when attempting to fetch resource.'))
|
|
}
|
|
|
|
const blob = resolveObjectURL(blobURLEntry.toString())
|
|
|
|
// 2. If request’s method is not `GET`, blobURLEntry is null, or blobURLEntry’s
|
|
// object is not a Blob object, then return a network error.
|
|
if (request.method !== 'GET' || !isBlobLike(blob)) {
|
|
return Promise.resolve(makeNetworkError('invalid method'))
|
|
}
|
|
|
|
// 3. Let blob be blobURLEntry’s object.
|
|
// Note: done above
|
|
|
|
// 4. Let response be a new response.
|
|
const response = makeResponse()
|
|
|
|
// 5. Let fullLength be blob’s size.
|
|
const fullLength = blob.size
|
|
|
|
// 6. Let serializedFullLength be fullLength, serialized and isomorphic encoded.
|
|
const serializedFullLength = isomorphicEncode(`${fullLength}`)
|
|
|
|
// 7. Let type be blob’s type.
|
|
const type = blob.type
|
|
|
|
// 8. If request’s header list does not contain `Range`:
|
|
// 9. Otherwise:
|
|
if (!request.headersList.contains('range', true)) {
|
|
// 1. Let bodyWithType be the result of safely extracting blob.
|
|
// Note: in the FileAPI a blob "object" is a Blob *or* a MediaSource.
|
|
// In node, this can only ever be a Blob. Therefore we can safely
|
|
// use extractBody directly.
|
|
const bodyWithType = extractBody(blob)
|
|
|
|
// 2. Set response’s status message to `OK`.
|
|
response.statusText = 'OK'
|
|
|
|
// 3. Set response’s body to bodyWithType’s body.
|
|
response.body = bodyWithType[0]
|
|
|
|
// 4. Set response’s header list to « (`Content-Length`, serializedFullLength), (`Content-Type`, type) ».
|
|
response.headersList.set('content-length', serializedFullLength, true)
|
|
response.headersList.set('content-type', type, true)
|
|
} else {
|
|
// 1. Set response’s range-requested flag.
|
|
response.rangeRequested = true
|
|
|
|
// 2. Let rangeHeader be the result of getting `Range` from request’s header list.
|
|
const rangeHeader = request.headersList.get('range', true)
|
|
|
|
// 3. Let rangeValue be the result of parsing a single range header value given rangeHeader and true.
|
|
const rangeValue = simpleRangeHeaderValue(rangeHeader, true)
|
|
|
|
// 4. If rangeValue is failure, then return a network error.
|
|
if (rangeValue === 'failure') {
|
|
return Promise.resolve(makeNetworkError('failed to fetch the data URL'))
|
|
}
|
|
|
|
// 5. Let (rangeStart, rangeEnd) be rangeValue.
|
|
let { rangeStartValue: rangeStart, rangeEndValue: rangeEnd } = rangeValue
|
|
|
|
// 6. If rangeStart is null:
|
|
// 7. Otherwise:
|
|
if (rangeStart === null) {
|
|
// 1. Set rangeStart to fullLength − rangeEnd.
|
|
rangeStart = fullLength - rangeEnd
|
|
|
|
// 2. Set rangeEnd to rangeStart + rangeEnd − 1.
|
|
rangeEnd = rangeStart + rangeEnd - 1
|
|
} else {
|
|
// 1. If rangeStart is greater than or equal to fullLength, then return a network error.
|
|
if (rangeStart >= fullLength) {
|
|
return Promise.resolve(makeNetworkError('Range start is greater than the blob\'s size.'))
|
|
}
|
|
|
|
// 2. If rangeEnd is null or rangeEnd is greater than or equal to fullLength, then set
|
|
// rangeEnd to fullLength − 1.
|
|
if (rangeEnd === null || rangeEnd >= fullLength) {
|
|
rangeEnd = fullLength - 1
|
|
}
|
|
}
|
|
|
|
// 8. Let slicedBlob be the result of invoking slice blob given blob, rangeStart,
|
|
// rangeEnd + 1, and type.
|
|
const slicedBlob = blob.slice(rangeStart, rangeEnd, type)
|
|
|
|
// 9. Let slicedBodyWithType be the result of safely extracting slicedBlob.
|
|
// Note: same reason as mentioned above as to why we use extractBody
|
|
const slicedBodyWithType = extractBody(slicedBlob)
|
|
|
|
// 10. Set response’s body to slicedBodyWithType’s body.
|
|
response.body = slicedBodyWithType[0]
|
|
|
|
// 11. Let serializedSlicedLength be slicedBlob’s size, serialized and isomorphic encoded.
|
|
const serializedSlicedLength = isomorphicEncode(`${slicedBlob.size}`)
|
|
|
|
// 12. Let contentRange be the result of invoking build a content range given rangeStart,
|
|
// rangeEnd, and fullLength.
|
|
const contentRange = buildContentRange(rangeStart, rangeEnd, fullLength)
|
|
|
|
// 13. Set response’s status to 206.
|
|
response.status = 206
|
|
|
|
// 14. Set response’s status message to `Partial Content`.
|
|
response.statusText = 'Partial Content'
|
|
|
|
// 15. Set response’s header list to « (`Content-Length`, serializedSlicedLength),
|
|
// (`Content-Type`, type), (`Content-Range`, contentRange) ».
|
|
response.headersList.set('content-length', serializedSlicedLength, true)
|
|
response.headersList.set('content-type', type, true)
|
|
response.headersList.set('content-range', contentRange, true)
|
|
}
|
|
|
|
// 10. Return response.
|
|
return Promise.resolve(response)
|
|
}
|
|
case 'data:': {
|
|
// 1. Let dataURLStruct be the result of running the
|
|
// data: URL processor on request’s current URL.
|
|
const currentURL = requestCurrentURL(request)
|
|
const dataURLStruct = dataURLProcessor(currentURL)
|
|
|
|
// 2. If dataURLStruct is failure, then return a
|
|
// network error.
|
|
if (dataURLStruct === 'failure') {
|
|
return Promise.resolve(makeNetworkError('failed to fetch the data URL'))
|
|
}
|
|
|
|
// 3. Let mimeType be dataURLStruct’s MIME type, serialized.
|
|
const mimeType = serializeAMimeType(dataURLStruct.mimeType)
|
|
|
|
// 4. Return a response whose status message is `OK`,
|
|
// header list is « (`Content-Type`, mimeType) »,
|
|
// and body is dataURLStruct’s body as a body.
|
|
return Promise.resolve(makeResponse({
|
|
statusText: 'OK',
|
|
headersList: [
|
|
['content-type', { name: 'Content-Type', value: mimeType }]
|
|
],
|
|
body: safelyExtractBody(dataURLStruct.body)[0]
|
|
}))
|
|
}
|
|
case 'file:': {
|
|
// For now, unfortunate as it is, file URLs are left as an exercise for the reader.
|
|
// When in doubt, return a network error.
|
|
return Promise.resolve(makeNetworkError('not implemented... yet...'))
|
|
}
|
|
case 'http:':
|
|
case 'https:': {
|
|
// Return the result of running HTTP fetch given fetchParams.
|
|
|
|
return httpFetch(fetchParams)
|
|
.catch((err) => makeNetworkError(err))
|
|
}
|
|
default: {
|
|
return Promise.resolve(makeNetworkError('unknown scheme'))
|
|
}
|
|
}
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#finalize-response
|
|
function finalizeResponse (fetchParams, response) {
|
|
// 1. Set fetchParams’s request’s done flag.
|
|
fetchParams.request.done = true
|
|
|
|
// 2, If fetchParams’s process response done is not null, then queue a fetch
|
|
// task to run fetchParams’s process response done given response, with
|
|
// fetchParams’s task destination.
|
|
if (fetchParams.processResponseDone != null) {
|
|
queueMicrotask(() => fetchParams.processResponseDone(response))
|
|
}
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#fetch-finale
|
|
function fetchFinale (fetchParams, response) {
|
|
// 1. Let timingInfo be fetchParams’s timing info.
|
|
let timingInfo = fetchParams.timingInfo
|
|
|
|
// 2. If response is not a network error and fetchParams’s request’s client is a secure context,
|
|
// then set timingInfo’s server-timing headers to the result of getting, decoding, and splitting
|
|
// `Server-Timing` from response’s internal response’s header list.
|
|
// TODO
|
|
|
|
// 3. Let processResponseEndOfBody be the following steps:
|
|
const processResponseEndOfBody = () => {
|
|
// 1. Let unsafeEndTime be the unsafe shared current time.
|
|
const unsafeEndTime = Date.now() // ?
|
|
|
|
// 2. If fetchParams’s request’s destination is "document", then set fetchParams’s controller’s
|
|
// full timing info to fetchParams’s timing info.
|
|
if (fetchParams.request.destination === 'document') {
|
|
fetchParams.controller.fullTimingInfo = timingInfo
|
|
}
|
|
|
|
// 3. Set fetchParams’s controller’s report timing steps to the following steps given a global object global:
|
|
fetchParams.controller.reportTimingSteps = () => {
|
|
// 1. If fetchParams’s request’s URL’s scheme is not an HTTP(S) scheme, then return.
|
|
if (fetchParams.request.url.protocol !== 'https:') {
|
|
return
|
|
}
|
|
|
|
// 2. Set timingInfo’s end time to the relative high resolution time given unsafeEndTime and global.
|
|
timingInfo.endTime = unsafeEndTime
|
|
|
|
// 3. Let cacheState be response’s cache state.
|
|
let cacheState = response.cacheState
|
|
|
|
// 4. Let bodyInfo be response’s body info.
|
|
const bodyInfo = response.bodyInfo
|
|
|
|
// 5. If response’s timing allow passed flag is not set, then set timingInfo to the result of creating an
|
|
// opaque timing info for timingInfo and set cacheState to the empty string.
|
|
if (!response.timingAllowPassed) {
|
|
timingInfo = createOpaqueTimingInfo(timingInfo)
|
|
|
|
cacheState = ''
|
|
}
|
|
|
|
// 6. Let responseStatus be 0.
|
|
let responseStatus = 0
|
|
|
|
// 7. If fetchParams’s request’s mode is not "navigate" or response’s has-cross-origin-redirects is false:
|
|
if (fetchParams.request.mode !== 'navigator' || !response.hasCrossOriginRedirects) {
|
|
// 1. Set responseStatus to response’s status.
|
|
responseStatus = response.status
|
|
|
|
// 2. Let mimeType be the result of extracting a MIME type from response’s header list.
|
|
const mimeType = extractMimeType(response.headersList)
|
|
|
|
// 3. If mimeType is not failure, then set bodyInfo’s content type to the result of minimizing a supported MIME type given mimeType.
|
|
if (mimeType !== 'failure') {
|
|
bodyInfo.contentType = minimizeSupportedMimeType(mimeType)
|
|
}
|
|
}
|
|
|
|
// 8. If fetchParams’s request’s initiator type is non-null, then mark resource timing given timingInfo,
|
|
// fetchParams’s request’s URL, fetchParams’s request’s initiator type, global, cacheState, bodyInfo,
|
|
// and responseStatus.
|
|
if (fetchParams.request.initiatorType != null) {
|
|
// TODO: update markresourcetiming
|
|
markResourceTiming(timingInfo, fetchParams.request.url.href, fetchParams.request.initiatorType, globalThis, cacheState, bodyInfo, responseStatus)
|
|
}
|
|
}
|
|
|
|
// 4. Let processResponseEndOfBodyTask be the following steps:
|
|
const processResponseEndOfBodyTask = () => {
|
|
// 1. Set fetchParams’s request’s done flag.
|
|
fetchParams.request.done = true
|
|
|
|
// 2. If fetchParams’s process response end-of-body is non-null, then run fetchParams’s process
|
|
// response end-of-body given response.
|
|
if (fetchParams.processResponseEndOfBody != null) {
|
|
queueMicrotask(() => fetchParams.processResponseEndOfBody(response))
|
|
}
|
|
|
|
// 3. If fetchParams’s request’s initiator type is non-null and fetchParams’s request’s client’s
|
|
// global object is fetchParams’s task destination, then run fetchParams’s controller’s report
|
|
// timing steps given fetchParams’s request’s client’s global object.
|
|
if (fetchParams.request.initiatorType != null) {
|
|
fetchParams.controller.reportTimingSteps()
|
|
}
|
|
}
|
|
|
|
// 5. Queue a fetch task to run processResponseEndOfBodyTask with fetchParams’s task destination
|
|
queueMicrotask(() => processResponseEndOfBodyTask())
|
|
}
|
|
|
|
// 4. If fetchParams’s process response is non-null, then queue a fetch task to run fetchParams’s
|
|
// process response given response, with fetchParams’s task destination.
|
|
if (fetchParams.processResponse != null) {
|
|
queueMicrotask(() => {
|
|
fetchParams.processResponse(response)
|
|
fetchParams.processResponse = null
|
|
})
|
|
}
|
|
|
|
// 5. Let internalResponse be response, if response is a network error; otherwise response’s internal response.
|
|
const internalResponse = response.type === 'error' ? response : (response.internalResponse ?? response)
|
|
|
|
// 6. If internalResponse’s body is null, then run processResponseEndOfBody.
|
|
// 7. Otherwise:
|
|
if (internalResponse.body == null) {
|
|
processResponseEndOfBody()
|
|
} else {
|
|
// mcollina: all the following steps of the specs are skipped.
|
|
// The internal transform stream is not needed.
|
|
// See https://github.com/nodejs/undici/pull/3093#issuecomment-2050198541
|
|
|
|
// 1. Let transformStream be a new TransformStream.
|
|
// 2. Let identityTransformAlgorithm be an algorithm which, given chunk, enqueues chunk in transformStream.
|
|
// 3. Set up transformStream with transformAlgorithm set to identityTransformAlgorithm and flushAlgorithm
|
|
// set to processResponseEndOfBody.
|
|
// 4. Set internalResponse’s body’s stream to the result of internalResponse’s body’s stream piped through transformStream.
|
|
|
|
finished(internalResponse.body.stream, () => {
|
|
processResponseEndOfBody()
|
|
})
|
|
}
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#http-fetch
|
|
async function httpFetch (fetchParams) {
|
|
// 1. Let request be fetchParams’s request.
|
|
const request = fetchParams.request
|
|
|
|
// 2. Let response be null.
|
|
let response = null
|
|
|
|
// 3. Let actualResponse be null.
|
|
let actualResponse = null
|
|
|
|
// 4. Let timingInfo be fetchParams’s timing info.
|
|
const timingInfo = fetchParams.timingInfo
|
|
|
|
// 5. If request’s service-workers mode is "all", then:
|
|
if (request.serviceWorkers === 'all') {
|
|
// TODO
|
|
}
|
|
|
|
// 6. If response is null, then:
|
|
if (response === null) {
|
|
// 1. If makeCORSPreflight is true and one of these conditions is true:
|
|
// TODO
|
|
|
|
// 2. If request’s redirect mode is "follow", then set request’s
|
|
// service-workers mode to "none".
|
|
if (request.redirect === 'follow') {
|
|
request.serviceWorkers = 'none'
|
|
}
|
|
|
|
// 3. Set response and actualResponse to the result of running
|
|
// HTTP-network-or-cache fetch given fetchParams.
|
|
actualResponse = response = await httpNetworkOrCacheFetch(fetchParams)
|
|
|
|
// 4. If request’s response tainting is "cors" and a CORS check
|
|
// for request and response returns failure, then return a network error.
|
|
if (
|
|
request.responseTainting === 'cors' &&
|
|
corsCheck(request, response) === 'failure'
|
|
) {
|
|
return makeNetworkError('cors failure')
|
|
}
|
|
|
|
// 5. If the TAO check for request and response returns failure, then set
|
|
// request’s timing allow failed flag.
|
|
if (TAOCheck(request, response) === 'failure') {
|
|
request.timingAllowFailed = true
|
|
}
|
|
}
|
|
|
|
// 7. If either request’s response tainting or response’s type
|
|
// is "opaque", and the cross-origin resource policy check with
|
|
// request’s origin, request’s client, request’s destination,
|
|
// and actualResponse returns blocked, then return a network error.
|
|
if (
|
|
(request.responseTainting === 'opaque' || response.type === 'opaque') &&
|
|
crossOriginResourcePolicyCheck(
|
|
request.origin,
|
|
request.client,
|
|
request.destination,
|
|
actualResponse
|
|
) === 'blocked'
|
|
) {
|
|
return makeNetworkError('blocked')
|
|
}
|
|
|
|
// 8. If actualResponse’s status is a redirect status, then:
|
|
if (redirectStatusSet.has(actualResponse.status)) {
|
|
// 1. If actualResponse’s status is not 303, request’s body is not null,
|
|
// and the connection uses HTTP/2, then user agents may, and are even
|
|
// encouraged to, transmit an RST_STREAM frame.
|
|
// See, https://github.com/whatwg/fetch/issues/1288
|
|
if (request.redirect !== 'manual') {
|
|
fetchParams.controller.connection.destroy(undefined, false)
|
|
}
|
|
|
|
// 2. Switch on request’s redirect mode:
|
|
if (request.redirect === 'error') {
|
|
// Set response to a network error.
|
|
response = makeNetworkError('unexpected redirect')
|
|
} else if (request.redirect === 'manual') {
|
|
// Set response to an opaque-redirect filtered response whose internal
|
|
// response is actualResponse.
|
|
// NOTE(spec): On the web this would return an `opaqueredirect` response,
|
|
// but that doesn't make sense server side.
|
|
// See https://github.com/nodejs/undici/issues/1193.
|
|
response = actualResponse
|
|
} else if (request.redirect === 'follow') {
|
|
// Set response to the result of running HTTP-redirect fetch given
|
|
// fetchParams and response.
|
|
response = await httpRedirectFetch(fetchParams, response)
|
|
} else {
|
|
assert(false)
|
|
}
|
|
}
|
|
|
|
// 9. Set response’s timing info to timingInfo.
|
|
response.timingInfo = timingInfo
|
|
|
|
// 10. Return response.
|
|
return response
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#http-redirect-fetch
|
|
function httpRedirectFetch (fetchParams, response) {
|
|
// 1. Let request be fetchParams’s request.
|
|
const request = fetchParams.request
|
|
|
|
// 2. Let actualResponse be response, if response is not a filtered response,
|
|
// and response’s internal response otherwise.
|
|
const actualResponse = response.internalResponse
|
|
? response.internalResponse
|
|
: response
|
|
|
|
// 3. Let locationURL be actualResponse’s location URL given request’s current
|
|
// URL’s fragment.
|
|
let locationURL
|
|
|
|
try {
|
|
locationURL = responseLocationURL(
|
|
actualResponse,
|
|
requestCurrentURL(request).hash
|
|
)
|
|
|
|
// 4. If locationURL is null, then return response.
|
|
if (locationURL == null) {
|
|
return response
|
|
}
|
|
} catch (err) {
|
|
// 5. If locationURL is failure, then return a network error.
|
|
return Promise.resolve(makeNetworkError(err))
|
|
}
|
|
|
|
// 6. If locationURL’s scheme is not an HTTP(S) scheme, then return a network
|
|
// error.
|
|
if (!urlIsHttpHttpsScheme(locationURL)) {
|
|
return Promise.resolve(makeNetworkError('URL scheme must be a HTTP(S) scheme'))
|
|
}
|
|
|
|
// 7. If request’s redirect count is 20, then return a network error.
|
|
if (request.redirectCount === 20) {
|
|
return Promise.resolve(makeNetworkError('redirect count exceeded'))
|
|
}
|
|
|
|
// 8. Increase request’s redirect count by 1.
|
|
request.redirectCount += 1
|
|
|
|
// 9. If request’s mode is "cors", locationURL includes credentials, and
|
|
// request’s origin is not same origin with locationURL’s origin, then return
|
|
// a network error.
|
|
if (
|
|
request.mode === 'cors' &&
|
|
(locationURL.username || locationURL.password) &&
|
|
!sameOrigin(request, locationURL)
|
|
) {
|
|
return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"'))
|
|
}
|
|
|
|
// 10. If request’s response tainting is "cors" and locationURL includes
|
|
// credentials, then return a network error.
|
|
if (
|
|
request.responseTainting === 'cors' &&
|
|
(locationURL.username || locationURL.password)
|
|
) {
|
|
return Promise.resolve(makeNetworkError(
|
|
'URL cannot contain credentials for request mode "cors"'
|
|
))
|
|
}
|
|
|
|
// 11. If actualResponse’s status is not 303, request’s body is non-null,
|
|
// and request’s body’s source is null, then return a network error.
|
|
if (
|
|
actualResponse.status !== 303 &&
|
|
request.body != null &&
|
|
request.body.source == null
|
|
) {
|
|
return Promise.resolve(makeNetworkError())
|
|
}
|
|
|
|
// 12. If one of the following is true
|
|
// - actualResponse’s status is 301 or 302 and request’s method is `POST`
|
|
// - actualResponse’s status is 303 and request’s method is not `GET` or `HEAD`
|
|
if (
|
|
([301, 302].includes(actualResponse.status) && request.method === 'POST') ||
|
|
(actualResponse.status === 303 &&
|
|
!GET_OR_HEAD.includes(request.method))
|
|
) {
|
|
// then:
|
|
// 1. Set request’s method to `GET` and request’s body to null.
|
|
request.method = 'GET'
|
|
request.body = null
|
|
|
|
// 2. For each headerName of request-body-header name, delete headerName from
|
|
// request’s header list.
|
|
for (const headerName of requestBodyHeader) {
|
|
request.headersList.delete(headerName)
|
|
}
|
|
}
|
|
|
|
// 13. If request’s current URL’s origin is not same origin with locationURL’s
|
|
// origin, then for each headerName of CORS non-wildcard request-header name,
|
|
// delete headerName from request’s header list.
|
|
if (!sameOrigin(requestCurrentURL(request), locationURL)) {
|
|
// https://fetch.spec.whatwg.org/#cors-non-wildcard-request-header-name
|
|
request.headersList.delete('authorization', true)
|
|
|
|
// https://fetch.spec.whatwg.org/#authentication-entries
|
|
request.headersList.delete('proxy-authorization', true)
|
|
|
|
// "Cookie" and "Host" are forbidden request-headers, which undici doesn't implement.
|
|
request.headersList.delete('cookie', true)
|
|
request.headersList.delete('host', true)
|
|
}
|
|
|
|
// 14. If request’s body is non-null, then set request’s body to the first return
|
|
// value of safely extracting request’s body’s source.
|
|
if (request.body != null) {
|
|
assert(request.body.source != null)
|
|
request.body = safelyExtractBody(request.body.source)[0]
|
|
}
|
|
|
|
// 15. Let timingInfo be fetchParams’s timing info.
|
|
const timingInfo = fetchParams.timingInfo
|
|
|
|
// 16. Set timingInfo’s redirect end time and post-redirect start time to the
|
|
// coarsened shared current time given fetchParams’s cross-origin isolated
|
|
// capability.
|
|
timingInfo.redirectEndTime = timingInfo.postRedirectStartTime =
|
|
coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability)
|
|
|
|
// 17. If timingInfo’s redirect start time is 0, then set timingInfo’s
|
|
// redirect start time to timingInfo’s start time.
|
|
if (timingInfo.redirectStartTime === 0) {
|
|
timingInfo.redirectStartTime = timingInfo.startTime
|
|
}
|
|
|
|
// 18. Append locationURL to request’s URL list.
|
|
request.urlList.push(locationURL)
|
|
|
|
// 19. Invoke set request’s referrer policy on redirect on request and
|
|
// actualResponse.
|
|
setRequestReferrerPolicyOnRedirect(request, actualResponse)
|
|
|
|
// 20. Return the result of running main fetch given fetchParams and true.
|
|
return mainFetch(fetchParams, true)
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#http-network-or-cache-fetch
|
|
async function httpNetworkOrCacheFetch (
|
|
fetchParams,
|
|
isAuthenticationFetch = false,
|
|
isNewConnectionFetch = false
|
|
) {
|
|
// 1. Let request be fetchParams’s request.
|
|
const request = fetchParams.request
|
|
|
|
// 2. Let httpFetchParams be null.
|
|
let httpFetchParams = null
|
|
|
|
// 3. Let httpRequest be null.
|
|
let httpRequest = null
|
|
|
|
// 4. Let response be null.
|
|
let response = null
|
|
|
|
// 5. Let storedResponse be null.
|
|
// TODO: cache
|
|
|
|
// 6. Let httpCache be null.
|
|
const httpCache = null
|
|
|
|
// 7. Let the revalidatingFlag be unset.
|
|
const revalidatingFlag = false
|
|
|
|
// 8. Run these steps, but abort when the ongoing fetch is terminated:
|
|
|
|
// 1. If request’s window is "no-window" and request’s redirect mode is
|
|
// "error", then set httpFetchParams to fetchParams and httpRequest to
|
|
// request.
|
|
if (request.window === 'no-window' && request.redirect === 'error') {
|
|
httpFetchParams = fetchParams
|
|
httpRequest = request
|
|
} else {
|
|
// Otherwise:
|
|
|
|
// 1. Set httpRequest to a clone of request.
|
|
httpRequest = cloneRequest(request)
|
|
|
|
// 2. Set httpFetchParams to a copy of fetchParams.
|
|
httpFetchParams = { ...fetchParams }
|
|
|
|
// 3. Set httpFetchParams’s request to httpRequest.
|
|
httpFetchParams.request = httpRequest
|
|
}
|
|
|
|
// 3. Let includeCredentials be true if one of
|
|
const includeCredentials =
|
|
request.credentials === 'include' ||
|
|
(request.credentials === 'same-origin' &&
|
|
request.responseTainting === 'basic')
|
|
|
|
// 4. Let contentLength be httpRequest’s body’s length, if httpRequest’s
|
|
// body is non-null; otherwise null.
|
|
const contentLength = httpRequest.body ? httpRequest.body.length : null
|
|
|
|
// 5. Let contentLengthHeaderValue be null.
|
|
let contentLengthHeaderValue = null
|
|
|
|
// 6. If httpRequest’s body is null and httpRequest’s method is `POST` or
|
|
// `PUT`, then set contentLengthHeaderValue to `0`.
|
|
if (
|
|
httpRequest.body == null &&
|
|
['POST', 'PUT'].includes(httpRequest.method)
|
|
) {
|
|
contentLengthHeaderValue = '0'
|
|
}
|
|
|
|
// 7. If contentLength is non-null, then set contentLengthHeaderValue to
|
|
// contentLength, serialized and isomorphic encoded.
|
|
if (contentLength != null) {
|
|
contentLengthHeaderValue = isomorphicEncode(`${contentLength}`)
|
|
}
|
|
|
|
// 8. If contentLengthHeaderValue is non-null, then append
|
|
// `Content-Length`/contentLengthHeaderValue to httpRequest’s header
|
|
// list.
|
|
if (contentLengthHeaderValue != null) {
|
|
httpRequest.headersList.append('content-length', contentLengthHeaderValue, true)
|
|
}
|
|
|
|
// 9. If contentLengthHeaderValue is non-null, then append (`Content-Length`,
|
|
// contentLengthHeaderValue) to httpRequest’s header list.
|
|
|
|
// 10. If contentLength is non-null and httpRequest’s keepalive is true,
|
|
// then:
|
|
if (contentLength != null && httpRequest.keepalive) {
|
|
// NOTE: keepalive is a noop outside of browser context.
|
|
}
|
|
|
|
// 11. If httpRequest’s referrer is a URL, then append
|
|
// `Referer`/httpRequest’s referrer, serialized and isomorphic encoded,
|
|
// to httpRequest’s header list.
|
|
if (httpRequest.referrer instanceof URL) {
|
|
httpRequest.headersList.append('referer', isomorphicEncode(httpRequest.referrer.href), true)
|
|
}
|
|
|
|
// 12. Append a request `Origin` header for httpRequest.
|
|
appendRequestOriginHeader(httpRequest)
|
|
|
|
// 13. Append the Fetch metadata headers for httpRequest. [FETCH-METADATA]
|
|
appendFetchMetadata(httpRequest)
|
|
|
|
// 14. If httpRequest’s header list does not contain `User-Agent`, then
|
|
// user agents should append `User-Agent`/default `User-Agent` value to
|
|
// httpRequest’s header list.
|
|
if (!httpRequest.headersList.contains('user-agent', true)) {
|
|
httpRequest.headersList.append('user-agent', defaultUserAgent)
|
|
}
|
|
|
|
// 15. If httpRequest’s cache mode is "default" and httpRequest’s header
|
|
// list contains `If-Modified-Since`, `If-None-Match`,
|
|
// `If-Unmodified-Since`, `If-Match`, or `If-Range`, then set
|
|
// httpRequest’s cache mode to "no-store".
|
|
if (
|
|
httpRequest.cache === 'default' &&
|
|
(httpRequest.headersList.contains('if-modified-since', true) ||
|
|
httpRequest.headersList.contains('if-none-match', true) ||
|
|
httpRequest.headersList.contains('if-unmodified-since', true) ||
|
|
httpRequest.headersList.contains('if-match', true) ||
|
|
httpRequest.headersList.contains('if-range', true))
|
|
) {
|
|
httpRequest.cache = 'no-store'
|
|
}
|
|
|
|
// 16. If httpRequest’s cache mode is "no-cache", httpRequest’s prevent
|
|
// no-cache cache-control header modification flag is unset, and
|
|
// httpRequest’s header list does not contain `Cache-Control`, then append
|
|
// `Cache-Control`/`max-age=0` to httpRequest’s header list.
|
|
if (
|
|
httpRequest.cache === 'no-cache' &&
|
|
!httpRequest.preventNoCacheCacheControlHeaderModification &&
|
|
!httpRequest.headersList.contains('cache-control', true)
|
|
) {
|
|
httpRequest.headersList.append('cache-control', 'max-age=0', true)
|
|
}
|
|
|
|
// 17. If httpRequest’s cache mode is "no-store" or "reload", then:
|
|
if (httpRequest.cache === 'no-store' || httpRequest.cache === 'reload') {
|
|
// 1. If httpRequest’s header list does not contain `Pragma`, then append
|
|
// `Pragma`/`no-cache` to httpRequest’s header list.
|
|
if (!httpRequest.headersList.contains('pragma', true)) {
|
|
httpRequest.headersList.append('pragma', 'no-cache', true)
|
|
}
|
|
|
|
// 2. If httpRequest’s header list does not contain `Cache-Control`,
|
|
// then append `Cache-Control`/`no-cache` to httpRequest’s header list.
|
|
if (!httpRequest.headersList.contains('cache-control', true)) {
|
|
httpRequest.headersList.append('cache-control', 'no-cache', true)
|
|
}
|
|
}
|
|
|
|
// 18. If httpRequest’s header list contains `Range`, then append
|
|
// `Accept-Encoding`/`identity` to httpRequest’s header list.
|
|
if (httpRequest.headersList.contains('range', true)) {
|
|
httpRequest.headersList.append('accept-encoding', 'identity', true)
|
|
}
|
|
|
|
// 19. Modify httpRequest’s header list per HTTP. Do not append a given
|
|
// header if httpRequest’s header list contains that header’s name.
|
|
// TODO: https://github.com/whatwg/fetch/issues/1285#issuecomment-896560129
|
|
if (!httpRequest.headersList.contains('accept-encoding', true)) {
|
|
if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) {
|
|
httpRequest.headersList.append('accept-encoding', 'br, gzip, deflate', true)
|
|
} else {
|
|
httpRequest.headersList.append('accept-encoding', 'gzip, deflate', true)
|
|
}
|
|
}
|
|
|
|
httpRequest.headersList.delete('host', true)
|
|
|
|
// 20. If includeCredentials is true, then:
|
|
if (includeCredentials) {
|
|
// 1. If the user agent is not configured to block cookies for httpRequest
|
|
// (see section 7 of [COOKIES]), then:
|
|
// TODO: credentials
|
|
// 2. If httpRequest’s header list does not contain `Authorization`, then:
|
|
// TODO: credentials
|
|
}
|
|
|
|
// 21. If there’s a proxy-authentication entry, use it as appropriate.
|
|
// TODO: proxy-authentication
|
|
|
|
// 22. Set httpCache to the result of determining the HTTP cache
|
|
// partition, given httpRequest.
|
|
// TODO: cache
|
|
|
|
// 23. If httpCache is null, then set httpRequest’s cache mode to
|
|
// "no-store".
|
|
if (httpCache == null) {
|
|
httpRequest.cache = 'no-store'
|
|
}
|
|
|
|
// 24. If httpRequest’s cache mode is neither "no-store" nor "reload",
|
|
// then:
|
|
if (httpRequest.cache !== 'no-store' && httpRequest.cache !== 'reload') {
|
|
// TODO: cache
|
|
}
|
|
|
|
// 9. If aborted, then return the appropriate network error for fetchParams.
|
|
// TODO
|
|
|
|
// 10. If response is null, then:
|
|
if (response == null) {
|
|
// 1. If httpRequest’s cache mode is "only-if-cached", then return a
|
|
// network error.
|
|
if (httpRequest.cache === 'only-if-cached') {
|
|
return makeNetworkError('only if cached')
|
|
}
|
|
|
|
// 2. Let forwardResponse be the result of running HTTP-network fetch
|
|
// given httpFetchParams, includeCredentials, and isNewConnectionFetch.
|
|
const forwardResponse = await httpNetworkFetch(
|
|
httpFetchParams,
|
|
includeCredentials,
|
|
isNewConnectionFetch
|
|
)
|
|
|
|
// 3. If httpRequest’s method is unsafe and forwardResponse’s status is
|
|
// in the range 200 to 399, inclusive, invalidate appropriate stored
|
|
// responses in httpCache, as per the "Invalidation" chapter of HTTP
|
|
// Caching, and set storedResponse to null. [HTTP-CACHING]
|
|
if (
|
|
!safeMethodsSet.has(httpRequest.method) &&
|
|
forwardResponse.status >= 200 &&
|
|
forwardResponse.status <= 399
|
|
) {
|
|
// TODO: cache
|
|
}
|
|
|
|
// 4. If the revalidatingFlag is set and forwardResponse’s status is 304,
|
|
// then:
|
|
if (revalidatingFlag && forwardResponse.status === 304) {
|
|
// TODO: cache
|
|
}
|
|
|
|
// 5. If response is null, then:
|
|
if (response == null) {
|
|
// 1. Set response to forwardResponse.
|
|
response = forwardResponse
|
|
|
|
// 2. Store httpRequest and forwardResponse in httpCache, as per the
|
|
// "Storing Responses in Caches" chapter of HTTP Caching. [HTTP-CACHING]
|
|
// TODO: cache
|
|
}
|
|
}
|
|
|
|
// 11. Set response’s URL list to a clone of httpRequest’s URL list.
|
|
response.urlList = [...httpRequest.urlList]
|
|
|
|
// 12. If httpRequest’s header list contains `Range`, then set response’s
|
|
// range-requested flag.
|
|
if (httpRequest.headersList.contains('range', true)) {
|
|
response.rangeRequested = true
|
|
}
|
|
|
|
// 13. Set response’s request-includes-credentials to includeCredentials.
|
|
response.requestIncludesCredentials = includeCredentials
|
|
|
|
// 14. If response’s status is 401, httpRequest’s response tainting is not
|
|
// "cors", includeCredentials is true, and request’s window is an environment
|
|
// settings object, then:
|
|
// TODO
|
|
|
|
// 15. If response’s status is 407, then:
|
|
if (response.status === 407) {
|
|
// 1. If request’s window is "no-window", then return a network error.
|
|
if (request.window === 'no-window') {
|
|
return makeNetworkError()
|
|
}
|
|
|
|
// 2. ???
|
|
|
|
// 3. If fetchParams is canceled, then return the appropriate network error for fetchParams.
|
|
if (isCancelled(fetchParams)) {
|
|
return makeAppropriateNetworkError(fetchParams)
|
|
}
|
|
|
|
// 4. Prompt the end user as appropriate in request’s window and store
|
|
// the result as a proxy-authentication entry. [HTTP-AUTH]
|
|
// TODO: Invoke some kind of callback?
|
|
|
|
// 5. Set response to the result of running HTTP-network-or-cache fetch given
|
|
// fetchParams.
|
|
// TODO
|
|
return makeNetworkError('proxy authentication required')
|
|
}
|
|
|
|
// 16. If all of the following are true
|
|
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)
|
|
) {
|
|
// then:
|
|
|
|
// 1. If fetchParams is canceled, then return the appropriate network error for fetchParams.
|
|
if (isCancelled(fetchParams)) {
|
|
return makeAppropriateNetworkError(fetchParams)
|
|
}
|
|
|
|
// 2. Set response to the result of running HTTP-network-or-cache
|
|
// fetch given fetchParams, isAuthenticationFetch, and true.
|
|
|
|
// TODO (spec): The spec doesn't specify this but we need to cancel
|
|
// the active response before we can start a new one.
|
|
// https://github.com/whatwg/fetch/issues/1293
|
|
fetchParams.controller.connection.destroy()
|
|
|
|
response = await httpNetworkOrCacheFetch(
|
|
fetchParams,
|
|
isAuthenticationFetch,
|
|
true
|
|
)
|
|
}
|
|
|
|
// 17. If isAuthenticationFetch is true, then create an authentication entry
|
|
if (isAuthenticationFetch) {
|
|
// TODO
|
|
}
|
|
|
|
// 18. Return response.
|
|
return response
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#http-network-fetch
|
|
async function httpNetworkFetch (
|
|
fetchParams,
|
|
includeCredentials = false,
|
|
forceNewConnection = false
|
|
) {
|
|
assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed)
|
|
|
|
fetchParams.controller.connection = {
|
|
abort: null,
|
|
destroyed: false,
|
|
destroy (err, abort = true) {
|
|
if (!this.destroyed) {
|
|
this.destroyed = true
|
|
if (abort) {
|
|
this.abort?.(err ?? new DOMException('The operation was aborted.', 'AbortError'))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 1. Let request be fetchParams’s request.
|
|
const request = fetchParams.request
|
|
|
|
// 2. Let response be null.
|
|
let response = null
|
|
|
|
// 3. Let timingInfo be fetchParams’s timing info.
|
|
const timingInfo = fetchParams.timingInfo
|
|
|
|
// 4. Let httpCache be the result of determining the HTTP cache partition,
|
|
// given request.
|
|
// TODO: cache
|
|
const httpCache = null
|
|
|
|
// 5. If httpCache is null, then set request’s cache mode to "no-store".
|
|
if (httpCache == null) {
|
|
request.cache = 'no-store'
|
|
}
|
|
|
|
// 6. Let networkPartitionKey be the result of determining the network
|
|
// partition key given request.
|
|
// TODO
|
|
|
|
// 7. Let newConnection be "yes" if forceNewConnection is true; otherwise
|
|
// "no".
|
|
const newConnection = forceNewConnection ? 'yes' : 'no' // eslint-disable-line no-unused-vars
|
|
|
|
// 8. Switch on request’s mode:
|
|
if (request.mode === 'websocket') {
|
|
// Let connection be the result of obtaining a WebSocket connection,
|
|
// given request’s current URL.
|
|
// TODO
|
|
} else {
|
|
// Let connection be the result of obtaining a connection, given
|
|
// networkPartitionKey, request’s current URL’s origin,
|
|
// includeCredentials, and forceNewConnection.
|
|
// TODO
|
|
}
|
|
|
|
// 9. Run these steps, but abort when the ongoing fetch is terminated:
|
|
|
|
// 1. If connection is failure, then return a network error.
|
|
|
|
// 2. Set timingInfo’s final connection timing info to the result of
|
|
// calling clamp and coarsen connection timing info with connection’s
|
|
// timing info, timingInfo’s post-redirect start time, and fetchParams’s
|
|
// cross-origin isolated capability.
|
|
|
|
// 3. If connection is not an HTTP/2 connection, request’s body is non-null,
|
|
// and request’s body’s source is null, then append (`Transfer-Encoding`,
|
|
// `chunked`) to request’s header list.
|
|
|
|
// 4. Set timingInfo’s final network-request start time to the coarsened
|
|
// shared current time given fetchParams’s cross-origin isolated
|
|
// capability.
|
|
|
|
// 5. Set response to the result of making an HTTP request over connection
|
|
// using request with the following caveats:
|
|
|
|
// - Follow the relevant requirements from HTTP. [HTTP] [HTTP-SEMANTICS]
|
|
// [HTTP-COND] [HTTP-CACHING] [HTTP-AUTH]
|
|
|
|
// - If request’s body is non-null, and request’s body’s source is null,
|
|
// then the user agent may have a buffer of up to 64 kibibytes and store
|
|
// a part of request’s body in that buffer. If the user agent reads from
|
|
// request’s body beyond that buffer’s size and the user agent needs to
|
|
// resend request, then instead return a network error.
|
|
|
|
// - Set timingInfo’s final network-response start time to the coarsened
|
|
// shared current time given fetchParams’s cross-origin isolated capability,
|
|
// immediately after the user agent’s HTTP parser receives the first byte
|
|
// of the response (e.g., frame header bytes for HTTP/2 or response status
|
|
// line for HTTP/1.x).
|
|
|
|
// - Wait until all the headers are transmitted.
|
|
|
|
// - Any responses whose status is in the range 100 to 199, inclusive,
|
|
// and is not 101, are to be ignored, except for the purposes of setting
|
|
// timingInfo’s final network-response start time above.
|
|
|
|
// - If request’s header list contains `Transfer-Encoding`/`chunked` and
|
|
// response is transferred via HTTP/1.0 or older, then return a network
|
|
// error.
|
|
|
|
// - If the HTTP request results in a TLS client certificate dialog, then:
|
|
|
|
// 1. If request’s window is an environment settings object, make the
|
|
// dialog available in request’s window.
|
|
|
|
// 2. Otherwise, return a network error.
|
|
|
|
// To transmit request’s body body, run these steps:
|
|
let requestBody = null
|
|
// 1. If body is null and fetchParams’s process request end-of-body is
|
|
// non-null, then queue a fetch task given fetchParams’s process request
|
|
// end-of-body and fetchParams’s task destination.
|
|
if (request.body == null && fetchParams.processRequestEndOfBody) {
|
|
queueMicrotask(() => fetchParams.processRequestEndOfBody())
|
|
} else if (request.body != null) {
|
|
// 2. Otherwise, if body is non-null:
|
|
|
|
// 1. Let processBodyChunk given bytes be these steps:
|
|
const processBodyChunk = async function * (bytes) {
|
|
// 1. If the ongoing fetch is terminated, then abort these steps.
|
|
if (isCancelled(fetchParams)) {
|
|
return
|
|
}
|
|
|
|
// 2. Run this step in parallel: transmit bytes.
|
|
yield bytes
|
|
|
|
// 3. If fetchParams’s process request body is non-null, then run
|
|
// fetchParams’s process request body given bytes’s length.
|
|
fetchParams.processRequestBodyChunkLength?.(bytes.byteLength)
|
|
}
|
|
|
|
// 2. Let processEndOfBody be these steps:
|
|
const processEndOfBody = () => {
|
|
// 1. If fetchParams is canceled, then abort these steps.
|
|
if (isCancelled(fetchParams)) {
|
|
return
|
|
}
|
|
|
|
// 2. If fetchParams’s process request end-of-body is non-null,
|
|
// then run fetchParams’s process request end-of-body.
|
|
if (fetchParams.processRequestEndOfBody) {
|
|
fetchParams.processRequestEndOfBody()
|
|
}
|
|
}
|
|
|
|
// 3. Let processBodyError given e be these steps:
|
|
const processBodyError = (e) => {
|
|
// 1. If fetchParams is canceled, then abort these steps.
|
|
if (isCancelled(fetchParams)) {
|
|
return
|
|
}
|
|
|
|
// 2. If e is an "AbortError" DOMException, then abort fetchParams’s controller.
|
|
if (e.name === 'AbortError') {
|
|
fetchParams.controller.abort()
|
|
} else {
|
|
fetchParams.controller.terminate(e)
|
|
}
|
|
}
|
|
|
|
// 4. Incrementally read request’s body given processBodyChunk, processEndOfBody,
|
|
// processBodyError, and fetchParams’s task destination.
|
|
requestBody = (async function * () {
|
|
try {
|
|
for await (const bytes of request.body.stream) {
|
|
yield * processBodyChunk(bytes)
|
|
}
|
|
processEndOfBody()
|
|
} catch (err) {
|
|
processBodyError(err)
|
|
}
|
|
})()
|
|
}
|
|
|
|
try {
|
|
// socket is only provided for websockets
|
|
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) {
|
|
// 10. If aborted, then:
|
|
if (err.name === 'AbortError') {
|
|
// 1. If connection uses HTTP/2, then transmit an RST_STREAM frame.
|
|
fetchParams.controller.connection.destroy()
|
|
|
|
// 2. Return the appropriate network error for fetchParams.
|
|
return makeAppropriateNetworkError(fetchParams, err)
|
|
}
|
|
|
|
return makeNetworkError(err)
|
|
}
|
|
|
|
// 11. Let pullAlgorithm be an action that resumes the ongoing fetch
|
|
// if it is suspended.
|
|
const pullAlgorithm = async () => {
|
|
await fetchParams.controller.resume()
|
|
}
|
|
|
|
// 12. Let cancelAlgorithm be an algorithm that aborts fetchParams’s
|
|
// controller with reason, given reason.
|
|
const cancelAlgorithm = (reason) => {
|
|
// If the aborted fetch was already terminated, then we do not
|
|
// need to do anything.
|
|
if (!isCancelled(fetchParams)) {
|
|
fetchParams.controller.abort(reason)
|
|
}
|
|
}
|
|
|
|
// 13. Let highWaterMark be a non-negative, non-NaN number, chosen by
|
|
// the user agent.
|
|
// TODO
|
|
|
|
// 14. Let sizeAlgorithm be an algorithm that accepts a chunk object
|
|
// and returns a non-negative, non-NaN, non-infinite number, chosen by the user agent.
|
|
// TODO
|
|
|
|
// 15. Let stream be a new ReadableStream.
|
|
// 16. Set up stream with byte reading support with pullAlgorithm set to pullAlgorithm,
|
|
// cancelAlgorithm set to cancelAlgorithm.
|
|
const stream = new ReadableStream(
|
|
{
|
|
async start (controller) {
|
|
fetchParams.controller.controller = controller
|
|
},
|
|
async pull (controller) {
|
|
await pullAlgorithm(controller)
|
|
},
|
|
async cancel (reason) {
|
|
await cancelAlgorithm(reason)
|
|
},
|
|
type: 'bytes'
|
|
}
|
|
)
|
|
|
|
// 17. Run these steps, but abort when the ongoing fetch is terminated:
|
|
|
|
// 1. Set response’s body to a new body whose stream is stream.
|
|
response.body = { stream, source: null, length: null }
|
|
|
|
// 2. If response is not a network error and request’s cache mode is
|
|
// not "no-store", then update response in httpCache for request.
|
|
// TODO
|
|
|
|
// 3. If includeCredentials is true and the user agent is not configured
|
|
// to block cookies for request (see section 7 of [COOKIES]), then run the
|
|
// "set-cookie-string" parsing algorithm (see section 5.2 of [COOKIES]) on
|
|
// the value of each header whose name is a byte-case-insensitive match for
|
|
// `Set-Cookie` in response’s header list, if any, and request’s current URL.
|
|
// TODO
|
|
|
|
// 18. If aborted, then:
|
|
// TODO
|
|
|
|
// 19. Run these steps in parallel:
|
|
|
|
// 1. Run these steps, but abort when fetchParams is canceled:
|
|
fetchParams.controller.onAborted = onAborted
|
|
fetchParams.controller.on('terminated', onAborted)
|
|
fetchParams.controller.resume = async () => {
|
|
// 1. While true
|
|
while (true) {
|
|
// 1-3. See onData...
|
|
|
|
// 4. Set bytes to the result of handling content codings given
|
|
// codings and bytes.
|
|
let bytes
|
|
let isFailure
|
|
try {
|
|
const { done, value } = await fetchParams.controller.next()
|
|
|
|
if (isAborted(fetchParams)) {
|
|
break
|
|
}
|
|
|
|
bytes = done ? undefined : value
|
|
} catch (err) {
|
|
if (fetchParams.controller.ended && !timingInfo.encodedBodySize) {
|
|
// zlib doesn't like empty streams.
|
|
bytes = undefined
|
|
} else {
|
|
bytes = err
|
|
|
|
// err may be propagated from the result of calling readablestream.cancel,
|
|
// which might not be an error. https://github.com/nodejs/undici/issues/2009
|
|
isFailure = true
|
|
}
|
|
}
|
|
|
|
if (bytes === undefined) {
|
|
// 2. Otherwise, if the bytes transmission for response’s message
|
|
// body is done normally and stream is readable, then close
|
|
// stream, finalize response for fetchParams and response, and
|
|
// abort these in-parallel steps.
|
|
readableStreamClose(fetchParams.controller.controller)
|
|
|
|
finalizeResponse(fetchParams, response)
|
|
|
|
return
|
|
}
|
|
|
|
// 5. Increase timingInfo’s decoded body size by bytes’s length.
|
|
timingInfo.decodedBodySize += bytes?.byteLength ?? 0
|
|
|
|
// 6. If bytes is failure, then terminate fetchParams’s controller.
|
|
if (isFailure) {
|
|
fetchParams.controller.terminate(bytes)
|
|
return
|
|
}
|
|
|
|
// 7. Enqueue a Uint8Array wrapping an ArrayBuffer containing bytes
|
|
// into stream.
|
|
const buffer = new Uint8Array(bytes)
|
|
if (buffer.byteLength) {
|
|
fetchParams.controller.controller.enqueue(buffer)
|
|
}
|
|
|
|
// 8. If stream is errored, then terminate the ongoing fetch.
|
|
if (isErrored(stream)) {
|
|
fetchParams.controller.terminate()
|
|
return
|
|
}
|
|
|
|
// 9. If stream doesn’t need more data ask the user agent to suspend
|
|
// the ongoing fetch.
|
|
if (fetchParams.controller.controller.desiredSize <= 0) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. If aborted, then:
|
|
function onAborted (reason) {
|
|
// 2. If fetchParams is aborted, then:
|
|
if (isAborted(fetchParams)) {
|
|
// 1. Set response’s aborted flag.
|
|
response.aborted = true
|
|
|
|
// 2. If stream is readable, then error stream with the result of
|
|
// deserialize a serialized abort reason given fetchParams’s
|
|
// controller’s serialized abort reason and an
|
|
// implementation-defined realm.
|
|
if (isReadable(stream)) {
|
|
fetchParams.controller.controller.error(
|
|
fetchParams.controller.serializedAbortReason
|
|
)
|
|
}
|
|
} else {
|
|
// 3. Otherwise, if stream is readable, error stream with a TypeError.
|
|
if (isReadable(stream)) {
|
|
fetchParams.controller.controller.error(new TypeError('terminated', {
|
|
cause: isErrorLike(reason) ? reason : undefined
|
|
}))
|
|
}
|
|
}
|
|
|
|
// 4. If connection uses HTTP/2, then transmit an RST_STREAM frame.
|
|
// 5. Otherwise, the user agent should close connection unless it would be bad for performance to do so.
|
|
fetchParams.controller.connection.destroy()
|
|
}
|
|
|
|
// 20. Return response.
|
|
return response
|
|
|
|
function dispatch ({ body }) {
|
|
const url = requestCurrentURL(request)
|
|
/** @type {import('../..').Agent} */
|
|
const agent = fetchParams.controller.dispatcher
|
|
|
|
return new Promise((resolve, reject) => agent.dispatch(
|
|
{
|
|
path: url.pathname + url.search,
|
|
origin: url.origin,
|
|
method: request.method,
|
|
body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body,
|
|
headers: request.headersList.entries,
|
|
maxRedirections: 0,
|
|
upgrade: request.mode === 'websocket' ? 'websocket' : undefined
|
|
},
|
|
{
|
|
body: null,
|
|
abort: null,
|
|
|
|
onConnect (abort) {
|
|
// TODO (fix): Do we need connection here?
|
|
const { connection } = fetchParams.controller
|
|
|
|
// Set timingInfo’s final connection timing info to the result of calling clamp and coarsen
|
|
// connection timing info with connection’s timing info, timingInfo’s post-redirect start
|
|
// time, and fetchParams’s cross-origin isolated capability.
|
|
// TODO: implement connection timing
|
|
timingInfo.finalConnectionTimingInfo = clampAndCoarsenConnectionTimingInfo(undefined, timingInfo.postRedirectStartTime, fetchParams.crossOriginIsolatedCapability)
|
|
|
|
if (connection.destroyed) {
|
|
abort(new DOMException('The operation was aborted.', 'AbortError'))
|
|
} else {
|
|
fetchParams.controller.on('terminated', abort)
|
|
this.abort = connection.abort = abort
|
|
}
|
|
|
|
// Set timingInfo’s final network-request start time to the coarsened shared current time given
|
|
// fetchParams’s cross-origin isolated capability.
|
|
timingInfo.finalNetworkRequestStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability)
|
|
},
|
|
|
|
onResponseStarted () {
|
|
// Set timingInfo’s final network-response start time to the coarsened shared current
|
|
// time given fetchParams’s cross-origin isolated capability, immediately after the
|
|
// user agent’s HTTP parser receives the first byte of the response (e.g., frame header
|
|
// bytes for HTTP/2 or response status line for HTTP/1.x).
|
|
timingInfo.finalNetworkResponseStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability)
|
|
},
|
|
|
|
onHeaders (status, rawHeaders, resume, statusText) {
|
|
if (status < 200) {
|
|
return
|
|
}
|
|
|
|
let location = ''
|
|
|
|
const headersList = new HeadersList()
|
|
|
|
for (let i = 0; i < rawHeaders.length; i += 2) {
|
|
headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString('latin1'), true)
|
|
}
|
|
location = headersList.get('location', true)
|
|
|
|
this.body = new Readable({ read: resume })
|
|
|
|
const decoders = []
|
|
|
|
const willFollow = location && request.redirect === 'follow' &&
|
|
redirectStatusSet.has(status)
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding
|
|
if (request.method !== 'HEAD' && request.method !== 'CONNECT' && !nullBodyStatus.includes(status) && !willFollow) {
|
|
// https://www.rfc-editor.org/rfc/rfc7231#section-3.1.2.1
|
|
const contentEncoding = headersList.get('content-encoding', true)
|
|
// "All content-coding values are case-insensitive..."
|
|
/** @type {string[]} */
|
|
const codings = contentEncoding ? contentEncoding.toLowerCase().split(',') : []
|
|
|
|
// Limit the number of content-encodings to prevent resource exhaustion.
|
|
// CVE fix similar to urllib3 (GHSA-gm62-xv2j-4w53) and curl (CVE-2022-32206).
|
|
const maxContentEncodings = 5
|
|
if (codings.length > maxContentEncodings) {
|
|
reject(new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`))
|
|
return true
|
|
}
|
|
|
|
for (let i = codings.length - 1; i >= 0; --i) {
|
|
const coding = codings[i].trim()
|
|
// https://www.rfc-editor.org/rfc/rfc9112.html#section-7.2
|
|
if (coding === 'x-gzip' || coding === 'gzip') {
|
|
decoders.push(zlib.createGunzip({
|
|
// Be less strict when decoding compressed responses, since sometimes
|
|
// servers send slightly invalid responses that are still accepted
|
|
// by common browsers.
|
|
// Always using Z_SYNC_FLUSH is what cURL does.
|
|
flush: zlib.constants.Z_SYNC_FLUSH,
|
|
finishFlush: zlib.constants.Z_SYNC_FLUSH
|
|
}))
|
|
} else if (coding === 'deflate') {
|
|
decoders.push(createInflate({
|
|
flush: zlib.constants.Z_SYNC_FLUSH,
|
|
finishFlush: zlib.constants.Z_SYNC_FLUSH
|
|
}))
|
|
} else if (coding === 'br') {
|
|
decoders.push(zlib.createBrotliDecompress({
|
|
flush: zlib.constants.BROTLI_OPERATION_FLUSH,
|
|
finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH
|
|
}))
|
|
} else {
|
|
decoders.length = 0
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
const onError = this.onError.bind(this)
|
|
|
|
resolve({
|
|
status,
|
|
statusText,
|
|
headersList,
|
|
body: decoders.length
|
|
? pipeline(this.body, ...decoders, (err) => {
|
|
if (err) {
|
|
this.onError(err)
|
|
}
|
|
}).on('error', onError)
|
|
: this.body.on('error', onError)
|
|
})
|
|
|
|
return true
|
|
},
|
|
|
|
onData (chunk) {
|
|
if (fetchParams.controller.dump) {
|
|
return
|
|
}
|
|
|
|
// 1. If one or more bytes have been transmitted from response’s
|
|
// message body, then:
|
|
|
|
// 1. Let bytes be the transmitted bytes.
|
|
const bytes = chunk
|
|
|
|
// 2. Let codings be the result of extracting header list values
|
|
// given `Content-Encoding` and response’s header list.
|
|
// See pullAlgorithm.
|
|
|
|
// 3. Increase timingInfo’s encoded body size by bytes’s length.
|
|
timingInfo.encodedBodySize += bytes.byteLength
|
|
|
|
// 4. See pullAlgorithm...
|
|
|
|
return this.body.push(bytes)
|
|
},
|
|
|
|
onComplete () {
|
|
if (this.abort) {
|
|
fetchParams.controller.off('terminated', this.abort)
|
|
}
|
|
|
|
if (fetchParams.controller.onAborted) {
|
|
fetchParams.controller.off('terminated', fetchParams.controller.onAborted)
|
|
}
|
|
|
|
fetchParams.controller.ended = true
|
|
|
|
this.body.push(null)
|
|
},
|
|
|
|
onError (error) {
|
|
if (this.abort) {
|
|
fetchParams.controller.off('terminated', this.abort)
|
|
}
|
|
|
|
this.body?.destroy(error)
|
|
|
|
fetchParams.controller.terminate(error)
|
|
|
|
reject(error)
|
|
},
|
|
|
|
onUpgrade (status, rawHeaders, socket) {
|
|
if (status !== 101) {
|
|
return
|
|
}
|
|
|
|
const headersList = new HeadersList()
|
|
|
|
for (let i = 0; i < rawHeaders.length; i += 2) {
|
|
headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString('latin1'), true)
|
|
}
|
|
|
|
resolve({
|
|
status,
|
|
statusText: STATUS_CODES[status],
|
|
headersList,
|
|
socket
|
|
})
|
|
|
|
return true
|
|
}
|
|
}
|
|
))
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
fetch,
|
|
Fetch,
|
|
fetching,
|
|
finalizeAndReportTiming
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9967:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
/* globals AbortController */
|
|
|
|
|
|
|
|
const { extractBody, mixinBody, cloneBody, bodyUnusable } = __nccwpck_require__(4492)
|
|
const { Headers, fill: fillHeaders, HeadersList, setHeadersGuard, getHeadersGuard, setHeadersList, getHeadersList } = __nccwpck_require__(660)
|
|
const { FinalizationRegistry } = __nccwpck_require__(6653)()
|
|
const util = __nccwpck_require__(3440)
|
|
const nodeUtil = __nccwpck_require__(7975)
|
|
const {
|
|
isValidHTTPToken,
|
|
sameOrigin,
|
|
environmentSettingsObject
|
|
} = __nccwpck_require__(3168)
|
|
const {
|
|
forbiddenMethodsSet,
|
|
corsSafeListedMethodsSet,
|
|
referrerPolicy,
|
|
requestRedirect,
|
|
requestMode,
|
|
requestCredentials,
|
|
requestCache,
|
|
requestDuplex
|
|
} = __nccwpck_require__(4495)
|
|
const { kEnumerableProperty, normalizedMethodRecordsBase, normalizedMethodRecords } = util
|
|
const { kHeaders, kSignal, kState, kDispatcher } = __nccwpck_require__(3627)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const { URLSerializer } = __nccwpck_require__(1900)
|
|
const { kConstruct } = __nccwpck_require__(6443)
|
|
const assert = __nccwpck_require__(4589)
|
|
const { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = __nccwpck_require__(8474)
|
|
|
|
const kAbortController = Symbol('abortController')
|
|
|
|
const requestFinalizer = new FinalizationRegistry(({ signal, abort }) => {
|
|
signal.removeEventListener('abort', abort)
|
|
})
|
|
|
|
const dependentControllerMap = new WeakMap()
|
|
|
|
function buildAbort (acRef) {
|
|
return abort
|
|
|
|
function abort () {
|
|
const ac = acRef.deref()
|
|
if (ac !== undefined) {
|
|
// Currently, there is a problem with FinalizationRegistry.
|
|
// https://github.com/nodejs/node/issues/49344
|
|
// https://github.com/nodejs/node/issues/47748
|
|
// In the case of abort, the first step is to unregister from it.
|
|
// If the controller can refer to it, it is still registered.
|
|
// It will be removed in the future.
|
|
requestFinalizer.unregister(abort)
|
|
|
|
// Unsubscribe a listener.
|
|
// FinalizationRegistry will no longer be called, so this must be done.
|
|
this.removeEventListener('abort', abort)
|
|
|
|
ac.abort(this.reason)
|
|
|
|
const controllerList = dependentControllerMap.get(ac.signal)
|
|
|
|
if (controllerList !== undefined) {
|
|
if (controllerList.size !== 0) {
|
|
for (const ref of controllerList) {
|
|
const ctrl = ref.deref()
|
|
if (ctrl !== undefined) {
|
|
ctrl.abort(this.reason)
|
|
}
|
|
}
|
|
controllerList.clear()
|
|
}
|
|
dependentControllerMap.delete(ac.signal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let patchMethodWarning = false
|
|
|
|
// https://fetch.spec.whatwg.org/#request-class
|
|
class Request {
|
|
// https://fetch.spec.whatwg.org/#dom-request
|
|
constructor (input, init = {}) {
|
|
webidl.util.markAsUncloneable(this)
|
|
if (input === kConstruct) {
|
|
return
|
|
}
|
|
|
|
const prefix = 'Request constructor'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
input = webidl.converters.RequestInfo(input, prefix, 'input')
|
|
init = webidl.converters.RequestInit(init, prefix, 'init')
|
|
|
|
// 1. Let request be null.
|
|
let request = null
|
|
|
|
// 2. Let fallbackMode be null.
|
|
let fallbackMode = null
|
|
|
|
// 3. Let baseURL be this’s relevant settings object’s API base URL.
|
|
const baseUrl = environmentSettingsObject.settingsObject.baseUrl
|
|
|
|
// 4. Let signal be null.
|
|
let signal = null
|
|
|
|
// 5. If input is a string, then:
|
|
if (typeof input === 'string') {
|
|
this[kDispatcher] = init.dispatcher
|
|
|
|
// 1. Let parsedURL be the result of parsing input with baseURL.
|
|
// 2. If parsedURL is failure, then throw a TypeError.
|
|
let parsedURL
|
|
try {
|
|
parsedURL = new URL(input, baseUrl)
|
|
} catch (err) {
|
|
throw new TypeError('Failed to parse URL from ' + input, { cause: err })
|
|
}
|
|
|
|
// 3. If parsedURL includes credentials, then throw a TypeError.
|
|
if (parsedURL.username || parsedURL.password) {
|
|
throw new TypeError(
|
|
'Request cannot be constructed from a URL that includes credentials: ' +
|
|
input
|
|
)
|
|
}
|
|
|
|
// 4. Set request to a new request whose URL is parsedURL.
|
|
request = makeRequest({ urlList: [parsedURL] })
|
|
|
|
// 5. Set fallbackMode to "cors".
|
|
fallbackMode = 'cors'
|
|
} else {
|
|
this[kDispatcher] = init.dispatcher || input[kDispatcher]
|
|
|
|
// 6. Otherwise:
|
|
|
|
// 7. Assert: input is a Request object.
|
|
assert(input instanceof Request)
|
|
|
|
// 8. Set request to input’s request.
|
|
request = input[kState]
|
|
|
|
// 9. Set signal to input’s signal.
|
|
signal = input[kSignal]
|
|
}
|
|
|
|
// 7. Let origin be this’s relevant settings object’s origin.
|
|
const origin = environmentSettingsObject.settingsObject.origin
|
|
|
|
// 8. Let window be "client".
|
|
let window = 'client'
|
|
|
|
// 9. If request’s window is an environment settings object and its origin
|
|
// is same origin with origin, then set window to request’s window.
|
|
if (
|
|
request.window?.constructor?.name === 'EnvironmentSettingsObject' &&
|
|
sameOrigin(request.window, origin)
|
|
) {
|
|
window = request.window
|
|
}
|
|
|
|
// 10. If init["window"] exists and is non-null, then throw a TypeError.
|
|
if (init.window != null) {
|
|
throw new TypeError(`'window' option '${window}' must be null`)
|
|
}
|
|
|
|
// 11. If init["window"] exists, then set window to "no-window".
|
|
if ('window' in init) {
|
|
window = 'no-window'
|
|
}
|
|
|
|
// 12. Set request to a new request with the following properties:
|
|
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: environmentSettingsObject.settingsObject,
|
|
// window window.
|
|
window,
|
|
// priority request’s priority.
|
|
priority: request.priority,
|
|
// origin request’s origin. The propagation of the origin is only significant for navigation requests
|
|
// being handled by a service worker. In this scenario a request can have an origin that is different
|
|
// from the current client.
|
|
origin: request.origin,
|
|
// referrer request’s referrer.
|
|
referrer: request.referrer,
|
|
// referrer policy request’s referrer policy.
|
|
referrerPolicy: request.referrerPolicy,
|
|
// mode request’s mode.
|
|
mode: request.mode,
|
|
// credentials mode request’s credentials mode.
|
|
credentials: request.credentials,
|
|
// cache mode request’s cache mode.
|
|
cache: request.cache,
|
|
// redirect mode request’s redirect mode.
|
|
redirect: request.redirect,
|
|
// integrity metadata request’s integrity metadata.
|
|
integrity: request.integrity,
|
|
// keepalive request’s keepalive.
|
|
keepalive: request.keepalive,
|
|
// reload-navigation flag request’s reload-navigation flag.
|
|
reloadNavigation: request.reloadNavigation,
|
|
// history-navigation flag request’s history-navigation flag.
|
|
historyNavigation: request.historyNavigation,
|
|
// URL list A clone of request’s URL list.
|
|
urlList: [...request.urlList]
|
|
})
|
|
|
|
const initHasKey = Object.keys(init).length !== 0
|
|
|
|
// 13. If init is not empty, then:
|
|
if (initHasKey) {
|
|
// 1. If request’s mode is "navigate", then set it to "same-origin".
|
|
if (request.mode === 'navigate') {
|
|
request.mode = 'same-origin'
|
|
}
|
|
|
|
// 2. Unset request’s reload-navigation flag.
|
|
request.reloadNavigation = false
|
|
|
|
// 3. Unset request’s history-navigation flag.
|
|
request.historyNavigation = false
|
|
|
|
// 4. Set request’s origin to "client".
|
|
request.origin = 'client'
|
|
|
|
// 5. Set request’s referrer to "client"
|
|
request.referrer = 'client'
|
|
|
|
// 6. Set request’s referrer policy to the empty string.
|
|
request.referrerPolicy = ''
|
|
|
|
// 7. Set request’s URL to request’s current URL.
|
|
request.url = request.urlList[request.urlList.length - 1]
|
|
|
|
// 8. Set request’s URL list to « request’s URL ».
|
|
request.urlList = [request.url]
|
|
}
|
|
|
|
// 14. If init["referrer"] exists, then:
|
|
if (init.referrer !== undefined) {
|
|
// 1. Let referrer be init["referrer"].
|
|
const referrer = init.referrer
|
|
|
|
// 2. If referrer is the empty string, then set request’s referrer to "no-referrer".
|
|
if (referrer === '') {
|
|
request.referrer = 'no-referrer'
|
|
} else {
|
|
// 1. Let parsedReferrer be the result of parsing referrer with
|
|
// baseURL.
|
|
// 2. If parsedReferrer is failure, then throw a TypeError.
|
|
let parsedReferrer
|
|
try {
|
|
parsedReferrer = new URL(referrer, baseUrl)
|
|
} catch (err) {
|
|
throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err })
|
|
}
|
|
|
|
// 3. If one of the following is true
|
|
// - parsedReferrer’s scheme is "about" and path is the string "client"
|
|
// - parsedReferrer’s origin is not same origin with origin
|
|
// then set request’s referrer to "client".
|
|
if (
|
|
(parsedReferrer.protocol === 'about:' && parsedReferrer.hostname === 'client') ||
|
|
(origin && !sameOrigin(parsedReferrer, environmentSettingsObject.settingsObject.baseUrl))
|
|
) {
|
|
request.referrer = 'client'
|
|
} else {
|
|
// 4. Otherwise, set request’s referrer to parsedReferrer.
|
|
request.referrer = parsedReferrer
|
|
}
|
|
}
|
|
}
|
|
|
|
// 15. If init["referrerPolicy"] exists, then set request’s referrer policy
|
|
// to it.
|
|
if (init.referrerPolicy !== undefined) {
|
|
request.referrerPolicy = init.referrerPolicy
|
|
}
|
|
|
|
// 16. Let mode be init["mode"] if it exists, and fallbackMode otherwise.
|
|
let mode
|
|
if (init.mode !== undefined) {
|
|
mode = init.mode
|
|
} else {
|
|
mode = fallbackMode
|
|
}
|
|
|
|
// 17. If mode is "navigate", then throw a TypeError.
|
|
if (mode === 'navigate') {
|
|
throw webidl.errors.exception({
|
|
header: 'Request constructor',
|
|
message: 'invalid request mode navigate.'
|
|
})
|
|
}
|
|
|
|
// 18. If mode is non-null, set request’s mode to mode.
|
|
if (mode != null) {
|
|
request.mode = mode
|
|
}
|
|
|
|
// 19. If init["credentials"] exists, then set request’s credentials mode
|
|
// to it.
|
|
if (init.credentials !== undefined) {
|
|
request.credentials = init.credentials
|
|
}
|
|
|
|
// 18. If init["cache"] exists, then set request’s cache mode to it.
|
|
if (init.cache !== undefined) {
|
|
request.cache = init.cache
|
|
}
|
|
|
|
// 21. If request’s cache mode is "only-if-cached" and request’s mode is
|
|
// not "same-origin", then throw a TypeError.
|
|
if (request.cache === 'only-if-cached' && request.mode !== 'same-origin') {
|
|
throw new TypeError(
|
|
"'only-if-cached' can be set only with 'same-origin' mode"
|
|
)
|
|
}
|
|
|
|
// 22. If init["redirect"] exists, then set request’s redirect mode to it.
|
|
if (init.redirect !== undefined) {
|
|
request.redirect = init.redirect
|
|
}
|
|
|
|
// 23. If init["integrity"] exists, then set request’s integrity metadata to it.
|
|
if (init.integrity != null) {
|
|
request.integrity = String(init.integrity)
|
|
}
|
|
|
|
// 24. If init["keepalive"] exists, then set request’s keepalive to it.
|
|
if (init.keepalive !== undefined) {
|
|
request.keepalive = Boolean(init.keepalive)
|
|
}
|
|
|
|
// 25. If init["method"] exists, then:
|
|
if (init.method !== undefined) {
|
|
// 1. Let method be init["method"].
|
|
let method = init.method
|
|
|
|
const mayBeNormalized = normalizedMethodRecords[method]
|
|
|
|
if (mayBeNormalized !== undefined) {
|
|
// Note: Bypass validation DELETE, GET, HEAD, OPTIONS, POST, PUT, PATCH and these lowercase ones
|
|
request.method = mayBeNormalized
|
|
} else {
|
|
// 2. If method is not a method or method is a forbidden method, then
|
|
// throw a TypeError.
|
|
if (!isValidHTTPToken(method)) {
|
|
throw new TypeError(`'${method}' is not a valid HTTP method.`)
|
|
}
|
|
|
|
const upperCase = method.toUpperCase()
|
|
|
|
if (forbiddenMethodsSet.has(upperCase)) {
|
|
throw new TypeError(`'${method}' HTTP method is unsupported.`)
|
|
}
|
|
|
|
// 3. Normalize method.
|
|
// https://fetch.spec.whatwg.org/#concept-method-normalize
|
|
// Note: must be in uppercase
|
|
method = normalizedMethodRecordsBase[upperCase] ?? method
|
|
|
|
// 4. Set request’s method to method.
|
|
request.method = method
|
|
}
|
|
|
|
if (!patchMethodWarning && request.method === 'patch') {
|
|
process.emitWarning('Using `patch` is highly likely to result in a `405 Method Not Allowed`. `PATCH` is much more likely to succeed.', {
|
|
code: 'UNDICI-FETCH-patch'
|
|
})
|
|
|
|
patchMethodWarning = true
|
|
}
|
|
}
|
|
|
|
// 26. If init["signal"] exists, then set signal to it.
|
|
if (init.signal !== undefined) {
|
|
signal = init.signal
|
|
}
|
|
|
|
// 27. Set this’s request to request.
|
|
this[kState] = request
|
|
|
|
// 28. Set this’s signal to a new AbortSignal object with this’s relevant
|
|
// Realm.
|
|
// TODO: could this be simplified with AbortSignal.any
|
|
// (https://dom.spec.whatwg.org/#dom-abortsignal-any)
|
|
const ac = new AbortController()
|
|
this[kSignal] = ac.signal
|
|
|
|
// 29. If signal is not null, then make this’s signal follow signal.
|
|
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 {
|
|
// Keep a strong ref to ac while request object
|
|
// is alive. This is needed to prevent AbortController
|
|
// from being prematurely garbage collected.
|
|
// See, https://github.com/nodejs/undici/issues/1926.
|
|
this[kAbortController] = ac
|
|
|
|
const acRef = new WeakRef(ac)
|
|
const abort = buildAbort(acRef)
|
|
|
|
// Third-party AbortControllers may not work with these.
|
|
// See, https://github.com/nodejs/undici/pull/1910#issuecomment-1464495619.
|
|
try {
|
|
// If the max amount of listeners is equal to the default, increase it
|
|
// This is only available in node >= v19.9.0
|
|
if (typeof getMaxListeners === 'function' && getMaxListeners(signal) === defaultMaxListeners) {
|
|
setMaxListeners(1500, signal)
|
|
} else if (getEventListeners(signal, 'abort').length >= defaultMaxListeners) {
|
|
setMaxListeners(1500, signal)
|
|
}
|
|
} catch {}
|
|
|
|
util.addAbortListener(signal, abort)
|
|
// The third argument must be a registry key to be unregistered.
|
|
// Without it, you cannot unregister.
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
|
|
// abort is used as the unregister key. (because it is unique)
|
|
requestFinalizer.register(ac, { signal, abort }, abort)
|
|
}
|
|
}
|
|
|
|
// 30. Set this’s headers to a new Headers object with this’s relevant
|
|
// Realm, whose header list is request’s header list and guard is
|
|
// "request".
|
|
this[kHeaders] = new Headers(kConstruct)
|
|
setHeadersList(this[kHeaders], request.headersList)
|
|
setHeadersGuard(this[kHeaders], 'request')
|
|
|
|
// 31. If this’s request’s mode is "no-cors", then:
|
|
if (mode === 'no-cors') {
|
|
// 1. If this’s request’s method is not a CORS-safelisted method,
|
|
// then throw a TypeError.
|
|
if (!corsSafeListedMethodsSet.has(request.method)) {
|
|
throw new TypeError(
|
|
`'${request.method} is unsupported in no-cors mode.`
|
|
)
|
|
}
|
|
|
|
// 2. Set this’s headers’s guard to "request-no-cors".
|
|
setHeadersGuard(this[kHeaders], 'request-no-cors')
|
|
}
|
|
|
|
// 32. If init is not empty, then:
|
|
if (initHasKey) {
|
|
/** @type {HeadersList} */
|
|
const headersList = getHeadersList(this[kHeaders])
|
|
// 1. Let headers be a copy of this’s headers and its associated header
|
|
// list.
|
|
// 2. If init["headers"] exists, then set headers to init["headers"].
|
|
const headers = init.headers !== undefined ? init.headers : new HeadersList(headersList)
|
|
|
|
// 3. Empty this’s headers’s header list.
|
|
headersList.clear()
|
|
|
|
// 4. If headers is a Headers object, then for each header in its header
|
|
// list, append header’s name/header’s value to this’s headers.
|
|
if (headers instanceof HeadersList) {
|
|
for (const { name, value } of headers.rawValues()) {
|
|
headersList.append(name, value, false)
|
|
}
|
|
// Note: Copy the `set-cookie` meta-data.
|
|
headersList.cookies = headers.cookies
|
|
} else {
|
|
// 5. Otherwise, fill this’s headers with headers.
|
|
fillHeaders(this[kHeaders], headers)
|
|
}
|
|
}
|
|
|
|
// 33. Let inputBody be input’s request’s body if input is a Request
|
|
// object; otherwise null.
|
|
const inputBody = input instanceof Request ? input[kState].body : null
|
|
|
|
// 34. If either init["body"] exists and is non-null or inputBody is
|
|
// non-null, and request’s method is `GET` or `HEAD`, then throw a
|
|
// TypeError.
|
|
if (
|
|
(init.body != null || inputBody != null) &&
|
|
(request.method === 'GET' || request.method === 'HEAD')
|
|
) {
|
|
throw new TypeError('Request with GET/HEAD method cannot have body.')
|
|
}
|
|
|
|
// 35. Let initBody be null.
|
|
let initBody = null
|
|
|
|
// 36. If init["body"] exists and is non-null, then:
|
|
if (init.body != null) {
|
|
// 1. Let Content-Type be null.
|
|
// 2. Set initBody and Content-Type to the result of extracting
|
|
// init["body"], with keepalive set to request’s keepalive.
|
|
const [extractedBody, contentType] = extractBody(
|
|
init.body,
|
|
request.keepalive
|
|
)
|
|
initBody = extractedBody
|
|
|
|
// 3, If Content-Type is non-null and this’s headers’s header list does
|
|
// not contain `Content-Type`, then append `Content-Type`/Content-Type to
|
|
// this’s headers.
|
|
if (contentType && !getHeadersList(this[kHeaders]).contains('content-type', true)) {
|
|
this[kHeaders].append('content-type', contentType)
|
|
}
|
|
}
|
|
|
|
// 37. Let inputOrInitBody be initBody if it is non-null; otherwise
|
|
// inputBody.
|
|
const inputOrInitBody = initBody ?? inputBody
|
|
|
|
// 38. If inputOrInitBody is non-null and inputOrInitBody’s source is
|
|
// null, then:
|
|
if (inputOrInitBody != null && inputOrInitBody.source == null) {
|
|
// 1. If initBody is non-null and init["duplex"] does not exist,
|
|
// then throw a TypeError.
|
|
if (initBody != null && init.duplex == null) {
|
|
throw new TypeError('RequestInit: duplex option is required when sending a body.')
|
|
}
|
|
|
|
// 2. If this’s request’s mode is neither "same-origin" nor "cors",
|
|
// then throw a TypeError.
|
|
if (request.mode !== 'same-origin' && request.mode !== 'cors') {
|
|
throw new TypeError(
|
|
'If request is made from ReadableStream, mode should be "same-origin" or "cors"'
|
|
)
|
|
}
|
|
|
|
// 3. Set this’s request’s use-CORS-preflight flag.
|
|
request.useCORSPreflightFlag = true
|
|
}
|
|
|
|
// 39. Let finalBody be inputOrInitBody.
|
|
let finalBody = inputOrInitBody
|
|
|
|
// 40. If initBody is null and inputBody is non-null, then:
|
|
if (initBody == null && inputBody != null) {
|
|
// 1. If input is unusable, then throw a TypeError.
|
|
if (bodyUnusable(input)) {
|
|
throw new TypeError(
|
|
'Cannot construct a Request with a Request object that has already been used.'
|
|
)
|
|
}
|
|
|
|
// 2. Set finalBody to the result of creating a proxy for inputBody.
|
|
// https://streams.spec.whatwg.org/#readablestream-create-a-proxy
|
|
const identityTransform = new TransformStream()
|
|
inputBody.stream.pipeThrough(identityTransform)
|
|
finalBody = {
|
|
source: inputBody.source,
|
|
length: inputBody.length,
|
|
stream: identityTransform.readable
|
|
}
|
|
}
|
|
|
|
// 41. Set this’s request’s body to finalBody.
|
|
this[kState].body = finalBody
|
|
}
|
|
|
|
// Returns request’s HTTP method, which is "GET" by default.
|
|
get method () {
|
|
webidl.brandCheck(this, Request)
|
|
|
|
// The method getter steps are to return this’s request’s method.
|
|
return this[kState].method
|
|
}
|
|
|
|
// Returns the URL of request as a string.
|
|
get url () {
|
|
webidl.brandCheck(this, Request)
|
|
|
|
// The url getter steps are to return this’s request’s URL, serialized.
|
|
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)
|
|
|
|
// The headers getter steps are to return this’s headers.
|
|
return this[kHeaders]
|
|
}
|
|
|
|
// Returns the kind of resource requested by request, e.g., "document"
|
|
// or "script".
|
|
get destination () {
|
|
webidl.brandCheck(this, Request)
|
|
|
|
// The destination getter are to return this’s request’s destination.
|
|
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)
|
|
|
|
// 1. If this’s request’s referrer is "no-referrer", then return the
|
|
// empty string.
|
|
if (this[kState].referrer === 'no-referrer') {
|
|
return ''
|
|
}
|
|
|
|
// 2. If this’s request’s referrer is "client", then return
|
|
// "about:client".
|
|
if (this[kState].referrer === 'client') {
|
|
return 'about:client'
|
|
}
|
|
|
|
// Return this’s request’s referrer, serialized.
|
|
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)
|
|
|
|
// The referrerPolicy getter steps are to return this’s request’s referrer policy.
|
|
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)
|
|
|
|
// The mode getter steps are to return this’s request’s mode.
|
|
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 () {
|
|
// The credentials getter steps are to return this’s request’s credentials mode.
|
|
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)
|
|
|
|
// The cache getter steps are to return this’s request’s cache mode.
|
|
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)
|
|
|
|
// The redirect getter steps are to return this’s request’s redirect mode.
|
|
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)
|
|
|
|
// The integrity getter steps are to return this’s request’s integrity
|
|
// metadata.
|
|
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)
|
|
|
|
// The keepalive getter steps are to return this’s request’s keepalive.
|
|
return this[kState].keepalive
|
|
}
|
|
|
|
// Returns a boolean indicating whether or not request is for a reload
|
|
// navigation.
|
|
get isReloadNavigation () {
|
|
webidl.brandCheck(this, Request)
|
|
|
|
// The isReloadNavigation getter steps are to return true if this’s
|
|
// request’s reload-navigation flag is set; otherwise false.
|
|
return this[kState].reloadNavigation
|
|
}
|
|
|
|
// Returns a boolean indicating whether or not request is for a history
|
|
// navigation (a.k.a. back-forward navigation).
|
|
get isHistoryNavigation () {
|
|
webidl.brandCheck(this, Request)
|
|
|
|
// The isHistoryNavigation getter steps are to return true if this’s request’s
|
|
// history-navigation flag is set; otherwise false.
|
|
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)
|
|
|
|
// The signal getter steps are to return this’s signal.
|
|
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)
|
|
|
|
// 1. If this is unusable, then throw a TypeError.
|
|
if (bodyUnusable(this)) {
|
|
throw new TypeError('unusable')
|
|
}
|
|
|
|
// 2. Let clonedRequest be the result of cloning this’s request.
|
|
const clonedRequest = cloneRequest(this[kState])
|
|
|
|
// 3. Let clonedRequestObject be the result of creating a Request object,
|
|
// given clonedRequest, this’s headers’s guard, and this’s relevant Realm.
|
|
// 4. Make clonedRequestObject’s signal follow this’s signal.
|
|
const ac = new AbortController()
|
|
if (this.signal.aborted) {
|
|
ac.abort(this.signal.reason)
|
|
} else {
|
|
let list = dependentControllerMap.get(this.signal)
|
|
if (list === undefined) {
|
|
list = new Set()
|
|
dependentControllerMap.set(this.signal, list)
|
|
}
|
|
const acRef = new WeakRef(ac)
|
|
list.add(acRef)
|
|
util.addAbortListener(
|
|
ac.signal,
|
|
buildAbort(acRef)
|
|
)
|
|
}
|
|
|
|
// 4. Return clonedRequestObject.
|
|
return fromInnerRequest(clonedRequest, ac.signal, getHeadersGuard(this[kHeaders]))
|
|
}
|
|
|
|
[nodeUtil.inspect.custom] (depth, options) {
|
|
if (options.depth === null) {
|
|
options.depth = 2
|
|
}
|
|
|
|
options.colors ??= true
|
|
|
|
const properties = {
|
|
method: this.method,
|
|
url: this.url,
|
|
headers: this.headers,
|
|
destination: this.destination,
|
|
referrer: this.referrer,
|
|
referrerPolicy: this.referrerPolicy,
|
|
mode: this.mode,
|
|
credentials: this.credentials,
|
|
cache: this.cache,
|
|
redirect: this.redirect,
|
|
integrity: this.integrity,
|
|
keepalive: this.keepalive,
|
|
isReloadNavigation: this.isReloadNavigation,
|
|
isHistoryNavigation: this.isHistoryNavigation,
|
|
signal: this.signal
|
|
}
|
|
|
|
return `Request ${nodeUtil.formatWithOptions(options, properties)}`
|
|
}
|
|
}
|
|
|
|
mixinBody(Request)
|
|
|
|
// https://fetch.spec.whatwg.org/#requests
|
|
function makeRequest (init) {
|
|
return {
|
|
method: init.method ?? 'GET',
|
|
localURLsOnly: init.localURLsOnly ?? false,
|
|
unsafeRequest: init.unsafeRequest ?? false,
|
|
body: init.body ?? null,
|
|
client: init.client ?? null,
|
|
reservedClient: init.reservedClient ?? null,
|
|
replacesClientId: init.replacesClientId ?? '',
|
|
window: init.window ?? 'client',
|
|
keepalive: init.keepalive ?? false,
|
|
serviceWorkers: init.serviceWorkers ?? 'all',
|
|
initiator: init.initiator ?? '',
|
|
destination: init.destination ?? '',
|
|
priority: init.priority ?? null,
|
|
origin: init.origin ?? 'client',
|
|
policyContainer: init.policyContainer ?? 'client',
|
|
referrer: init.referrer ?? 'client',
|
|
referrerPolicy: init.referrerPolicy ?? '',
|
|
mode: init.mode ?? 'no-cors',
|
|
useCORSPreflightFlag: init.useCORSPreflightFlag ?? false,
|
|
credentials: init.credentials ?? 'same-origin',
|
|
useCredentials: init.useCredentials ?? false,
|
|
cache: init.cache ?? 'default',
|
|
redirect: init.redirect ?? 'follow',
|
|
integrity: init.integrity ?? '',
|
|
cryptoGraphicsNonceMetadata: init.cryptoGraphicsNonceMetadata ?? '',
|
|
parserMetadata: init.parserMetadata ?? '',
|
|
reloadNavigation: init.reloadNavigation ?? false,
|
|
historyNavigation: init.historyNavigation ?? false,
|
|
userActivation: init.userActivation ?? false,
|
|
taintedOrigin: init.taintedOrigin ?? false,
|
|
redirectCount: init.redirectCount ?? 0,
|
|
responseTainting: init.responseTainting ?? 'basic',
|
|
preventNoCacheCacheControlHeaderModification: init.preventNoCacheCacheControlHeaderModification ?? false,
|
|
done: init.done ?? false,
|
|
timingAllowFailed: init.timingAllowFailed ?? false,
|
|
urlList: init.urlList,
|
|
url: init.urlList[0],
|
|
headersList: init.headersList
|
|
? new HeadersList(init.headersList)
|
|
: new HeadersList()
|
|
}
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#concept-request-clone
|
|
function cloneRequest (request) {
|
|
// To clone a request request, run these steps:
|
|
|
|
// 1. Let newRequest be a copy of request, except for its body.
|
|
const newRequest = makeRequest({ ...request, body: null })
|
|
|
|
// 2. If request’s body is non-null, set newRequest’s body to the
|
|
// result of cloning request’s body.
|
|
if (request.body != null) {
|
|
newRequest.body = cloneBody(newRequest, request.body)
|
|
}
|
|
|
|
// 3. Return newRequest.
|
|
return newRequest
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#request-create
|
|
* @param {any} innerRequest
|
|
* @param {AbortSignal} signal
|
|
* @param {'request' | 'immutable' | 'request-no-cors' | 'response' | 'none'} guard
|
|
* @returns {Request}
|
|
*/
|
|
function fromInnerRequest (innerRequest, signal, guard) {
|
|
const request = new Request(kConstruct)
|
|
request[kState] = innerRequest
|
|
request[kSignal] = signal
|
|
request[kHeaders] = new Headers(kConstruct)
|
|
setHeadersList(request[kHeaders], innerRequest.headersList)
|
|
setHeadersGuard(request[kHeaders], guard)
|
|
return request
|
|
}
|
|
|
|
Object.defineProperties(Request.prototype, {
|
|
method: kEnumerableProperty,
|
|
url: kEnumerableProperty,
|
|
headers: kEnumerableProperty,
|
|
redirect: kEnumerableProperty,
|
|
clone: kEnumerableProperty,
|
|
signal: kEnumerableProperty,
|
|
duplex: kEnumerableProperty,
|
|
destination: kEnumerableProperty,
|
|
body: kEnumerableProperty,
|
|
bodyUsed: kEnumerableProperty,
|
|
isHistoryNavigation: kEnumerableProperty,
|
|
isReloadNavigation: kEnumerableProperty,
|
|
keepalive: kEnumerableProperty,
|
|
integrity: kEnumerableProperty,
|
|
cache: kEnumerableProperty,
|
|
credentials: kEnumerableProperty,
|
|
attribute: kEnumerableProperty,
|
|
referrerPolicy: kEnumerableProperty,
|
|
referrer: kEnumerableProperty,
|
|
mode: kEnumerableProperty,
|
|
[Symbol.toStringTag]: {
|
|
value: 'Request',
|
|
configurable: true
|
|
}
|
|
})
|
|
|
|
webidl.converters.Request = webidl.interfaceConverter(
|
|
Request
|
|
)
|
|
|
|
// https://fetch.spec.whatwg.org/#requestinfo
|
|
webidl.converters.RequestInfo = function (V, prefix, argument) {
|
|
if (typeof V === 'string') {
|
|
return webidl.converters.USVString(V, prefix, argument)
|
|
}
|
|
|
|
if (V instanceof Request) {
|
|
return webidl.converters.Request(V, prefix, argument)
|
|
}
|
|
|
|
return webidl.converters.USVString(V, prefix, argument)
|
|
}
|
|
|
|
webidl.converters.AbortSignal = webidl.interfaceConverter(
|
|
AbortSignal
|
|
)
|
|
|
|
// https://fetch.spec.whatwg.org/#requestinit
|
|
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,
|
|
'RequestInit',
|
|
'signal',
|
|
{ strict: false }
|
|
)
|
|
)
|
|
},
|
|
{
|
|
key: 'window',
|
|
converter: webidl.converters.any
|
|
},
|
|
{
|
|
key: 'duplex',
|
|
converter: webidl.converters.DOMString,
|
|
allowedValues: requestDuplex
|
|
},
|
|
{
|
|
key: 'dispatcher', // undici specific option
|
|
converter: webidl.converters.any
|
|
}
|
|
])
|
|
|
|
module.exports = { Request, makeRequest, fromInnerRequest, cloneRequest }
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9051:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { Headers, HeadersList, fill, getHeadersGuard, setHeadersGuard, setHeadersList } = __nccwpck_require__(660)
|
|
const { extractBody, cloneBody, mixinBody, hasFinalizationRegistry, streamRegistry, bodyUnusable } = __nccwpck_require__(4492)
|
|
const util = __nccwpck_require__(3440)
|
|
const nodeUtil = __nccwpck_require__(7975)
|
|
const { kEnumerableProperty } = util
|
|
const {
|
|
isValidReasonPhrase,
|
|
isCancelled,
|
|
isAborted,
|
|
isBlobLike,
|
|
serializeJavascriptValueToJSONString,
|
|
isErrorLike,
|
|
isomorphicEncode,
|
|
environmentSettingsObject: relevantRealm
|
|
} = __nccwpck_require__(3168)
|
|
const {
|
|
redirectStatusSet,
|
|
nullBodyStatus
|
|
} = __nccwpck_require__(4495)
|
|
const { kState, kHeaders } = __nccwpck_require__(3627)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const { FormData } = __nccwpck_require__(5910)
|
|
const { URLSerializer } = __nccwpck_require__(1900)
|
|
const { kConstruct } = __nccwpck_require__(6443)
|
|
const assert = __nccwpck_require__(4589)
|
|
const { types } = __nccwpck_require__(7975)
|
|
|
|
const textEncoder = new TextEncoder('utf-8')
|
|
|
|
// https://fetch.spec.whatwg.org/#response-class
|
|
class Response {
|
|
// Creates network error Response.
|
|
static error () {
|
|
// The static error() method steps are to return the result of creating a
|
|
// Response object, given a new network error, "immutable", and this’s
|
|
// relevant Realm.
|
|
const responseObject = fromInnerResponse(makeNetworkError(), 'immutable')
|
|
|
|
return responseObject
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#dom-response-json
|
|
static json (data, init = {}) {
|
|
webidl.argumentLengthCheck(arguments, 1, 'Response.json')
|
|
|
|
if (init !== null) {
|
|
init = webidl.converters.ResponseInit(init)
|
|
}
|
|
|
|
// 1. Let bytes the result of running serialize a JavaScript value to JSON bytes on data.
|
|
const bytes = textEncoder.encode(
|
|
serializeJavascriptValueToJSONString(data)
|
|
)
|
|
|
|
// 2. Let body be the result of extracting bytes.
|
|
const body = extractBody(bytes)
|
|
|
|
// 3. Let responseObject be the result of creating a Response object, given a new response,
|
|
// "response", and this’s relevant Realm.
|
|
const responseObject = fromInnerResponse(makeResponse({}), 'response')
|
|
|
|
// 4. Perform initialize a response given responseObject, init, and (body, "application/json").
|
|
initializeResponse(responseObject, init, { body: body[0], type: 'application/json' })
|
|
|
|
// 5. Return responseObject.
|
|
return responseObject
|
|
}
|
|
|
|
// Creates a redirect Response that redirects to url with status status.
|
|
static redirect (url, status = 302) {
|
|
webidl.argumentLengthCheck(arguments, 1, 'Response.redirect')
|
|
|
|
url = webidl.converters.USVString(url)
|
|
status = webidl.converters['unsigned short'](status)
|
|
|
|
// 1. Let parsedURL be the result of parsing url with current settings
|
|
// object’s API base URL.
|
|
// 2. If parsedURL is failure, then throw a TypeError.
|
|
// TODO: base-URL?
|
|
let parsedURL
|
|
try {
|
|
parsedURL = new URL(url, relevantRealm.settingsObject.baseUrl)
|
|
} catch (err) {
|
|
throw new TypeError(`Failed to parse URL from ${url}`, { cause: err })
|
|
}
|
|
|
|
// 3. If status is not a redirect status, then throw a RangeError.
|
|
if (!redirectStatusSet.has(status)) {
|
|
throw new RangeError(`Invalid status code ${status}`)
|
|
}
|
|
|
|
// 4. Let responseObject be the result of creating a Response object,
|
|
// given a new response, "immutable", and this’s relevant Realm.
|
|
const responseObject = fromInnerResponse(makeResponse({}), 'immutable')
|
|
|
|
// 5. Set responseObject’s response’s status to status.
|
|
responseObject[kState].status = status
|
|
|
|
// 6. Let value be parsedURL, serialized and isomorphic encoded.
|
|
const value = isomorphicEncode(URLSerializer(parsedURL))
|
|
|
|
// 7. Append `Location`/value to responseObject’s response’s header list.
|
|
responseObject[kState].headersList.append('location', value, true)
|
|
|
|
// 8. Return responseObject.
|
|
return responseObject
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#dom-response
|
|
constructor (body = null, init = {}) {
|
|
webidl.util.markAsUncloneable(this)
|
|
if (body === kConstruct) {
|
|
return
|
|
}
|
|
|
|
if (body !== null) {
|
|
body = webidl.converters.BodyInit(body)
|
|
}
|
|
|
|
init = webidl.converters.ResponseInit(init)
|
|
|
|
// 1. Set this’s response to a new response.
|
|
this[kState] = makeResponse({})
|
|
|
|
// 2. Set this’s headers to a new Headers object with this’s relevant
|
|
// Realm, whose header list is this’s response’s header list and guard
|
|
// is "response".
|
|
this[kHeaders] = new Headers(kConstruct)
|
|
setHeadersGuard(this[kHeaders], 'response')
|
|
setHeadersList(this[kHeaders], this[kState].headersList)
|
|
|
|
// 3. Let bodyWithType be null.
|
|
let bodyWithType = null
|
|
|
|
// 4. If body is non-null, then set bodyWithType to the result of extracting body.
|
|
if (body != null) {
|
|
const [extractedBody, type] = extractBody(body)
|
|
bodyWithType = { body: extractedBody, type }
|
|
}
|
|
|
|
// 5. Perform initialize a response given this, init, and bodyWithType.
|
|
initializeResponse(this, init, bodyWithType)
|
|
}
|
|
|
|
// Returns response’s type, e.g., "cors".
|
|
get type () {
|
|
webidl.brandCheck(this, Response)
|
|
|
|
// The type getter steps are to return this’s response’s type.
|
|
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
|
|
|
|
// The url getter steps are to return the empty string if this’s
|
|
// response’s URL is null; otherwise this’s response’s URL,
|
|
// serialized with exclude fragment set to true.
|
|
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)
|
|
|
|
// The redirected getter steps are to return true if this’s response’s URL
|
|
// list has more than one item; otherwise false.
|
|
return this[kState].urlList.length > 1
|
|
}
|
|
|
|
// Returns response’s status.
|
|
get status () {
|
|
webidl.brandCheck(this, Response)
|
|
|
|
// The status getter steps are to return this’s response’s status.
|
|
return this[kState].status
|
|
}
|
|
|
|
// Returns whether response’s status is an ok status.
|
|
get ok () {
|
|
webidl.brandCheck(this, Response)
|
|
|
|
// The ok getter steps are to return true if this’s response’s status is an
|
|
// ok status; otherwise false.
|
|
return this[kState].status >= 200 && this[kState].status <= 299
|
|
}
|
|
|
|
// Returns response’s status message.
|
|
get statusText () {
|
|
webidl.brandCheck(this, Response)
|
|
|
|
// The statusText getter steps are to return this’s response’s status
|
|
// message.
|
|
return this[kState].statusText
|
|
}
|
|
|
|
// Returns response’s headers as Headers.
|
|
get headers () {
|
|
webidl.brandCheck(this, Response)
|
|
|
|
// The headers getter steps are to return this’s headers.
|
|
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)
|
|
|
|
// 1. If this is unusable, then throw a TypeError.
|
|
if (bodyUnusable(this)) {
|
|
throw webidl.errors.exception({
|
|
header: 'Response.clone',
|
|
message: 'Body has already been consumed.'
|
|
})
|
|
}
|
|
|
|
// 2. Let clonedResponse be the result of cloning this’s response.
|
|
const clonedResponse = cloneResponse(this[kState])
|
|
|
|
// Note: To re-register because of a new stream.
|
|
if (hasFinalizationRegistry && this[kState].body?.stream) {
|
|
streamRegistry.register(this, new WeakRef(this[kState].body.stream))
|
|
}
|
|
|
|
// 3. Return the result of creating a Response object, given
|
|
// clonedResponse, this’s headers’s guard, and this’s relevant Realm.
|
|
return fromInnerResponse(clonedResponse, getHeadersGuard(this[kHeaders]))
|
|
}
|
|
|
|
[nodeUtil.inspect.custom] (depth, options) {
|
|
if (options.depth === null) {
|
|
options.depth = 2
|
|
}
|
|
|
|
options.colors ??= true
|
|
|
|
const properties = {
|
|
status: this.status,
|
|
statusText: this.statusText,
|
|
headers: this.headers,
|
|
body: this.body,
|
|
bodyUsed: this.bodyUsed,
|
|
ok: this.ok,
|
|
redirected: this.redirected,
|
|
type: this.type,
|
|
url: this.url
|
|
}
|
|
|
|
return `Response ${nodeUtil.formatWithOptions(options, properties)}`
|
|
}
|
|
}
|
|
|
|
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
|
|
})
|
|
|
|
// https://fetch.spec.whatwg.org/#concept-response-clone
|
|
function cloneResponse (response) {
|
|
// To clone a response response, run these steps:
|
|
|
|
// 1. If response is a filtered response, then return a new identical
|
|
// filtered response whose internal response is a clone of response’s
|
|
// internal response.
|
|
if (response.internalResponse) {
|
|
return filterResponse(
|
|
cloneResponse(response.internalResponse),
|
|
response.type
|
|
)
|
|
}
|
|
|
|
// 2. Let newResponse be a copy of response, except for its body.
|
|
const newResponse = makeResponse({ ...response, body: null })
|
|
|
|
// 3. If response’s body is non-null, then set newResponse’s body to the
|
|
// result of cloning response’s body.
|
|
if (response.body != null) {
|
|
newResponse.body = cloneBody(newResponse, response.body)
|
|
}
|
|
|
|
// 4. Return newResponse.
|
|
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),
|
|
aborted: reason && reason.name === 'AbortError'
|
|
})
|
|
}
|
|
|
|
// @see https://fetch.spec.whatwg.org/#concept-network-error
|
|
function isNetworkError (response) {
|
|
return (
|
|
// A network error is a response whose type is "error",
|
|
response.type === 'error' &&
|
|
// status is 0
|
|
response.status === 0
|
|
)
|
|
}
|
|
|
|
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
|
|
}
|
|
})
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#concept-filtered-response
|
|
function filterResponse (response, type) {
|
|
// Set response to the following filtered response with response as its
|
|
// internal response, depending on request’s response tainting:
|
|
if (type === 'basic') {
|
|
// A basic filtered response is a filtered response whose type is "basic"
|
|
// and header list excludes any headers in internal response’s header list
|
|
// whose name is a forbidden response-header name.
|
|
|
|
// Note: undici does not implement forbidden response-header names
|
|
return makeFilteredResponse(response, {
|
|
type: 'basic',
|
|
headersList: response.headersList
|
|
})
|
|
} else if (type === 'cors') {
|
|
// A CORS filtered response is a filtered response whose type is "cors"
|
|
// and header list excludes any headers in internal response’s header
|
|
// list whose name is not a CORS-safelisted response-header name, given
|
|
// internal response’s CORS-exposed header-name list.
|
|
|
|
// Note: undici does not implement CORS-safelisted response-header names
|
|
return makeFilteredResponse(response, {
|
|
type: 'cors',
|
|
headersList: response.headersList
|
|
})
|
|
} else if (type === 'opaque') {
|
|
// An opaque filtered response is a filtered response whose type is
|
|
// "opaque", URL list is the empty list, status is 0, status message
|
|
// is the empty byte sequence, header list is empty, and body is null.
|
|
|
|
return makeFilteredResponse(response, {
|
|
type: 'opaque',
|
|
urlList: Object.freeze([]),
|
|
status: 0,
|
|
statusText: '',
|
|
body: null
|
|
})
|
|
} else if (type === 'opaqueredirect') {
|
|
// An opaque-redirect filtered response is a filtered response whose type
|
|
// is "opaqueredirect", status is 0, status message is the empty byte
|
|
// sequence, header list is empty, and body is null.
|
|
|
|
return makeFilteredResponse(response, {
|
|
type: 'opaqueredirect',
|
|
status: 0,
|
|
statusText: '',
|
|
headersList: [],
|
|
body: null
|
|
})
|
|
} else {
|
|
assert(false)
|
|
}
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#appropriate-network-error
|
|
function makeAppropriateNetworkError (fetchParams, err = null) {
|
|
// 1. Assert: fetchParams is canceled.
|
|
assert(isCancelled(fetchParams))
|
|
|
|
// 2. Return an aborted network error if fetchParams is aborted;
|
|
// otherwise return a network error.
|
|
return isAborted(fetchParams)
|
|
? makeNetworkError(Object.assign(new DOMException('The operation was aborted.', 'AbortError'), { cause: err }))
|
|
: makeNetworkError(Object.assign(new DOMException('Request was cancelled.'), { cause: err }))
|
|
}
|
|
|
|
// https://whatpr.org/fetch/1392.html#initialize-a-response
|
|
function initializeResponse (response, init, body) {
|
|
// 1. If init["status"] is not in the range 200 to 599, inclusive, then
|
|
// throw a RangeError.
|
|
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.')
|
|
}
|
|
|
|
// 2. If init["statusText"] does not match the reason-phrase token production,
|
|
// then throw a TypeError.
|
|
if ('statusText' in init && init.statusText != null) {
|
|
// See, https://datatracker.ietf.org/doc/html/rfc7230#section-3.1.2:
|
|
// reason-phrase = *( HTAB / SP / VCHAR / obs-text )
|
|
if (!isValidReasonPhrase(String(init.statusText))) {
|
|
throw new TypeError('Invalid statusText')
|
|
}
|
|
}
|
|
|
|
// 3. Set response’s response’s status to init["status"].
|
|
if ('status' in init && init.status != null) {
|
|
response[kState].status = init.status
|
|
}
|
|
|
|
// 4. Set response’s response’s status message to init["statusText"].
|
|
if ('statusText' in init && init.statusText != null) {
|
|
response[kState].statusText = init.statusText
|
|
}
|
|
|
|
// 5. If init["headers"] exists, then fill response’s headers with init["headers"].
|
|
if ('headers' in init && init.headers != null) {
|
|
fill(response[kHeaders], init.headers)
|
|
}
|
|
|
|
// 6. If body was given, then:
|
|
if (body) {
|
|
// 1. If response's status is a null body status, then throw a TypeError.
|
|
if (nullBodyStatus.includes(response.status)) {
|
|
throw webidl.errors.exception({
|
|
header: 'Response constructor',
|
|
message: `Invalid response status code ${response.status}`
|
|
})
|
|
}
|
|
|
|
// 2. Set response's body to body's body.
|
|
response[kState].body = body.body
|
|
|
|
// 3. If body's type is non-null and response's header list does not contain
|
|
// `Content-Type`, then append (`Content-Type`, body's type) to response's header list.
|
|
if (body.type != null && !response[kState].headersList.contains('content-type', true)) {
|
|
response[kState].headersList.append('content-type', body.type, true)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#response-create
|
|
* @param {any} innerResponse
|
|
* @param {'request' | 'immutable' | 'request-no-cors' | 'response' | 'none'} guard
|
|
* @returns {Response}
|
|
*/
|
|
function fromInnerResponse (innerResponse, guard) {
|
|
const response = new Response(kConstruct)
|
|
response[kState] = innerResponse
|
|
response[kHeaders] = new Headers(kConstruct)
|
|
setHeadersList(response[kHeaders], innerResponse.headersList)
|
|
setHeadersGuard(response[kHeaders], guard)
|
|
|
|
if (hasFinalizationRegistry && innerResponse.body?.stream) {
|
|
// If the target (response) is reclaimed, the cleanup callback may be called at some point with
|
|
// the held value provided for it (innerResponse.body.stream). The held value can be any value:
|
|
// a primitive or an object, even undefined. If the held value is an object, the registry keeps
|
|
// a strong reference to it (so it can pass it to the cleanup callback later). Reworded from
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
|
|
streamRegistry.register(response, new WeakRef(innerResponse.body.stream))
|
|
}
|
|
|
|
return response
|
|
}
|
|
|
|
webidl.converters.ReadableStream = webidl.interfaceConverter(
|
|
ReadableStream
|
|
)
|
|
|
|
webidl.converters.FormData = webidl.interfaceConverter(
|
|
FormData
|
|
)
|
|
|
|
webidl.converters.URLSearchParams = webidl.interfaceConverter(
|
|
URLSearchParams
|
|
)
|
|
|
|
// https://fetch.spec.whatwg.org/#typedefdef-xmlhttprequestbodyinit
|
|
webidl.converters.XMLHttpRequestBodyInit = function (V, prefix, name) {
|
|
if (typeof V === 'string') {
|
|
return webidl.converters.USVString(V, prefix, name)
|
|
}
|
|
|
|
if (isBlobLike(V)) {
|
|
return webidl.converters.Blob(V, prefix, name, { strict: false })
|
|
}
|
|
|
|
if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
|
|
return webidl.converters.BufferSource(V, prefix, name)
|
|
}
|
|
|
|
if (util.isFormDataLike(V)) {
|
|
return webidl.converters.FormData(V, prefix, name, { strict: false })
|
|
}
|
|
|
|
if (V instanceof URLSearchParams) {
|
|
return webidl.converters.URLSearchParams(V, prefix, name)
|
|
}
|
|
|
|
return webidl.converters.DOMString(V, prefix, name)
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#bodyinit
|
|
webidl.converters.BodyInit = function (V, prefix, argument) {
|
|
if (V instanceof ReadableStream) {
|
|
return webidl.converters.ReadableStream(V, prefix, argument)
|
|
}
|
|
|
|
// Note: the spec doesn't include async iterables,
|
|
// this is an undici extension.
|
|
if (V?.[Symbol.asyncIterator]) {
|
|
return V
|
|
}
|
|
|
|
return webidl.converters.XMLHttpRequestBodyInit(V, prefix, argument)
|
|
}
|
|
|
|
webidl.converters.ResponseInit = webidl.dictionaryConverter([
|
|
{
|
|
key: 'status',
|
|
converter: webidl.converters['unsigned short'],
|
|
defaultValue: () => 200
|
|
},
|
|
{
|
|
key: 'statusText',
|
|
converter: webidl.converters.ByteString,
|
|
defaultValue: () => ''
|
|
},
|
|
{
|
|
key: 'headers',
|
|
converter: webidl.converters.HeadersInit
|
|
}
|
|
])
|
|
|
|
module.exports = {
|
|
isNetworkError,
|
|
makeNetworkError,
|
|
makeResponse,
|
|
makeAppropriateNetworkError,
|
|
filterResponse,
|
|
Response,
|
|
cloneResponse,
|
|
fromInnerResponse
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3627:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
module.exports = {
|
|
kUrl: Symbol('url'),
|
|
kHeaders: Symbol('headers'),
|
|
kSignal: Symbol('signal'),
|
|
kState: Symbol('state'),
|
|
kDispatcher: Symbol('dispatcher')
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3168:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { Transform } = __nccwpck_require__(7075)
|
|
const zlib = __nccwpck_require__(8522)
|
|
const { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = __nccwpck_require__(4495)
|
|
const { getGlobalOrigin } = __nccwpck_require__(1059)
|
|
const { collectASequenceOfCodePoints, collectAnHTTPQuotedString, removeChars, parseMIMEType } = __nccwpck_require__(1900)
|
|
const { performance } = __nccwpck_require__(643)
|
|
const { isBlobLike, ReadableStreamFrom, isValidHTTPToken, normalizedMethodRecordsBase } = __nccwpck_require__(3440)
|
|
const assert = __nccwpck_require__(4589)
|
|
const { isUint8Array } = __nccwpck_require__(3429)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
|
|
let supportedHashes = []
|
|
|
|
// https://nodejs.org/api/crypto.html#determining-if-crypto-support-is-unavailable
|
|
/** @type {import('crypto')} */
|
|
let crypto
|
|
try {
|
|
crypto = __nccwpck_require__(7598)
|
|
const possibleRelevantHashes = ['sha256', 'sha384', 'sha512']
|
|
supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash))
|
|
/* c8 ignore next 3 */
|
|
} catch {
|
|
|
|
}
|
|
|
|
function responseURL (response) {
|
|
// https://fetch.spec.whatwg.org/#responses
|
|
// A response has an associated URL. It is a pointer to the last URL
|
|
// in response’s URL list and null if response’s URL list is empty.
|
|
const urlList = response.urlList
|
|
const length = urlList.length
|
|
return length === 0 ? null : urlList[length - 1].toString()
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#concept-response-location-url
|
|
function responseLocationURL (response, requestFragment) {
|
|
// 1. If response’s status is not a redirect status, then return null.
|
|
if (!redirectStatusSet.has(response.status)) {
|
|
return null
|
|
}
|
|
|
|
// 2. Let location be the result of extracting header list values given
|
|
// `Location` and response’s header list.
|
|
let location = response.headersList.get('location', true)
|
|
|
|
// 3. If location is a header value, then set location to the result of
|
|
// parsing location with response’s URL.
|
|
if (location !== null && isValidHeaderValue(location)) {
|
|
if (!isValidEncodedURL(location)) {
|
|
// Some websites respond location header in UTF-8 form without encoding them as ASCII
|
|
// and major browsers redirect them to correctly UTF-8 encoded addresses.
|
|
// Here, we handle that behavior in the same way.
|
|
location = normalizeBinaryStringToUtf8(location)
|
|
}
|
|
location = new URL(location, responseURL(response))
|
|
}
|
|
|
|
// 4. If location is a URL whose fragment is null, then set location’s
|
|
// fragment to requestFragment.
|
|
if (location && !location.hash) {
|
|
location.hash = requestFragment
|
|
}
|
|
|
|
// 5. Return location.
|
|
return location
|
|
}
|
|
|
|
/**
|
|
* @see https://www.rfc-editor.org/rfc/rfc1738#section-2.2
|
|
* @param {string} url
|
|
* @returns {boolean}
|
|
*/
|
|
function isValidEncodedURL (url) {
|
|
for (let i = 0; i < url.length; ++i) {
|
|
const code = url.charCodeAt(i)
|
|
|
|
if (
|
|
code > 0x7E || // Non-US-ASCII + DEL
|
|
code < 0x20 // Control characters NUL - US
|
|
) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* If string contains non-ASCII characters, assumes it's UTF-8 encoded and decodes it.
|
|
* Since UTF-8 is a superset of ASCII, this will work for ASCII strings as well.
|
|
* @param {string} value
|
|
* @returns {string}
|
|
*/
|
|
function normalizeBinaryStringToUtf8 (value) {
|
|
return Buffer.from(value, 'binary').toString('utf8')
|
|
}
|
|
|
|
/** @returns {URL} */
|
|
function requestCurrentURL (request) {
|
|
return request.urlList[request.urlList.length - 1]
|
|
}
|
|
|
|
function requestBadPort (request) {
|
|
// 1. Let url be request’s current URL.
|
|
const url = requestCurrentURL(request)
|
|
|
|
// 2. If url’s scheme is an HTTP(S) scheme and url’s port is a bad port,
|
|
// then return blocked.
|
|
if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) {
|
|
return 'blocked'
|
|
}
|
|
|
|
// 3. Return allowed.
|
|
return 'allowed'
|
|
}
|
|
|
|
function isErrorLike (object) {
|
|
return object instanceof Error || (
|
|
object?.constructor?.name === 'Error' ||
|
|
object?.constructor?.name === 'DOMException'
|
|
)
|
|
}
|
|
|
|
// Check whether |statusText| is a ByteString and
|
|
// matches the Reason-Phrase token production.
|
|
// RFC 2616: https://tools.ietf.org/html/rfc2616
|
|
// RFC 7230: https://tools.ietf.org/html/rfc7230
|
|
// "reason-phrase = *( HTAB / SP / VCHAR / obs-text )"
|
|
// https://github.com/chromium/chromium/blob/94.0.4604.1/third_party/blink/renderer/core/fetch/response.cc#L116
|
|
function isValidReasonPhrase (statusText) {
|
|
for (let i = 0; i < statusText.length; ++i) {
|
|
const c = statusText.charCodeAt(i)
|
|
if (
|
|
!(
|
|
(
|
|
c === 0x09 || // HTAB
|
|
(c >= 0x20 && c <= 0x7e) || // SP / VCHAR
|
|
(c >= 0x80 && c <= 0xff)
|
|
) // obs-text
|
|
)
|
|
) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#header-name
|
|
* @param {string} potentialValue
|
|
*/
|
|
const isValidHeaderName = isValidHTTPToken
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#header-value
|
|
* @param {string} potentialValue
|
|
*/
|
|
function isValidHeaderValue (potentialValue) {
|
|
// - Has no leading or trailing HTTP tab or space bytes.
|
|
// - Contains no 0x00 (NUL) or HTTP newline bytes.
|
|
return (
|
|
potentialValue[0] === '\t' ||
|
|
potentialValue[0] === ' ' ||
|
|
potentialValue[potentialValue.length - 1] === '\t' ||
|
|
potentialValue[potentialValue.length - 1] === ' ' ||
|
|
potentialValue.includes('\n') ||
|
|
potentialValue.includes('\r') ||
|
|
potentialValue.includes('\0')
|
|
) === false
|
|
}
|
|
|
|
// https://w3c.github.io/webappsec-referrer-policy/#set-requests-referrer-policy-on-redirect
|
|
function setRequestReferrerPolicyOnRedirect (request, actualResponse) {
|
|
// Given a request request and a response actualResponse, this algorithm
|
|
// updates request’s referrer policy according to the Referrer-Policy
|
|
// header (if any) in actualResponse.
|
|
|
|
// 1. Let policy be the result of executing § 8.1 Parse a referrer policy
|
|
// from a Referrer-Policy header on actualResponse.
|
|
|
|
// 8.1 Parse a referrer policy from a Referrer-Policy header
|
|
// 1. Let policy-tokens be the result of extracting header list values given `Referrer-Policy` and response’s header list.
|
|
const { headersList } = actualResponse
|
|
// 2. Let policy be the empty string.
|
|
// 3. For each token in policy-tokens, if token is a referrer policy and token is not the empty string, then set policy to token.
|
|
// 4. Return policy.
|
|
const policyHeader = (headersList.get('referrer-policy', true) ?? '').split(',')
|
|
|
|
// Note: As the referrer-policy can contain multiple policies
|
|
// separated by comma, we need to loop through all of them
|
|
// and pick the first valid one.
|
|
// Ref: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy#specify_a_fallback_policy
|
|
let policy = ''
|
|
if (policyHeader.length > 0) {
|
|
// The right-most policy takes precedence.
|
|
// The left-most policy is the fallback.
|
|
for (let i = policyHeader.length; i !== 0; i--) {
|
|
const token = policyHeader[i - 1].trim()
|
|
if (referrerPolicyTokens.has(token)) {
|
|
policy = token
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. If policy is not the empty string, then set request’s referrer policy to policy.
|
|
if (policy !== '') {
|
|
request.referrerPolicy = policy
|
|
}
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#cross-origin-resource-policy-check
|
|
function crossOriginResourcePolicyCheck () {
|
|
// TODO
|
|
return 'allowed'
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#concept-cors-check
|
|
function corsCheck () {
|
|
// TODO
|
|
return 'success'
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#concept-tao-check
|
|
function TAOCheck () {
|
|
// TODO
|
|
return 'success'
|
|
}
|
|
|
|
function appendFetchMetadata (httpRequest) {
|
|
// https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-dest-header
|
|
// TODO
|
|
|
|
// https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-mode-header
|
|
|
|
// 1. Assert: r’s url is a potentially trustworthy URL.
|
|
// TODO
|
|
|
|
// 2. Let header be a Structured Header whose value is a token.
|
|
let header = null
|
|
|
|
// 3. Set header’s value to r’s mode.
|
|
header = httpRequest.mode
|
|
|
|
// 4. Set a structured field value `Sec-Fetch-Mode`/header in r’s header list.
|
|
httpRequest.headersList.set('sec-fetch-mode', header, true)
|
|
|
|
// https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-site-header
|
|
// TODO
|
|
|
|
// https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-user-header
|
|
// TODO
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#append-a-request-origin-header
|
|
function appendRequestOriginHeader (request) {
|
|
// 1. Let serializedOrigin be the result of byte-serializing a request origin
|
|
// with request.
|
|
// TODO: implement "byte-serializing a request origin"
|
|
let serializedOrigin = request.origin
|
|
|
|
// - "'client' is changed to an origin during fetching."
|
|
// This doesn't happen in undici (in most cases) because undici, by default,
|
|
// has no concept of origin.
|
|
// - request.origin can also be set to request.client.origin (client being
|
|
// an environment settings object), which is undefined without using
|
|
// setGlobalOrigin.
|
|
if (serializedOrigin === 'client' || serializedOrigin === undefined) {
|
|
return
|
|
}
|
|
|
|
// 2. If request’s response tainting is "cors" or request’s mode is "websocket",
|
|
// then append (`Origin`, serializedOrigin) to request’s header list.
|
|
// 3. Otherwise, if request’s method is neither `GET` nor `HEAD`, then:
|
|
if (request.responseTainting === 'cors' || request.mode === 'websocket') {
|
|
request.headersList.append('origin', serializedOrigin, true)
|
|
} else if (request.method !== 'GET' && request.method !== 'HEAD') {
|
|
// 1. Switch on request’s referrer policy:
|
|
switch (request.referrerPolicy) {
|
|
case 'no-referrer':
|
|
// Set serializedOrigin to `null`.
|
|
serializedOrigin = null
|
|
break
|
|
case 'no-referrer-when-downgrade':
|
|
case 'strict-origin':
|
|
case 'strict-origin-when-cross-origin':
|
|
// If request’s origin is a tuple origin, its scheme is "https", and
|
|
// request’s current URL’s scheme is not "https", then set
|
|
// serializedOrigin to `null`.
|
|
if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) {
|
|
serializedOrigin = null
|
|
}
|
|
break
|
|
case 'same-origin':
|
|
// If request’s origin is not same origin with request’s current URL’s
|
|
// origin, then set serializedOrigin to `null`.
|
|
if (!sameOrigin(request, requestCurrentURL(request))) {
|
|
serializedOrigin = null
|
|
}
|
|
break
|
|
default:
|
|
// Do nothing.
|
|
}
|
|
|
|
// 2. Append (`Origin`, serializedOrigin) to request’s header list.
|
|
request.headersList.append('origin', serializedOrigin, true)
|
|
}
|
|
}
|
|
|
|
// https://w3c.github.io/hr-time/#dfn-coarsen-time
|
|
function coarsenTime (timestamp, crossOriginIsolatedCapability) {
|
|
// TODO
|
|
return timestamp
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#clamp-and-coarsen-connection-timing-info
|
|
function clampAndCoarsenConnectionTimingInfo (connectionTimingInfo, defaultStartTime, crossOriginIsolatedCapability) {
|
|
if (!connectionTimingInfo?.startTime || connectionTimingInfo.startTime < defaultStartTime) {
|
|
return {
|
|
domainLookupStartTime: defaultStartTime,
|
|
domainLookupEndTime: defaultStartTime,
|
|
connectionStartTime: defaultStartTime,
|
|
connectionEndTime: defaultStartTime,
|
|
secureConnectionStartTime: defaultStartTime,
|
|
ALPNNegotiatedProtocol: connectionTimingInfo?.ALPNNegotiatedProtocol
|
|
}
|
|
}
|
|
|
|
return {
|
|
domainLookupStartTime: coarsenTime(connectionTimingInfo.domainLookupStartTime, crossOriginIsolatedCapability),
|
|
domainLookupEndTime: coarsenTime(connectionTimingInfo.domainLookupEndTime, crossOriginIsolatedCapability),
|
|
connectionStartTime: coarsenTime(connectionTimingInfo.connectionStartTime, crossOriginIsolatedCapability),
|
|
connectionEndTime: coarsenTime(connectionTimingInfo.connectionEndTime, crossOriginIsolatedCapability),
|
|
secureConnectionStartTime: coarsenTime(connectionTimingInfo.secureConnectionStartTime, crossOriginIsolatedCapability),
|
|
ALPNNegotiatedProtocol: connectionTimingInfo.ALPNNegotiatedProtocol
|
|
}
|
|
}
|
|
|
|
// https://w3c.github.io/hr-time/#dfn-coarsened-shared-current-time
|
|
function coarsenedSharedCurrentTime (crossOriginIsolatedCapability) {
|
|
return coarsenTime(performance.now(), crossOriginIsolatedCapability)
|
|
}
|
|
|
|
// https://fetch.spec.whatwg.org/#create-an-opaque-timing-info
|
|
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
|
|
}
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/multipage/origin.html#policy-container
|
|
function makePolicyContainer () {
|
|
// Note: the fetch spec doesn't make use of embedder policy or CSP list
|
|
return {
|
|
referrerPolicy: 'strict-origin-when-cross-origin'
|
|
}
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/multipage/origin.html#clone-a-policy-container
|
|
function clonePolicyContainer (policyContainer) {
|
|
return {
|
|
referrerPolicy: policyContainer.referrerPolicy
|
|
}
|
|
}
|
|
|
|
// https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer
|
|
function determineRequestsReferrer (request) {
|
|
// 1. Let policy be request's referrer policy.
|
|
const policy = request.referrerPolicy
|
|
|
|
// Note: policy cannot (shouldn't) be null or an empty string.
|
|
assert(policy)
|
|
|
|
// 2. Let environment be request’s client.
|
|
|
|
let referrerSource = null
|
|
|
|
// 3. Switch on request’s referrer:
|
|
if (request.referrer === 'client') {
|
|
// Note: node isn't a browser and doesn't implement document/iframes,
|
|
// so we bypass this step and replace it with our own.
|
|
|
|
const globalOrigin = getGlobalOrigin()
|
|
|
|
if (!globalOrigin || globalOrigin.origin === 'null') {
|
|
return 'no-referrer'
|
|
}
|
|
|
|
// note: we need to clone it as it's mutated
|
|
referrerSource = new URL(globalOrigin)
|
|
} else if (request.referrer instanceof URL) {
|
|
// Let referrerSource be request’s referrer.
|
|
referrerSource = request.referrer
|
|
}
|
|
|
|
// 4. Let request’s referrerURL be the result of stripping referrerSource for
|
|
// use as a referrer.
|
|
let referrerURL = stripURLForReferrer(referrerSource)
|
|
|
|
// 5. Let referrerOrigin be the result of stripping referrerSource for use as
|
|
// a referrer, with the origin-only flag set to true.
|
|
const referrerOrigin = stripURLForReferrer(referrerSource, true)
|
|
|
|
// 6. If the result of serializing referrerURL is a string whose length is
|
|
// greater than 4096, set referrerURL to referrerOrigin.
|
|
if (referrerURL.toString().length > 4096) {
|
|
referrerURL = referrerOrigin
|
|
}
|
|
|
|
const areSameOrigin = sameOrigin(request, referrerURL)
|
|
const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) &&
|
|
!isURLPotentiallyTrustworthy(request.url)
|
|
|
|
// 8. Execute the switch statements corresponding to the value of policy:
|
|
switch (policy) {
|
|
case 'origin': return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true)
|
|
case 'unsafe-url': return referrerURL
|
|
case 'same-origin':
|
|
return areSameOrigin ? referrerOrigin : 'no-referrer'
|
|
case 'origin-when-cross-origin':
|
|
return areSameOrigin ? referrerURL : referrerOrigin
|
|
case 'strict-origin-when-cross-origin': {
|
|
const currentURL = requestCurrentURL(request)
|
|
|
|
// 1. If the origin of referrerURL and the origin of request’s current
|
|
// URL are the same, then return referrerURL.
|
|
if (sameOrigin(referrerURL, currentURL)) {
|
|
return referrerURL
|
|
}
|
|
|
|
// 2. If referrerURL is a potentially trustworthy URL and request’s
|
|
// current URL is not a potentially trustworthy URL, then return no
|
|
// referrer.
|
|
if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
|
|
return 'no-referrer'
|
|
}
|
|
|
|
// 3. Return referrerOrigin.
|
|
return referrerOrigin
|
|
}
|
|
case 'strict-origin': // eslint-disable-line
|
|
/**
|
|
* 1. If referrerURL is a potentially trustworthy URL and
|
|
* request’s current URL is not a potentially trustworthy URL,
|
|
* then return no referrer.
|
|
* 2. Return referrerOrigin
|
|
*/
|
|
case 'no-referrer-when-downgrade': // eslint-disable-line
|
|
/**
|
|
* 1. If referrerURL is a potentially trustworthy URL and
|
|
* request’s current URL is not a potentially trustworthy URL,
|
|
* then return no referrer.
|
|
* 2. Return referrerOrigin
|
|
*/
|
|
|
|
default: // eslint-disable-line
|
|
return isNonPotentiallyTrustWorthy ? 'no-referrer' : referrerOrigin
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/webappsec-referrer-policy/#strip-url
|
|
* @param {URL} url
|
|
* @param {boolean|undefined} originOnly
|
|
*/
|
|
function stripURLForReferrer (url, originOnly) {
|
|
// 1. Assert: url is a URL.
|
|
assert(url instanceof URL)
|
|
|
|
url = new URL(url)
|
|
|
|
// 2. If url’s scheme is a local scheme, then return no referrer.
|
|
if (url.protocol === 'file:' || url.protocol === 'about:' || url.protocol === 'blank:') {
|
|
return 'no-referrer'
|
|
}
|
|
|
|
// 3. Set url’s username to the empty string.
|
|
url.username = ''
|
|
|
|
// 4. Set url’s password to the empty string.
|
|
url.password = ''
|
|
|
|
// 5. Set url’s fragment to null.
|
|
url.hash = ''
|
|
|
|
// 6. If the origin-only flag is true, then:
|
|
if (originOnly) {
|
|
// 1. Set url’s path to « the empty string ».
|
|
url.pathname = ''
|
|
|
|
// 2. Set url’s query to null.
|
|
url.search = ''
|
|
}
|
|
|
|
// 7. Return url.
|
|
return url
|
|
}
|
|
|
|
function isURLPotentiallyTrustworthy (url) {
|
|
if (!(url instanceof URL)) {
|
|
return false
|
|
}
|
|
|
|
// If child of about, return true
|
|
if (url.href === 'about:blank' || url.href === 'about:srcdoc') {
|
|
return true
|
|
}
|
|
|
|
// If scheme is data, return true
|
|
if (url.protocol === 'data:') return true
|
|
|
|
// If file, return true
|
|
if (url.protocol === 'file:') return true
|
|
|
|
return isOriginPotentiallyTrustworthy(url.origin)
|
|
|
|
function isOriginPotentiallyTrustworthy (origin) {
|
|
// If origin is explicitly null, return false
|
|
if (origin == null || origin === 'null') return false
|
|
|
|
const originAsURL = new URL(origin)
|
|
|
|
// If secure, return true
|
|
if (originAsURL.protocol === 'https:' || originAsURL.protocol === 'wss:') {
|
|
return true
|
|
}
|
|
|
|
// If localhost or variants, 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
|
|
}
|
|
|
|
// If any other, return false
|
|
return false
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/webappsec-subresource-integrity/#does-response-match-metadatalist
|
|
* @param {Uint8Array} bytes
|
|
* @param {string} metadataList
|
|
*/
|
|
function bytesMatch (bytes, metadataList) {
|
|
// If node is not built with OpenSSL support, we cannot check
|
|
// a request's integrity, so allow it by default (the spec will
|
|
// allow requests if an invalid hash is given, as precedence).
|
|
/* istanbul ignore if: only if node is built with --without-ssl */
|
|
if (crypto === undefined) {
|
|
return true
|
|
}
|
|
|
|
// 1. Let parsedMetadata be the result of parsing metadataList.
|
|
const parsedMetadata = parseMetadata(metadataList)
|
|
|
|
// 2. If parsedMetadata is no metadata, return true.
|
|
if (parsedMetadata === 'no metadata') {
|
|
return true
|
|
}
|
|
|
|
// 3. If response is not eligible for integrity validation, return false.
|
|
// TODO
|
|
|
|
// 4. If parsedMetadata is the empty set, return true.
|
|
if (parsedMetadata.length === 0) {
|
|
return true
|
|
}
|
|
|
|
// 5. Let metadata be the result of getting the strongest
|
|
// metadata from parsedMetadata.
|
|
const strongest = getStrongestMetadata(parsedMetadata)
|
|
const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest)
|
|
|
|
// 6. For each item in metadata:
|
|
for (const item of metadata) {
|
|
// 1. Let algorithm be the alg component of item.
|
|
const algorithm = item.algo
|
|
|
|
// 2. Let expectedValue be the val component of item.
|
|
const expectedValue = item.hash
|
|
|
|
// See https://github.com/web-platform-tests/wpt/commit/e4c5cc7a5e48093220528dfdd1c4012dc3837a0e
|
|
// "be liberal with padding". This is annoying, and it's not even in the spec.
|
|
|
|
// 3. Let actualValue be the result of applying algorithm to bytes.
|
|
let actualValue = crypto.createHash(algorithm).update(bytes).digest('base64')
|
|
|
|
if (actualValue[actualValue.length - 1] === '=') {
|
|
if (actualValue[actualValue.length - 2] === '=') {
|
|
actualValue = actualValue.slice(0, -2)
|
|
} else {
|
|
actualValue = actualValue.slice(0, -1)
|
|
}
|
|
}
|
|
|
|
// 4. If actualValue is a case-sensitive match for expectedValue,
|
|
// return true.
|
|
if (compareBase64Mixed(actualValue, expectedValue)) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
// 7. Return false.
|
|
return false
|
|
}
|
|
|
|
// https://w3c.github.io/webappsec-subresource-integrity/#grammardef-hash-with-options
|
|
// https://www.w3.org/TR/CSP2/#source-list-syntax
|
|
// https://www.rfc-editor.org/rfc/rfc5234#appendix-B.1
|
|
const parseHashWithOptions = /(?<algo>sha256|sha384|sha512)-((?<hash>[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i
|
|
|
|
/**
|
|
* @see https://w3c.github.io/webappsec-subresource-integrity/#parse-metadata
|
|
* @param {string} metadata
|
|
*/
|
|
function parseMetadata (metadata) {
|
|
// 1. Let result be the empty set.
|
|
/** @type {{ algo: string, hash: string }[]} */
|
|
const result = []
|
|
|
|
// 2. Let empty be equal to true.
|
|
let empty = true
|
|
|
|
// 3. For each token returned by splitting metadata on spaces:
|
|
for (const token of metadata.split(' ')) {
|
|
// 1. Set empty to false.
|
|
empty = false
|
|
|
|
// 2. Parse token as a hash-with-options.
|
|
const parsedToken = parseHashWithOptions.exec(token)
|
|
|
|
// 3. If token does not parse, continue to the next token.
|
|
if (
|
|
parsedToken === null ||
|
|
parsedToken.groups === undefined ||
|
|
parsedToken.groups.algo === undefined
|
|
) {
|
|
// Note: Chromium blocks the request at this point, but Firefox
|
|
// gives a warning that an invalid integrity was given. The
|
|
// correct behavior is to ignore these, and subsequently not
|
|
// check the integrity of the resource.
|
|
continue
|
|
}
|
|
|
|
// 4. Let algorithm be the hash-algo component of token.
|
|
const algorithm = parsedToken.groups.algo.toLowerCase()
|
|
|
|
// 5. If algorithm is a hash function recognized by the user
|
|
// agent, add the parsed token to result.
|
|
if (supportedHashes.includes(algorithm)) {
|
|
result.push(parsedToken.groups)
|
|
}
|
|
}
|
|
|
|
// 4. Return no metadata if empty is true, otherwise return result.
|
|
if (empty === true) {
|
|
return 'no metadata'
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* @param {{ algo: 'sha256' | 'sha384' | 'sha512' }[]} metadataList
|
|
*/
|
|
function getStrongestMetadata (metadataList) {
|
|
// Let algorithm be the algo component of the first item in metadataList.
|
|
// Can be sha256
|
|
let algorithm = metadataList[0].algo
|
|
// If the algorithm is sha512, then it is the strongest
|
|
// and we can return immediately
|
|
if (algorithm[3] === '5') {
|
|
return algorithm
|
|
}
|
|
|
|
for (let i = 1; i < metadataList.length; ++i) {
|
|
const metadata = metadataList[i]
|
|
// If the algorithm is sha512, then it is the strongest
|
|
// and we can break the loop immediately
|
|
if (metadata.algo[3] === '5') {
|
|
algorithm = 'sha512'
|
|
break
|
|
// If the algorithm is sha384, then a potential sha256 or sha384 is ignored
|
|
} else if (algorithm[3] === '3') {
|
|
continue
|
|
// algorithm is sha256, check if algorithm is sha384 and if so, set it as
|
|
// the strongest
|
|
} else if (metadata.algo[3] === '3') {
|
|
algorithm = 'sha384'
|
|
}
|
|
}
|
|
return algorithm
|
|
}
|
|
|
|
function filterMetadataListByAlgorithm (metadataList, algorithm) {
|
|
if (metadataList.length === 1) {
|
|
return metadataList
|
|
}
|
|
|
|
let pos = 0
|
|
for (let i = 0; i < metadataList.length; ++i) {
|
|
if (metadataList[i].algo === algorithm) {
|
|
metadataList[pos++] = metadataList[i]
|
|
}
|
|
}
|
|
|
|
metadataList.length = pos
|
|
|
|
return metadataList
|
|
}
|
|
|
|
/**
|
|
* Compares two base64 strings, allowing for base64url
|
|
* in the second string.
|
|
*
|
|
* @param {string} actualValue always base64
|
|
* @param {string} expectedValue base64 or base64url
|
|
* @returns {boolean}
|
|
*/
|
|
function compareBase64Mixed (actualValue, expectedValue) {
|
|
if (actualValue.length !== expectedValue.length) {
|
|
return false
|
|
}
|
|
for (let i = 0; i < actualValue.length; ++i) {
|
|
if (actualValue[i] !== expectedValue[i]) {
|
|
if (
|
|
(actualValue[i] === '+' && expectedValue[i] === '-') ||
|
|
(actualValue[i] === '/' && expectedValue[i] === '_')
|
|
) {
|
|
continue
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// https://w3c.github.io/webappsec-upgrade-insecure-requests/#upgrade-request
|
|
function tryUpgradeRequestToAPotentiallyTrustworthyURL (request) {
|
|
// TODO
|
|
}
|
|
|
|
/**
|
|
* @link {https://html.spec.whatwg.org/multipage/origin.html#same-origin}
|
|
* @param {URL} A
|
|
* @param {URL} B
|
|
*/
|
|
function sameOrigin (A, B) {
|
|
// 1. If A and B are the same opaque origin, then return true.
|
|
if (A.origin === B.origin && A.origin === 'null') {
|
|
return true
|
|
}
|
|
|
|
// 2. If A and B are both tuple origins and their schemes,
|
|
// hosts, and port are identical, then return true.
|
|
if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) {
|
|
return true
|
|
}
|
|
|
|
// 3. Return false.
|
|
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'
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#concept-method-normalize
|
|
* @param {string} method
|
|
*/
|
|
function normalizeMethod (method) {
|
|
return normalizedMethodRecordsBase[method.toLowerCase()] ?? method
|
|
}
|
|
|
|
// https://infra.spec.whatwg.org/#serialize-a-javascript-value-to-a-json-string
|
|
function serializeJavascriptValueToJSONString (value) {
|
|
// 1. Let result be ? Call(%JSON.stringify%, undefined, « value »).
|
|
const result = JSON.stringify(value)
|
|
|
|
// 2. If result is undefined, then throw a TypeError.
|
|
if (result === undefined) {
|
|
throw new TypeError('Value is not JSON serializable')
|
|
}
|
|
|
|
// 3. Assert: result is a string.
|
|
assert(typeof result === 'string')
|
|
|
|
// 4. Return result.
|
|
return result
|
|
}
|
|
|
|
// https://tc39.es/ecma262/#sec-%25iteratorprototype%25-object
|
|
const esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))
|
|
|
|
/**
|
|
* @see https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
|
|
* @param {string} name name of the instance
|
|
* @param {symbol} kInternalIterator
|
|
* @param {string | number} [keyIndex]
|
|
* @param {string | number} [valueIndex]
|
|
*/
|
|
function createIterator (name, kInternalIterator, keyIndex = 0, valueIndex = 1) {
|
|
class FastIterableIterator {
|
|
/** @type {any} */
|
|
#target
|
|
/** @type {'key' | 'value' | 'key+value'} */
|
|
#kind
|
|
/** @type {number} */
|
|
#index
|
|
|
|
/**
|
|
* @see https://webidl.spec.whatwg.org/#dfn-default-iterator-object
|
|
* @param {unknown} target
|
|
* @param {'key' | 'value' | 'key+value'} kind
|
|
*/
|
|
constructor (target, kind) {
|
|
this.#target = target
|
|
this.#kind = kind
|
|
this.#index = 0
|
|
}
|
|
|
|
next () {
|
|
// 1. Let interface be the interface for which the iterator prototype object exists.
|
|
// 2. Let thisValue be the this value.
|
|
// 3. Let object be ? ToObject(thisValue).
|
|
// 4. If object is a platform object, then perform a security
|
|
// check, passing:
|
|
// 5. If object is not a default iterator object for interface,
|
|
// then throw a TypeError.
|
|
if (typeof this !== 'object' || this === null || !(#target in this)) {
|
|
throw new TypeError(
|
|
`'next' called on an object that does not implement interface ${name} Iterator.`
|
|
)
|
|
}
|
|
|
|
// 6. Let index be object’s index.
|
|
// 7. Let kind be object’s kind.
|
|
// 8. Let values be object’s target's value pairs to iterate over.
|
|
const index = this.#index
|
|
const values = this.#target[kInternalIterator]
|
|
|
|
// 9. Let len be the length of values.
|
|
const len = values.length
|
|
|
|
// 10. If index is greater than or equal to len, then return
|
|
// CreateIterResultObject(undefined, true).
|
|
if (index >= len) {
|
|
return {
|
|
value: undefined,
|
|
done: true
|
|
}
|
|
}
|
|
|
|
// 11. Let pair be the entry in values at index index.
|
|
const { [keyIndex]: key, [valueIndex]: value } = values[index]
|
|
|
|
// 12. Set object’s index to index + 1.
|
|
this.#index = index + 1
|
|
|
|
// 13. Return the iterator result for pair and kind.
|
|
|
|
// https://webidl.spec.whatwg.org/#iterator-result
|
|
|
|
// 1. Let result be a value determined by the value of kind:
|
|
let result
|
|
switch (this.#kind) {
|
|
case 'key':
|
|
// 1. Let idlKey be pair’s key.
|
|
// 2. Let key be the result of converting idlKey to an
|
|
// ECMAScript value.
|
|
// 3. result is key.
|
|
result = key
|
|
break
|
|
case 'value':
|
|
// 1. Let idlValue be pair’s value.
|
|
// 2. Let value be the result of converting idlValue to
|
|
// an ECMAScript value.
|
|
// 3. result is value.
|
|
result = value
|
|
break
|
|
case 'key+value':
|
|
// 1. Let idlKey be pair’s key.
|
|
// 2. Let idlValue be pair’s value.
|
|
// 3. Let key be the result of converting idlKey to an
|
|
// ECMAScript value.
|
|
// 4. Let value be the result of converting idlValue to
|
|
// an ECMAScript value.
|
|
// 5. Let array be ! ArrayCreate(2).
|
|
// 6. Call ! CreateDataProperty(array, "0", key).
|
|
// 7. Call ! CreateDataProperty(array, "1", value).
|
|
// 8. result is array.
|
|
result = [key, value]
|
|
break
|
|
}
|
|
|
|
// 2. Return CreateIterResultObject(result, false).
|
|
return {
|
|
value: result,
|
|
done: false
|
|
}
|
|
}
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
|
|
// @ts-ignore
|
|
delete FastIterableIterator.prototype.constructor
|
|
|
|
Object.setPrototypeOf(FastIterableIterator.prototype, esIteratorPrototype)
|
|
|
|
Object.defineProperties(FastIterableIterator.prototype, {
|
|
[Symbol.toStringTag]: {
|
|
writable: false,
|
|
enumerable: false,
|
|
configurable: true,
|
|
value: `${name} Iterator`
|
|
},
|
|
next: { writable: true, enumerable: true, configurable: true }
|
|
})
|
|
|
|
/**
|
|
* @param {unknown} target
|
|
* @param {'key' | 'value' | 'key+value'} kind
|
|
* @returns {IterableIterator<any>}
|
|
*/
|
|
return function (target, kind) {
|
|
return new FastIterableIterator(target, kind)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
|
|
* @param {string} name name of the instance
|
|
* @param {any} object class
|
|
* @param {symbol} kInternalIterator
|
|
* @param {string | number} [keyIndex]
|
|
* @param {string | number} [valueIndex]
|
|
*/
|
|
function iteratorMixin (name, object, kInternalIterator, keyIndex = 0, valueIndex = 1) {
|
|
const makeIterator = createIterator(name, kInternalIterator, keyIndex, valueIndex)
|
|
|
|
const properties = {
|
|
keys: {
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true,
|
|
value: function keys () {
|
|
webidl.brandCheck(this, object)
|
|
return makeIterator(this, 'key')
|
|
}
|
|
},
|
|
values: {
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true,
|
|
value: function values () {
|
|
webidl.brandCheck(this, object)
|
|
return makeIterator(this, 'value')
|
|
}
|
|
},
|
|
entries: {
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true,
|
|
value: function entries () {
|
|
webidl.brandCheck(this, object)
|
|
return makeIterator(this, 'key+value')
|
|
}
|
|
},
|
|
forEach: {
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true,
|
|
value: function forEach (callbackfn, thisArg = globalThis) {
|
|
webidl.brandCheck(this, object)
|
|
webidl.argumentLengthCheck(arguments, 1, `${name}.forEach`)
|
|
if (typeof callbackfn !== 'function') {
|
|
throw new TypeError(
|
|
`Failed to execute 'forEach' on '${name}': parameter 1 is not of type 'Function'.`
|
|
)
|
|
}
|
|
for (const { 0: key, 1: value } of makeIterator(this, 'key+value')) {
|
|
callbackfn.call(thisArg, value, key, this)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return Object.defineProperties(object.prototype, {
|
|
...properties,
|
|
[Symbol.iterator]: {
|
|
writable: true,
|
|
enumerable: false,
|
|
configurable: true,
|
|
value: properties.entries.value
|
|
}
|
|
})
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#body-fully-read
|
|
*/
|
|
async function fullyReadBody (body, processBody, processBodyError) {
|
|
// 1. If taskDestination is null, then set taskDestination to
|
|
// the result of starting a new parallel queue.
|
|
|
|
// 2. Let successSteps given a byte sequence bytes be to queue a
|
|
// fetch task to run processBody given bytes, with taskDestination.
|
|
const successSteps = processBody
|
|
|
|
// 3. Let errorSteps be to queue a fetch task to run processBodyError,
|
|
// with taskDestination.
|
|
const errorSteps = processBodyError
|
|
|
|
// 4. Let reader be the result of getting a reader for body’s stream.
|
|
// If that threw an exception, then run errorSteps with that
|
|
// exception and return.
|
|
let reader
|
|
|
|
try {
|
|
reader = body.stream.getReader()
|
|
} catch (e) {
|
|
errorSteps(e)
|
|
return
|
|
}
|
|
|
|
// 5. Read all bytes from reader, given successSteps and errorSteps.
|
|
try {
|
|
successSteps(await readAllBytes(reader))
|
|
} catch (e) {
|
|
errorSteps(e)
|
|
}
|
|
}
|
|
|
|
function isReadableStreamLike (stream) {
|
|
return stream instanceof ReadableStream || (
|
|
stream[Symbol.toStringTag] === 'ReadableStream' &&
|
|
typeof stream.tee === 'function'
|
|
)
|
|
}
|
|
|
|
/**
|
|
* @param {ReadableStreamController<Uint8Array>} controller
|
|
*/
|
|
function readableStreamClose (controller) {
|
|
try {
|
|
controller.close()
|
|
controller.byobRequest?.respond(0)
|
|
} catch (err) {
|
|
// TODO: add comment explaining why this error occurs.
|
|
if (!err.message.includes('Controller is already closed') && !err.message.includes('ReadableStream is already closed')) {
|
|
throw err
|
|
}
|
|
}
|
|
}
|
|
|
|
const invalidIsomorphicEncodeValueRegex = /[^\x00-\xFF]/ // eslint-disable-line
|
|
|
|
/**
|
|
* @see https://infra.spec.whatwg.org/#isomorphic-encode
|
|
* @param {string} input
|
|
*/
|
|
function isomorphicEncode (input) {
|
|
// 1. Assert: input contains no code points greater than U+00FF.
|
|
assert(!invalidIsomorphicEncodeValueRegex.test(input))
|
|
|
|
// 2. Return a byte sequence whose length is equal to input’s code
|
|
// point length and whose bytes have the same values as the
|
|
// values of input’s code points, in the same order
|
|
return input
|
|
}
|
|
|
|
/**
|
|
* @see https://streams.spec.whatwg.org/#readablestreamdefaultreader-read-all-bytes
|
|
* @see https://streams.spec.whatwg.org/#read-loop
|
|
* @param {ReadableStreamDefaultReader} reader
|
|
*/
|
|
async function readAllBytes (reader) {
|
|
const bytes = []
|
|
let byteLength = 0
|
|
|
|
while (true) {
|
|
const { done, value: chunk } = await reader.read()
|
|
|
|
if (done) {
|
|
// 1. Call successSteps with bytes.
|
|
return Buffer.concat(bytes, byteLength)
|
|
}
|
|
|
|
// 1. If chunk is not a Uint8Array object, call failureSteps
|
|
// with a TypeError and abort these steps.
|
|
if (!isUint8Array(chunk)) {
|
|
throw new TypeError('Received non-Uint8Array chunk')
|
|
}
|
|
|
|
// 2. Append the bytes represented by chunk to bytes.
|
|
bytes.push(chunk)
|
|
byteLength += chunk.length
|
|
|
|
// 3. Read-loop given reader, bytes, successSteps, and failureSteps.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#is-local
|
|
* @param {URL} url
|
|
*/
|
|
function urlIsLocal (url) {
|
|
assert('protocol' in url) // ensure it's a url object
|
|
|
|
const protocol = url.protocol
|
|
|
|
return protocol === 'about:' || protocol === 'blob:' || protocol === 'data:'
|
|
}
|
|
|
|
/**
|
|
* @param {string|URL} url
|
|
* @returns {boolean}
|
|
*/
|
|
function urlHasHttpsScheme (url) {
|
|
return (
|
|
(
|
|
typeof url === 'string' &&
|
|
url[5] === ':' &&
|
|
url[0] === 'h' &&
|
|
url[1] === 't' &&
|
|
url[2] === 't' &&
|
|
url[3] === 'p' &&
|
|
url[4] === 's'
|
|
) ||
|
|
url.protocol === 'https:'
|
|
)
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#http-scheme
|
|
* @param {URL} url
|
|
*/
|
|
function urlIsHttpHttpsScheme (url) {
|
|
assert('protocol' in url) // ensure it's a url object
|
|
|
|
const protocol = url.protocol
|
|
|
|
return protocol === 'http:' || protocol === 'https:'
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#simple-range-header-value
|
|
* @param {string} value
|
|
* @param {boolean} allowWhitespace
|
|
*/
|
|
function simpleRangeHeaderValue (value, allowWhitespace) {
|
|
// 1. Let data be the isomorphic decoding of value.
|
|
// Note: isomorphic decoding takes a sequence of bytes (ie. a Uint8Array) and turns it into a string,
|
|
// nothing more. We obviously don't need to do that if value is a string already.
|
|
const data = value
|
|
|
|
// 2. If data does not start with "bytes", then return failure.
|
|
if (!data.startsWith('bytes')) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 3. Let position be a position variable for data, initially pointing at the 5th code point of data.
|
|
const position = { position: 5 }
|
|
|
|
// 4. If allowWhitespace is true, collect a sequence of code points that are HTTP tab or space,
|
|
// from data given position.
|
|
if (allowWhitespace) {
|
|
collectASequenceOfCodePoints(
|
|
(char) => char === '\t' || char === ' ',
|
|
data,
|
|
position
|
|
)
|
|
}
|
|
|
|
// 5. If the code point at position within data is not U+003D (=), then return failure.
|
|
if (data.charCodeAt(position.position) !== 0x3D) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 6. Advance position by 1.
|
|
position.position++
|
|
|
|
// 7. If allowWhitespace is true, collect a sequence of code points that are HTTP tab or space, from
|
|
// data given position.
|
|
if (allowWhitespace) {
|
|
collectASequenceOfCodePoints(
|
|
(char) => char === '\t' || char === ' ',
|
|
data,
|
|
position
|
|
)
|
|
}
|
|
|
|
// 8. Let rangeStart be the result of collecting a sequence of code points that are ASCII digits,
|
|
// from data given position.
|
|
const rangeStart = collectASequenceOfCodePoints(
|
|
(char) => {
|
|
const code = char.charCodeAt(0)
|
|
|
|
return code >= 0x30 && code <= 0x39
|
|
},
|
|
data,
|
|
position
|
|
)
|
|
|
|
// 9. Let rangeStartValue be rangeStart, interpreted as decimal number, if rangeStart is not the
|
|
// empty string; otherwise null.
|
|
const rangeStartValue = rangeStart.length ? Number(rangeStart) : null
|
|
|
|
// 10. If allowWhitespace is true, collect a sequence of code points that are HTTP tab or space,
|
|
// from data given position.
|
|
if (allowWhitespace) {
|
|
collectASequenceOfCodePoints(
|
|
(char) => char === '\t' || char === ' ',
|
|
data,
|
|
position
|
|
)
|
|
}
|
|
|
|
// 11. If the code point at position within data is not U+002D (-), then return failure.
|
|
if (data.charCodeAt(position.position) !== 0x2D) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 12. Advance position by 1.
|
|
position.position++
|
|
|
|
// 13. If allowWhitespace is true, collect a sequence of code points that are HTTP tab
|
|
// or space, from data given position.
|
|
// Note from Khafra: its the same step as in #8 again lol
|
|
if (allowWhitespace) {
|
|
collectASequenceOfCodePoints(
|
|
(char) => char === '\t' || char === ' ',
|
|
data,
|
|
position
|
|
)
|
|
}
|
|
|
|
// 14. Let rangeEnd be the result of collecting a sequence of code points that are
|
|
// ASCII digits, from data given position.
|
|
// Note from Khafra: you wouldn't guess it, but this is also the same step as #8
|
|
const rangeEnd = collectASequenceOfCodePoints(
|
|
(char) => {
|
|
const code = char.charCodeAt(0)
|
|
|
|
return code >= 0x30 && code <= 0x39
|
|
},
|
|
data,
|
|
position
|
|
)
|
|
|
|
// 15. Let rangeEndValue be rangeEnd, interpreted as decimal number, if rangeEnd
|
|
// is not the empty string; otherwise null.
|
|
// Note from Khafra: THE SAME STEP, AGAIN!!!
|
|
// Note: why interpret as a decimal if we only collect ascii digits?
|
|
const rangeEndValue = rangeEnd.length ? Number(rangeEnd) : null
|
|
|
|
// 16. If position is not past the end of data, then return failure.
|
|
if (position.position < data.length) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 17. If rangeEndValue and rangeStartValue are null, then return failure.
|
|
if (rangeEndValue === null && rangeStartValue === null) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 18. If rangeStartValue and rangeEndValue are numbers, and rangeStartValue is
|
|
// greater than rangeEndValue, then return failure.
|
|
// Note: ... when can they not be numbers?
|
|
if (rangeStartValue > rangeEndValue) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 19. Return (rangeStartValue, rangeEndValue).
|
|
return { rangeStartValue, rangeEndValue }
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#build-a-content-range
|
|
* @param {number} rangeStart
|
|
* @param {number} rangeEnd
|
|
* @param {number} fullLength
|
|
*/
|
|
function buildContentRange (rangeStart, rangeEnd, fullLength) {
|
|
// 1. Let contentRange be `bytes `.
|
|
let contentRange = 'bytes '
|
|
|
|
// 2. Append rangeStart, serialized and isomorphic encoded, to contentRange.
|
|
contentRange += isomorphicEncode(`${rangeStart}`)
|
|
|
|
// 3. Append 0x2D (-) to contentRange.
|
|
contentRange += '-'
|
|
|
|
// 4. Append rangeEnd, serialized and isomorphic encoded to contentRange.
|
|
contentRange += isomorphicEncode(`${rangeEnd}`)
|
|
|
|
// 5. Append 0x2F (/) to contentRange.
|
|
contentRange += '/'
|
|
|
|
// 6. Append fullLength, serialized and isomorphic encoded to contentRange.
|
|
contentRange += isomorphicEncode(`${fullLength}`)
|
|
|
|
// 7. Return contentRange.
|
|
return contentRange
|
|
}
|
|
|
|
// A Stream, which pipes the response to zlib.createInflate() or
|
|
// zlib.createInflateRaw() depending on the first byte of the Buffer.
|
|
// If the lower byte of the first byte is 0x08, then the stream is
|
|
// interpreted as a zlib stream, otherwise it's interpreted as a
|
|
// raw deflate stream.
|
|
class InflateStream extends Transform {
|
|
#zlibOptions
|
|
|
|
/** @param {zlib.ZlibOptions} [zlibOptions] */
|
|
constructor (zlibOptions) {
|
|
super()
|
|
this.#zlibOptions = zlibOptions
|
|
}
|
|
|
|
_transform (chunk, encoding, callback) {
|
|
if (!this._inflateStream) {
|
|
if (chunk.length === 0) {
|
|
callback()
|
|
return
|
|
}
|
|
this._inflateStream = (chunk[0] & 0x0F) === 0x08
|
|
? zlib.createInflate(this.#zlibOptions)
|
|
: zlib.createInflateRaw(this.#zlibOptions)
|
|
|
|
this._inflateStream.on('data', this.push.bind(this))
|
|
this._inflateStream.on('end', () => this.push(null))
|
|
this._inflateStream.on('error', (err) => this.destroy(err))
|
|
}
|
|
|
|
this._inflateStream.write(chunk, encoding, callback)
|
|
}
|
|
|
|
_final (callback) {
|
|
if (this._inflateStream) {
|
|
this._inflateStream.end()
|
|
this._inflateStream = null
|
|
}
|
|
callback()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {zlib.ZlibOptions} [zlibOptions]
|
|
* @returns {InflateStream}
|
|
*/
|
|
function createInflate (zlibOptions) {
|
|
return new InflateStream(zlibOptions)
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#concept-header-extract-mime-type
|
|
* @param {import('./headers').HeadersList} headers
|
|
*/
|
|
function extractMimeType (headers) {
|
|
// 1. Let charset be null.
|
|
let charset = null
|
|
|
|
// 2. Let essence be null.
|
|
let essence = null
|
|
|
|
// 3. Let mimeType be null.
|
|
let mimeType = null
|
|
|
|
// 4. Let values be the result of getting, decoding, and splitting `Content-Type` from headers.
|
|
const values = getDecodeSplit('content-type', headers)
|
|
|
|
// 5. If values is null, then return failure.
|
|
if (values === null) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 6. For each value of values:
|
|
for (const value of values) {
|
|
// 6.1. Let temporaryMimeType be the result of parsing value.
|
|
const temporaryMimeType = parseMIMEType(value)
|
|
|
|
// 6.2. If temporaryMimeType is failure or its essence is "*/*", then continue.
|
|
if (temporaryMimeType === 'failure' || temporaryMimeType.essence === '*/*') {
|
|
continue
|
|
}
|
|
|
|
// 6.3. Set mimeType to temporaryMimeType.
|
|
mimeType = temporaryMimeType
|
|
|
|
// 6.4. If mimeType’s essence is not essence, then:
|
|
if (mimeType.essence !== essence) {
|
|
// 6.4.1. Set charset to null.
|
|
charset = null
|
|
|
|
// 6.4.2. If mimeType’s parameters["charset"] exists, then set charset to
|
|
// mimeType’s parameters["charset"].
|
|
if (mimeType.parameters.has('charset')) {
|
|
charset = mimeType.parameters.get('charset')
|
|
}
|
|
|
|
// 6.4.3. Set essence to mimeType’s essence.
|
|
essence = mimeType.essence
|
|
} else if (!mimeType.parameters.has('charset') && charset !== null) {
|
|
// 6.5. Otherwise, if mimeType’s parameters["charset"] does not exist, and
|
|
// charset is non-null, set mimeType’s parameters["charset"] to charset.
|
|
mimeType.parameters.set('charset', charset)
|
|
}
|
|
}
|
|
|
|
// 7. If mimeType is null, then return failure.
|
|
if (mimeType == null) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 8. Return mimeType.
|
|
return mimeType
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#header-value-get-decode-and-split
|
|
* @param {string|null} value
|
|
*/
|
|
function gettingDecodingSplitting (value) {
|
|
// 1. Let input be the result of isomorphic decoding value.
|
|
const input = value
|
|
|
|
// 2. Let position be a position variable for input, initially pointing at the start of input.
|
|
const position = { position: 0 }
|
|
|
|
// 3. Let values be a list of strings, initially empty.
|
|
const values = []
|
|
|
|
// 4. Let temporaryValue be the empty string.
|
|
let temporaryValue = ''
|
|
|
|
// 5. While position is not past the end of input:
|
|
while (position.position < input.length) {
|
|
// 5.1. Append the result of collecting a sequence of code points that are not U+0022 (")
|
|
// or U+002C (,) from input, given position, to temporaryValue.
|
|
temporaryValue += collectASequenceOfCodePoints(
|
|
(char) => char !== '"' && char !== ',',
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 5.2. If position is not past the end of input, then:
|
|
if (position.position < input.length) {
|
|
// 5.2.1. If the code point at position within input is U+0022 ("), then:
|
|
if (input.charCodeAt(position.position) === 0x22) {
|
|
// 5.2.1.1. Append the result of collecting an HTTP quoted string from input, given position, to temporaryValue.
|
|
temporaryValue += collectAnHTTPQuotedString(
|
|
input,
|
|
position
|
|
)
|
|
|
|
// 5.2.1.2. If position is not past the end of input, then continue.
|
|
if (position.position < input.length) {
|
|
continue
|
|
}
|
|
} else {
|
|
// 5.2.2. Otherwise:
|
|
|
|
// 5.2.2.1. Assert: the code point at position within input is U+002C (,).
|
|
assert(input.charCodeAt(position.position) === 0x2C)
|
|
|
|
// 5.2.2.2. Advance position by 1.
|
|
position.position++
|
|
}
|
|
}
|
|
|
|
// 5.3. Remove all HTTP tab or space from the start and end of temporaryValue.
|
|
temporaryValue = removeChars(temporaryValue, true, true, (char) => char === 0x9 || char === 0x20)
|
|
|
|
// 5.4. Append temporaryValue to values.
|
|
values.push(temporaryValue)
|
|
|
|
// 5.6. Set temporaryValue to the empty string.
|
|
temporaryValue = ''
|
|
}
|
|
|
|
// 6. Return values.
|
|
return values
|
|
}
|
|
|
|
/**
|
|
* @see https://fetch.spec.whatwg.org/#concept-header-list-get-decode-split
|
|
* @param {string} name lowercase header name
|
|
* @param {import('./headers').HeadersList} list
|
|
*/
|
|
function getDecodeSplit (name, list) {
|
|
// 1. Let value be the result of getting name from list.
|
|
const value = list.get(name, true)
|
|
|
|
// 2. If value is null, then return null.
|
|
if (value === null) {
|
|
return null
|
|
}
|
|
|
|
// 3. Return the result of getting, decoding, and splitting value.
|
|
return gettingDecodingSplitting(value)
|
|
}
|
|
|
|
const textDecoder = new TextDecoder()
|
|
|
|
/**
|
|
* @see https://encoding.spec.whatwg.org/#utf-8-decode
|
|
* @param {Buffer} buffer
|
|
*/
|
|
function utf8DecodeBytes (buffer) {
|
|
if (buffer.length === 0) {
|
|
return ''
|
|
}
|
|
|
|
// 1. Let buffer be the result of peeking three bytes from
|
|
// ioQueue, converted to a byte sequence.
|
|
|
|
// 2. If buffer is 0xEF 0xBB 0xBF, then read three
|
|
// bytes from ioQueue. (Do nothing with those bytes.)
|
|
if (buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) {
|
|
buffer = buffer.subarray(3)
|
|
}
|
|
|
|
// 3. Process a queue with an instance of UTF-8’s
|
|
// decoder, ioQueue, output, and "replacement".
|
|
const output = textDecoder.decode(buffer)
|
|
|
|
// 4. Return output.
|
|
return output
|
|
}
|
|
|
|
class EnvironmentSettingsObjectBase {
|
|
get baseUrl () {
|
|
return getGlobalOrigin()
|
|
}
|
|
|
|
get origin () {
|
|
return this.baseUrl?.origin
|
|
}
|
|
|
|
policyContainer = makePolicyContainer()
|
|
}
|
|
|
|
class EnvironmentSettingsObject {
|
|
settingsObject = new EnvironmentSettingsObjectBase()
|
|
}
|
|
|
|
const environmentSettingsObject = new EnvironmentSettingsObject()
|
|
|
|
module.exports = {
|
|
isAborted,
|
|
isCancelled,
|
|
isValidEncodedURL,
|
|
createDeferredPromise,
|
|
ReadableStreamFrom,
|
|
tryUpgradeRequestToAPotentiallyTrustworthyURL,
|
|
clampAndCoarsenConnectionTimingInfo,
|
|
coarsenedSharedCurrentTime,
|
|
determineRequestsReferrer,
|
|
makePolicyContainer,
|
|
clonePolicyContainer,
|
|
appendFetchMetadata,
|
|
appendRequestOriginHeader,
|
|
TAOCheck,
|
|
corsCheck,
|
|
crossOriginResourcePolicyCheck,
|
|
createOpaqueTimingInfo,
|
|
setRequestReferrerPolicyOnRedirect,
|
|
isValidHTTPToken,
|
|
requestBadPort,
|
|
requestCurrentURL,
|
|
responseURL,
|
|
responseLocationURL,
|
|
isBlobLike,
|
|
isURLPotentiallyTrustworthy,
|
|
isValidReasonPhrase,
|
|
sameOrigin,
|
|
normalizeMethod,
|
|
serializeJavascriptValueToJSONString,
|
|
iteratorMixin,
|
|
createIterator,
|
|
isValidHeaderName,
|
|
isValidHeaderValue,
|
|
isErrorLike,
|
|
fullyReadBody,
|
|
bytesMatch,
|
|
isReadableStreamLike,
|
|
readableStreamClose,
|
|
isomorphicEncode,
|
|
urlIsLocal,
|
|
urlHasHttpsScheme,
|
|
urlIsHttpHttpsScheme,
|
|
readAllBytes,
|
|
simpleRangeHeaderValue,
|
|
buildContentRange,
|
|
parseMetadata,
|
|
createInflate,
|
|
extractMimeType,
|
|
getDecodeSplit,
|
|
utf8DecodeBytes,
|
|
environmentSettingsObject
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5893:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { types, inspect } = __nccwpck_require__(7975)
|
|
const { markAsUncloneable } = __nccwpck_require__(5919)
|
|
const { toUSVString } = __nccwpck_require__(3440)
|
|
|
|
/** @type {import('../../../types/webidl').Webidl} */
|
|
const 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}.`
|
|
})
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#implements
|
|
webidl.brandCheck = function (V, I, opts) {
|
|
if (opts?.strict !== false) {
|
|
if (!(V instanceof I)) {
|
|
const err = new TypeError('Illegal invocation')
|
|
err.code = 'ERR_INVALID_THIS' // node compat.
|
|
throw err
|
|
}
|
|
} else {
|
|
if (V?.[Symbol.toStringTag] !== I.prototype[Symbol.toStringTag]) {
|
|
const err = new TypeError('Illegal invocation')
|
|
err.code = 'ERR_INVALID_THIS' // node compat.
|
|
throw err
|
|
}
|
|
}
|
|
}
|
|
|
|
webidl.argumentLengthCheck = function ({ length }, min, ctx) {
|
|
if (length < min) {
|
|
throw webidl.errors.exception({
|
|
message: `${min} argument${min !== 1 ? 's' : ''} required, ` +
|
|
`but${length ? ' only' : ''} ${length} found.`,
|
|
header: ctx
|
|
})
|
|
}
|
|
}
|
|
|
|
webidl.illegalConstructor = function () {
|
|
throw webidl.errors.exception({
|
|
header: 'TypeError',
|
|
message: 'Illegal constructor'
|
|
})
|
|
}
|
|
|
|
// https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
|
|
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.markAsUncloneable = markAsUncloneable || (() => {})
|
|
// https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
|
|
webidl.util.ConvertToInt = function (V, bitLength, signedness, opts) {
|
|
let upperBound
|
|
let lowerBound
|
|
|
|
// 1. If bitLength is 64, then:
|
|
if (bitLength === 64) {
|
|
// 1. Let upperBound be 2^53 − 1.
|
|
upperBound = Math.pow(2, 53) - 1
|
|
|
|
// 2. If signedness is "unsigned", then let lowerBound be 0.
|
|
if (signedness === 'unsigned') {
|
|
lowerBound = 0
|
|
} else {
|
|
// 3. Otherwise let lowerBound be −2^53 + 1.
|
|
lowerBound = Math.pow(-2, 53) + 1
|
|
}
|
|
} else if (signedness === 'unsigned') {
|
|
// 2. Otherwise, if signedness is "unsigned", then:
|
|
|
|
// 1. Let lowerBound be 0.
|
|
lowerBound = 0
|
|
|
|
// 2. Let upperBound be 2^bitLength − 1.
|
|
upperBound = Math.pow(2, bitLength) - 1
|
|
} else {
|
|
// 3. Otherwise:
|
|
|
|
// 1. Let lowerBound be -2^bitLength − 1.
|
|
lowerBound = Math.pow(-2, bitLength) - 1
|
|
|
|
// 2. Let upperBound be 2^bitLength − 1 − 1.
|
|
upperBound = Math.pow(2, bitLength - 1) - 1
|
|
}
|
|
|
|
// 4. Let x be ? ToNumber(V).
|
|
let x = Number(V)
|
|
|
|
// 5. If x is −0, then set x to +0.
|
|
if (x === 0) {
|
|
x = 0
|
|
}
|
|
|
|
// 6. If the conversion is to an IDL type associated
|
|
// with the [EnforceRange] extended attribute, then:
|
|
if (opts?.enforceRange === true) {
|
|
// 1. If x is NaN, +∞, or −∞, then throw a TypeError.
|
|
if (
|
|
Number.isNaN(x) ||
|
|
x === Number.POSITIVE_INFINITY ||
|
|
x === Number.NEGATIVE_INFINITY
|
|
) {
|
|
throw webidl.errors.exception({
|
|
header: 'Integer conversion',
|
|
message: `Could not convert ${webidl.util.Stringify(V)} to an integer.`
|
|
})
|
|
}
|
|
|
|
// 2. Set x to IntegerPart(x).
|
|
x = webidl.util.IntegerPart(x)
|
|
|
|
// 3. If x < lowerBound or x > upperBound, then
|
|
// throw a TypeError.
|
|
if (x < lowerBound || x > upperBound) {
|
|
throw webidl.errors.exception({
|
|
header: 'Integer conversion',
|
|
message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.`
|
|
})
|
|
}
|
|
|
|
// 4. Return x.
|
|
return x
|
|
}
|
|
|
|
// 7. If x is not NaN and the conversion is to an IDL
|
|
// type associated with the [Clamp] extended
|
|
// attribute, then:
|
|
if (!Number.isNaN(x) && opts?.clamp === true) {
|
|
// 1. Set x to min(max(x, lowerBound), upperBound).
|
|
x = Math.min(Math.max(x, lowerBound), upperBound)
|
|
|
|
// 2. Round x to the nearest integer, choosing the
|
|
// even integer if it lies halfway between two,
|
|
// and choosing +0 rather than −0.
|
|
if (Math.floor(x) % 2 === 0) {
|
|
x = Math.floor(x)
|
|
} else {
|
|
x = Math.ceil(x)
|
|
}
|
|
|
|
// 3. Return x.
|
|
return x
|
|
}
|
|
|
|
// 8. If x is NaN, +0, +∞, or −∞, then return +0.
|
|
if (
|
|
Number.isNaN(x) ||
|
|
(x === 0 && Object.is(0, x)) ||
|
|
x === Number.POSITIVE_INFINITY ||
|
|
x === Number.NEGATIVE_INFINITY
|
|
) {
|
|
return 0
|
|
}
|
|
|
|
// 9. Set x to IntegerPart(x).
|
|
x = webidl.util.IntegerPart(x)
|
|
|
|
// 10. Set x to x modulo 2^bitLength.
|
|
x = x % Math.pow(2, bitLength)
|
|
|
|
// 11. If signedness is "signed" and x ≥ 2^bitLength − 1,
|
|
// then return x − 2^bitLength.
|
|
if (signedness === 'signed' && x >= Math.pow(2, bitLength) - 1) {
|
|
return x - Math.pow(2, bitLength)
|
|
}
|
|
|
|
// 12. Otherwise, return x.
|
|
return x
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#abstract-opdef-integerpart
|
|
webidl.util.IntegerPart = function (n) {
|
|
// 1. Let r be floor(abs(n)).
|
|
const r = Math.floor(Math.abs(n))
|
|
|
|
// 2. If n < 0, then return -1 × r.
|
|
if (n < 0) {
|
|
return -1 * r
|
|
}
|
|
|
|
// 3. Otherwise, return r.
|
|
return r
|
|
}
|
|
|
|
webidl.util.Stringify = function (V) {
|
|
const type = webidl.util.Type(V)
|
|
|
|
switch (type) {
|
|
case 'Symbol':
|
|
return `Symbol(${V.description})`
|
|
case 'Object':
|
|
return inspect(V)
|
|
case 'String':
|
|
return `"${V}"`
|
|
default:
|
|
return `${V}`
|
|
}
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#es-sequence
|
|
webidl.sequenceConverter = function (converter) {
|
|
return (V, prefix, argument, Iterable) => {
|
|
// 1. If Type(V) is not Object, throw a TypeError.
|
|
if (webidl.util.Type(V) !== 'Object') {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: `${argument} (${webidl.util.Stringify(V)}) is not iterable.`
|
|
})
|
|
}
|
|
|
|
// 2. Let method be ? GetMethod(V, @@iterator).
|
|
/** @type {Generator} */
|
|
const method = typeof Iterable === 'function' ? Iterable() : V?.[Symbol.iterator]?.()
|
|
const seq = []
|
|
let index = 0
|
|
|
|
// 3. If method is undefined, throw a TypeError.
|
|
if (
|
|
method === undefined ||
|
|
typeof method.next !== 'function'
|
|
) {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: `${argument} is not iterable.`
|
|
})
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#create-sequence-from-iterable
|
|
while (true) {
|
|
const { done, value } = method.next()
|
|
|
|
if (done) {
|
|
break
|
|
}
|
|
|
|
seq.push(converter(value, prefix, `${argument}[${index++}]`))
|
|
}
|
|
|
|
return seq
|
|
}
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#es-to-record
|
|
webidl.recordConverter = function (keyConverter, valueConverter) {
|
|
return (O, prefix, argument) => {
|
|
// 1. If Type(O) is not Object, throw a TypeError.
|
|
if (webidl.util.Type(O) !== 'Object') {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: `${argument} ("${webidl.util.Type(O)}") is not an Object.`
|
|
})
|
|
}
|
|
|
|
// 2. Let result be a new empty instance of record<K, V>.
|
|
const result = {}
|
|
|
|
if (!types.isProxy(O)) {
|
|
// 1. Let desc be ? O.[[GetOwnProperty]](key).
|
|
const keys = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)]
|
|
|
|
for (const key of keys) {
|
|
// 1. Let typedKey be key converted to an IDL value of type K.
|
|
const typedKey = keyConverter(key, prefix, argument)
|
|
|
|
// 2. Let value be ? Get(O, key).
|
|
// 3. Let typedValue be value converted to an IDL value of type V.
|
|
const typedValue = valueConverter(O[key], prefix, argument)
|
|
|
|
// 4. Set result[typedKey] to typedValue.
|
|
result[typedKey] = typedValue
|
|
}
|
|
|
|
// 5. Return result.
|
|
return result
|
|
}
|
|
|
|
// 3. Let keys be ? O.[[OwnPropertyKeys]]().
|
|
const keys = Reflect.ownKeys(O)
|
|
|
|
// 4. For each key of keys.
|
|
for (const key of keys) {
|
|
// 1. Let desc be ? O.[[GetOwnProperty]](key).
|
|
const desc = Reflect.getOwnPropertyDescriptor(O, key)
|
|
|
|
// 2. If desc is not undefined and desc.[[Enumerable]] is true:
|
|
if (desc?.enumerable) {
|
|
// 1. Let typedKey be key converted to an IDL value of type K.
|
|
const typedKey = keyConverter(key, prefix, argument)
|
|
|
|
// 2. Let value be ? Get(O, key).
|
|
// 3. Let typedValue be value converted to an IDL value of type V.
|
|
const typedValue = valueConverter(O[key], prefix, argument)
|
|
|
|
// 4. Set result[typedKey] to typedValue.
|
|
result[typedKey] = typedValue
|
|
}
|
|
}
|
|
|
|
// 5. Return result.
|
|
return result
|
|
}
|
|
}
|
|
|
|
webidl.interfaceConverter = function (i) {
|
|
return (V, prefix, argument, opts) => {
|
|
if (opts?.strict !== false && !(V instanceof i)) {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: `Expected ${argument} ("${webidl.util.Stringify(V)}") to be an instance of ${i.name}.`
|
|
})
|
|
}
|
|
|
|
return V
|
|
}
|
|
}
|
|
|
|
webidl.dictionaryConverter = function (converters) {
|
|
return (dictionary, prefix, argument) => {
|
|
const type = webidl.util.Type(dictionary)
|
|
const dict = {}
|
|
|
|
if (type === 'Null' || type === 'Undefined') {
|
|
return dict
|
|
} else if (type !== 'Object') {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
|
|
})
|
|
}
|
|
|
|
for (const options of converters) {
|
|
const { key, defaultValue, required, converter } = options
|
|
|
|
if (required === true) {
|
|
if (!Object.hasOwn(dictionary, key)) {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: `Missing required key "${key}".`
|
|
})
|
|
}
|
|
}
|
|
|
|
let value = dictionary[key]
|
|
const hasDefault = Object.hasOwn(options, 'defaultValue')
|
|
|
|
// Only use defaultValue if value is undefined and
|
|
// a defaultValue options was provided.
|
|
if (hasDefault && value !== null) {
|
|
value ??= defaultValue()
|
|
}
|
|
|
|
// A key can be optional and have no default value.
|
|
// When this happens, do not perform a conversion,
|
|
// and do not assign the key a value.
|
|
if (required || hasDefault || value !== undefined) {
|
|
value = converter(value, prefix, `${argument}.${key}`)
|
|
|
|
if (
|
|
options.allowedValues &&
|
|
!options.allowedValues.includes(value)
|
|
) {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(', ')}.`
|
|
})
|
|
}
|
|
|
|
dict[key] = value
|
|
}
|
|
}
|
|
|
|
return dict
|
|
}
|
|
}
|
|
|
|
webidl.nullableConverter = function (converter) {
|
|
return (V, prefix, argument) => {
|
|
if (V === null) {
|
|
return V
|
|
}
|
|
|
|
return converter(V, prefix, argument)
|
|
}
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#es-DOMString
|
|
webidl.converters.DOMString = function (V, prefix, argument, opts) {
|
|
// 1. If V is null and the conversion is to an IDL type
|
|
// associated with the [LegacyNullToEmptyString]
|
|
// extended attribute, then return the DOMString value
|
|
// that represents the empty string.
|
|
if (V === null && opts?.legacyNullToEmptyString) {
|
|
return ''
|
|
}
|
|
|
|
// 2. Let x be ? ToString(V).
|
|
if (typeof V === 'symbol') {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: `${argument} is a symbol, which cannot be converted to a DOMString.`
|
|
})
|
|
}
|
|
|
|
// 3. Return the IDL DOMString value that represents the
|
|
// same sequence of code units as the one the
|
|
// ECMAScript String value x represents.
|
|
return String(V)
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#es-ByteString
|
|
webidl.converters.ByteString = function (V, prefix, argument) {
|
|
// 1. Let x be ? ToString(V).
|
|
// Note: DOMString converter perform ? ToString(V)
|
|
const x = webidl.converters.DOMString(V, prefix, argument)
|
|
|
|
// 2. If the value of any element of x is greater than
|
|
// 255, then throw a TypeError.
|
|
for (let index = 0; index < x.length; index++) {
|
|
if (x.charCodeAt(index) > 255) {
|
|
throw new TypeError(
|
|
'Cannot convert argument to a ByteString because the character at ' +
|
|
`index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.`
|
|
)
|
|
}
|
|
}
|
|
|
|
// 3. Return an IDL ByteString value whose length is the
|
|
// length of x, and where the value of each element is
|
|
// the value of the corresponding element of x.
|
|
return x
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#es-USVString
|
|
// TODO: rewrite this so we can control the errors thrown
|
|
webidl.converters.USVString = toUSVString
|
|
|
|
// https://webidl.spec.whatwg.org/#es-boolean
|
|
webidl.converters.boolean = function (V) {
|
|
// 1. Let x be the result of computing ToBoolean(V).
|
|
const x = Boolean(V)
|
|
|
|
// 2. Return the IDL boolean value that is the one that represents
|
|
// the same truth value as the ECMAScript Boolean value x.
|
|
return x
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#es-any
|
|
webidl.converters.any = function (V) {
|
|
return V
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#es-long-long
|
|
webidl.converters['long long'] = function (V, prefix, argument) {
|
|
// 1. Let x be ? ConvertToInt(V, 64, "signed").
|
|
const x = webidl.util.ConvertToInt(V, 64, 'signed', undefined, prefix, argument)
|
|
|
|
// 2. Return the IDL long long value that represents
|
|
// the same numeric value as x.
|
|
return x
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#es-unsigned-long-long
|
|
webidl.converters['unsigned long long'] = function (V, prefix, argument) {
|
|
// 1. Let x be ? ConvertToInt(V, 64, "unsigned").
|
|
const x = webidl.util.ConvertToInt(V, 64, 'unsigned', undefined, prefix, argument)
|
|
|
|
// 2. Return the IDL unsigned long long value that
|
|
// represents the same numeric value as x.
|
|
return x
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#es-unsigned-long
|
|
webidl.converters['unsigned long'] = function (V, prefix, argument) {
|
|
// 1. Let x be ? ConvertToInt(V, 32, "unsigned").
|
|
const x = webidl.util.ConvertToInt(V, 32, 'unsigned', undefined, prefix, argument)
|
|
|
|
// 2. Return the IDL unsigned long value that
|
|
// represents the same numeric value as x.
|
|
return x
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#es-unsigned-short
|
|
webidl.converters['unsigned short'] = function (V, prefix, argument, opts) {
|
|
// 1. Let x be ? ConvertToInt(V, 16, "unsigned").
|
|
const x = webidl.util.ConvertToInt(V, 16, 'unsigned', opts, prefix, argument)
|
|
|
|
// 2. Return the IDL unsigned short value that represents
|
|
// the same numeric value as x.
|
|
return x
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#idl-ArrayBuffer
|
|
webidl.converters.ArrayBuffer = function (V, prefix, argument, opts) {
|
|
// 1. If Type(V) is not Object, or V does not have an
|
|
// [[ArrayBufferData]] internal slot, then throw a
|
|
// TypeError.
|
|
// see: https://tc39.es/ecma262/#sec-properties-of-the-arraybuffer-instances
|
|
// see: https://tc39.es/ecma262/#sec-properties-of-the-sharedarraybuffer-instances
|
|
if (
|
|
webidl.util.Type(V) !== 'Object' ||
|
|
!types.isAnyArrayBuffer(V)
|
|
) {
|
|
throw webidl.errors.conversionFailed({
|
|
prefix,
|
|
argument: `${argument} ("${webidl.util.Stringify(V)}")`,
|
|
types: ['ArrayBuffer']
|
|
})
|
|
}
|
|
|
|
// 2. If the conversion is not to an IDL type associated
|
|
// with the [AllowShared] extended attribute, and
|
|
// IsSharedArrayBuffer(V) is true, then throw a
|
|
// TypeError.
|
|
if (opts?.allowShared === false && types.isSharedArrayBuffer(V)) {
|
|
throw webidl.errors.exception({
|
|
header: 'ArrayBuffer',
|
|
message: 'SharedArrayBuffer is not allowed.'
|
|
})
|
|
}
|
|
|
|
// 3. If the conversion is not to an IDL type associated
|
|
// with the [AllowResizable] extended attribute, and
|
|
// IsResizableArrayBuffer(V) is true, then throw a
|
|
// TypeError.
|
|
if (V.resizable || V.growable) {
|
|
throw webidl.errors.exception({
|
|
header: 'ArrayBuffer',
|
|
message: 'Received a resizable ArrayBuffer.'
|
|
})
|
|
}
|
|
|
|
// 4. Return the IDL ArrayBuffer value that is a
|
|
// reference to the same object as V.
|
|
return V
|
|
}
|
|
|
|
webidl.converters.TypedArray = function (V, T, prefix, name, opts) {
|
|
// 1. Let T be the IDL type V is being converted to.
|
|
|
|
// 2. If Type(V) is not Object, or V does not have a
|
|
// [[TypedArrayName]] internal slot with a value
|
|
// equal to T’s name, then throw a TypeError.
|
|
if (
|
|
webidl.util.Type(V) !== 'Object' ||
|
|
!types.isTypedArray(V) ||
|
|
V.constructor.name !== T.name
|
|
) {
|
|
throw webidl.errors.conversionFailed({
|
|
prefix,
|
|
argument: `${name} ("${webidl.util.Stringify(V)}")`,
|
|
types: [T.name]
|
|
})
|
|
}
|
|
|
|
// 3. If the conversion is not to an IDL type associated
|
|
// with the [AllowShared] extended attribute, and
|
|
// IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is
|
|
// true, then throw a TypeError.
|
|
if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
|
|
throw webidl.errors.exception({
|
|
header: 'ArrayBuffer',
|
|
message: 'SharedArrayBuffer is not allowed.'
|
|
})
|
|
}
|
|
|
|
// 4. If the conversion is not to an IDL type associated
|
|
// with the [AllowResizable] extended attribute, and
|
|
// IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is
|
|
// true, then throw a TypeError.
|
|
if (V.buffer.resizable || V.buffer.growable) {
|
|
throw webidl.errors.exception({
|
|
header: 'ArrayBuffer',
|
|
message: 'Received a resizable ArrayBuffer.'
|
|
})
|
|
}
|
|
|
|
// 5. Return the IDL value of type T that is a reference
|
|
// to the same object as V.
|
|
return V
|
|
}
|
|
|
|
webidl.converters.DataView = function (V, prefix, name, opts) {
|
|
// 1. If Type(V) is not Object, or V does not have a
|
|
// [[DataView]] internal slot, then throw a TypeError.
|
|
if (webidl.util.Type(V) !== 'Object' || !types.isDataView(V)) {
|
|
throw webidl.errors.exception({
|
|
header: prefix,
|
|
message: `${name} is not a DataView.`
|
|
})
|
|
}
|
|
|
|
// 2. If the conversion is not to an IDL type associated
|
|
// with the [AllowShared] extended attribute, and
|
|
// IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is true,
|
|
// then throw a TypeError.
|
|
if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
|
|
throw webidl.errors.exception({
|
|
header: 'ArrayBuffer',
|
|
message: 'SharedArrayBuffer is not allowed.'
|
|
})
|
|
}
|
|
|
|
// 3. If the conversion is not to an IDL type associated
|
|
// with the [AllowResizable] extended attribute, and
|
|
// IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is
|
|
// true, then throw a TypeError.
|
|
if (V.buffer.resizable || V.buffer.growable) {
|
|
throw webidl.errors.exception({
|
|
header: 'ArrayBuffer',
|
|
message: 'Received a resizable ArrayBuffer.'
|
|
})
|
|
}
|
|
|
|
// 4. Return the IDL DataView value that is a reference
|
|
// to the same object as V.
|
|
return V
|
|
}
|
|
|
|
// https://webidl.spec.whatwg.org/#BufferSource
|
|
webidl.converters.BufferSource = function (V, prefix, name, opts) {
|
|
if (types.isAnyArrayBuffer(V)) {
|
|
return webidl.converters.ArrayBuffer(V, prefix, name, { ...opts, allowShared: false })
|
|
}
|
|
|
|
if (types.isTypedArray(V)) {
|
|
return webidl.converters.TypedArray(V, V.constructor, prefix, name, { ...opts, allowShared: false })
|
|
}
|
|
|
|
if (types.isDataView(V)) {
|
|
return webidl.converters.DataView(V, prefix, name, { ...opts, allowShared: false })
|
|
}
|
|
|
|
throw webidl.errors.conversionFailed({
|
|
prefix,
|
|
argument: `${name} ("${webidl.util.Stringify(V)}")`,
|
|
types: ['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
|
|
)
|
|
|
|
module.exports = {
|
|
webidl
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2607:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
/**
|
|
* @see https://encoding.spec.whatwg.org/#concept-encoding-get
|
|
* @param {string|undefined} label
|
|
*/
|
|
function getEncoding (label) {
|
|
if (!label) {
|
|
return 'failure'
|
|
}
|
|
|
|
// 1. Remove any leading and trailing ASCII whitespace from label.
|
|
// 2. If label is an ASCII case-insensitive match for any of the
|
|
// labels listed in the table below, then return the
|
|
// corresponding encoding; otherwise return failure.
|
|
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'
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
getEncoding
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8355:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const {
|
|
staticPropertyDescriptors,
|
|
readOperation,
|
|
fireAProgressEvent
|
|
} = __nccwpck_require__(3610)
|
|
const {
|
|
kState,
|
|
kError,
|
|
kResult,
|
|
kEvents,
|
|
kAborted
|
|
} = __nccwpck_require__(961)
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const { kEnumerableProperty } = __nccwpck_require__(3440)
|
|
|
|
class FileReader 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, 'FileReader.readAsArrayBuffer')
|
|
|
|
blob = webidl.converters.Blob(blob, { strict: false })
|
|
|
|
// The readAsArrayBuffer(blob) method, when invoked,
|
|
// must initiate a read operation for blob with ArrayBuffer.
|
|
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, 'FileReader.readAsBinaryString')
|
|
|
|
blob = webidl.converters.Blob(blob, { strict: false })
|
|
|
|
// The readAsBinaryString(blob) method, when invoked,
|
|
// must initiate a read operation for blob with BinaryString.
|
|
readOperation(this, blob, 'BinaryString')
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#readAsDataText
|
|
* @param {import('buffer').Blob} blob
|
|
* @param {string?} encoding
|
|
*/
|
|
readAsText (blob, encoding = undefined) {
|
|
webidl.brandCheck(this, FileReader)
|
|
|
|
webidl.argumentLengthCheck(arguments, 1, 'FileReader.readAsText')
|
|
|
|
blob = webidl.converters.Blob(blob, { strict: false })
|
|
|
|
if (encoding !== undefined) {
|
|
encoding = webidl.converters.DOMString(encoding, 'FileReader.readAsText', 'encoding')
|
|
}
|
|
|
|
// The readAsText(blob, encoding) method, when invoked,
|
|
// must initiate a read operation for blob with Text and 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, 'FileReader.readAsDataURL')
|
|
|
|
blob = webidl.converters.Blob(blob, { strict: false })
|
|
|
|
// The readAsDataURL(blob) method, when invoked, must
|
|
// initiate a read operation for blob with DataURL.
|
|
readOperation(this, blob, 'DataURL')
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#dfn-abort
|
|
*/
|
|
abort () {
|
|
// 1. If this's state is "empty" or if this's state is
|
|
// "done" set this's result to null and terminate
|
|
// this algorithm.
|
|
if (this[kState] === 'empty' || this[kState] === 'done') {
|
|
this[kResult] = null
|
|
return
|
|
}
|
|
|
|
// 2. If this's state is "loading" set this's state to
|
|
// "done" and set this's result to null.
|
|
if (this[kState] === 'loading') {
|
|
this[kState] = 'done'
|
|
this[kResult] = null
|
|
}
|
|
|
|
// 3. If there are any tasks from this on the file reading
|
|
// task source in an affiliated task queue, then remove
|
|
// those tasks from that task queue.
|
|
this[kAborted] = true
|
|
|
|
// 4. Terminate the algorithm for the read method being processed.
|
|
// TODO
|
|
|
|
// 5. Fire a progress event called abort at this.
|
|
fireAProgressEvent('abort', this)
|
|
|
|
// 6. If this's state is not "loading", fire a progress
|
|
// event called loadend at 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)
|
|
|
|
// The result attribute’s getter, when invoked, must return
|
|
// this's result.
|
|
return this[kResult]
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#dom-filereader-error
|
|
*/
|
|
get error () {
|
|
webidl.brandCheck(this, FileReader)
|
|
|
|
// The error attribute’s getter, when invoked, must return
|
|
// this's error.
|
|
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
|
|
}
|
|
}
|
|
}
|
|
|
|
// https://w3c.github.io/FileAPI/#dom-filereader-empty
|
|
FileReader.EMPTY = FileReader.prototype.EMPTY = 0
|
|
// https://w3c.github.io/FileAPI/#dom-filereader-loading
|
|
FileReader.LOADING = FileReader.prototype.LOADING = 1
|
|
// https://w3c.github.io/FileAPI/#dom-filereader-done
|
|
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
|
|
})
|
|
|
|
module.exports = {
|
|
FileReader
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8573:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
|
|
const kState = Symbol('ProgressEvent state')
|
|
|
|
/**
|
|
* @see https://xhr.spec.whatwg.org/#progressevent
|
|
*/
|
|
class ProgressEvent extends Event {
|
|
constructor (type, eventInitDict = {}) {
|
|
type = webidl.converters.DOMString(type, 'ProgressEvent constructor', '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
|
|
}
|
|
])
|
|
|
|
module.exports = {
|
|
ProgressEvent
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 961:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
module.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')
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3610:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const {
|
|
kState,
|
|
kError,
|
|
kResult,
|
|
kAborted,
|
|
kLastProgressEventFired
|
|
} = __nccwpck_require__(961)
|
|
const { ProgressEvent } = __nccwpck_require__(8573)
|
|
const { getEncoding } = __nccwpck_require__(2607)
|
|
const { serializeAMimeType, parseMIMEType } = __nccwpck_require__(1900)
|
|
const { types } = __nccwpck_require__(7975)
|
|
const { StringDecoder } = __nccwpck_require__(3193)
|
|
const { btoa } = __nccwpck_require__(4573)
|
|
|
|
/** @type {PropertyDescriptor} */
|
|
const staticPropertyDescriptors = {
|
|
enumerable: true,
|
|
writable: false,
|
|
configurable: false
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#readOperation
|
|
* @param {import('./filereader').FileReader} fr
|
|
* @param {import('buffer').Blob} blob
|
|
* @param {string} type
|
|
* @param {string?} encodingName
|
|
*/
|
|
function readOperation (fr, blob, type, encodingName) {
|
|
// 1. If fr’s state is "loading", throw an InvalidStateError
|
|
// DOMException.
|
|
if (fr[kState] === 'loading') {
|
|
throw new DOMException('Invalid state', 'InvalidStateError')
|
|
}
|
|
|
|
// 2. Set fr’s state to "loading".
|
|
fr[kState] = 'loading'
|
|
|
|
// 3. Set fr’s result to null.
|
|
fr[kResult] = null
|
|
|
|
// 4. Set fr’s error to null.
|
|
fr[kError] = null
|
|
|
|
// 5. Let stream be the result of calling get stream on blob.
|
|
/** @type {import('stream/web').ReadableStream} */
|
|
const stream = blob.stream()
|
|
|
|
// 6. Let reader be the result of getting a reader from stream.
|
|
const reader = stream.getReader()
|
|
|
|
// 7. Let bytes be an empty byte sequence.
|
|
/** @type {Uint8Array[]} */
|
|
const bytes = []
|
|
|
|
// 8. Let chunkPromise be the result of reading a chunk from
|
|
// stream with reader.
|
|
let chunkPromise = reader.read()
|
|
|
|
// 9. Let isFirstChunk be true.
|
|
let isFirstChunk = true
|
|
|
|
// 10. In parallel, while true:
|
|
// Note: "In parallel" just means non-blocking
|
|
// Note 2: readOperation itself cannot be async as double
|
|
// reading the body would then reject the promise, instead
|
|
// of throwing an error.
|
|
;(async () => {
|
|
while (!fr[kAborted]) {
|
|
// 1. Wait for chunkPromise to be fulfilled or rejected.
|
|
try {
|
|
const { done, value } = await chunkPromise
|
|
|
|
// 2. If chunkPromise is fulfilled, and isFirstChunk is
|
|
// true, queue a task to fire a progress event called
|
|
// loadstart at fr.
|
|
if (isFirstChunk && !fr[kAborted]) {
|
|
queueMicrotask(() => {
|
|
fireAProgressEvent('loadstart', fr)
|
|
})
|
|
}
|
|
|
|
// 3. Set isFirstChunk to false.
|
|
isFirstChunk = false
|
|
|
|
// 4. If chunkPromise is fulfilled with an object whose
|
|
// done property is false and whose value property is
|
|
// a Uint8Array object, run these steps:
|
|
if (!done && types.isUint8Array(value)) {
|
|
// 1. Let bs be the byte sequence represented by the
|
|
// Uint8Array object.
|
|
|
|
// 2. Append bs to bytes.
|
|
bytes.push(value)
|
|
|
|
// 3. If roughly 50ms have passed since these steps
|
|
// were last invoked, queue a task to fire a
|
|
// progress event called progress at fr.
|
|
if (
|
|
(
|
|
fr[kLastProgressEventFired] === undefined ||
|
|
Date.now() - fr[kLastProgressEventFired] >= 50
|
|
) &&
|
|
!fr[kAborted]
|
|
) {
|
|
fr[kLastProgressEventFired] = Date.now()
|
|
queueMicrotask(() => {
|
|
fireAProgressEvent('progress', fr)
|
|
})
|
|
}
|
|
|
|
// 4. Set chunkPromise to the result of reading a
|
|
// chunk from stream with reader.
|
|
chunkPromise = reader.read()
|
|
} else if (done) {
|
|
// 5. Otherwise, if chunkPromise is fulfilled with an
|
|
// object whose done property is true, queue a task
|
|
// to run the following steps and abort this algorithm:
|
|
queueMicrotask(() => {
|
|
// 1. Set fr’s state to "done".
|
|
fr[kState] = 'done'
|
|
|
|
// 2. Let result be the result of package data given
|
|
// bytes, type, blob’s type, and encodingName.
|
|
try {
|
|
const result = packageData(bytes, type, blob.type, encodingName)
|
|
|
|
// 4. Else:
|
|
|
|
if (fr[kAborted]) {
|
|
return
|
|
}
|
|
|
|
// 1. Set fr’s result to result.
|
|
fr[kResult] = result
|
|
|
|
// 2. Fire a progress event called load at the fr.
|
|
fireAProgressEvent('load', fr)
|
|
} catch (error) {
|
|
// 3. If package data threw an exception error:
|
|
|
|
// 1. Set fr’s error to error.
|
|
fr[kError] = error
|
|
|
|
// 2. Fire a progress event called error at fr.
|
|
fireAProgressEvent('error', fr)
|
|
}
|
|
|
|
// 5. If fr’s state is not "loading", fire a progress
|
|
// event called loadend at the fr.
|
|
if (fr[kState] !== 'loading') {
|
|
fireAProgressEvent('loadend', fr)
|
|
}
|
|
})
|
|
|
|
break
|
|
}
|
|
} catch (error) {
|
|
if (fr[kAborted]) {
|
|
return
|
|
}
|
|
|
|
// 6. Otherwise, if chunkPromise is rejected with an
|
|
// error error, queue a task to run the following
|
|
// steps and abort this algorithm:
|
|
queueMicrotask(() => {
|
|
// 1. Set fr’s state to "done".
|
|
fr[kState] = 'done'
|
|
|
|
// 2. Set fr’s error to error.
|
|
fr[kError] = error
|
|
|
|
// 3. Fire a progress event called error at fr.
|
|
fireAProgressEvent('error', fr)
|
|
|
|
// 4. If fr’s state is not "loading", fire a progress
|
|
// event called loadend at fr.
|
|
if (fr[kState] !== 'loading') {
|
|
fireAProgressEvent('loadend', fr)
|
|
}
|
|
})
|
|
|
|
break
|
|
}
|
|
}
|
|
})()
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#fire-a-progress-event
|
|
* @see https://dom.spec.whatwg.org/#concept-event-fire
|
|
* @param {string} e The name of the event
|
|
* @param {import('./filereader').FileReader} reader
|
|
*/
|
|
function fireAProgressEvent (e, reader) {
|
|
// The progress event e does not bubble. e.bubbles must be false
|
|
// The progress event e is NOT cancelable. e.cancelable must be false
|
|
const event = new ProgressEvent(e, {
|
|
bubbles: false,
|
|
cancelable: false
|
|
})
|
|
|
|
reader.dispatchEvent(event)
|
|
}
|
|
|
|
/**
|
|
* @see https://w3c.github.io/FileAPI/#blob-package-data
|
|
* @param {Uint8Array[]} bytes
|
|
* @param {string} type
|
|
* @param {string?} mimeType
|
|
* @param {string?} encodingName
|
|
*/
|
|
function packageData (bytes, type, mimeType, encodingName) {
|
|
// 1. A Blob has an associated package data algorithm, given
|
|
// bytes, a type, a optional mimeType, and a optional
|
|
// encodingName, which switches on type and runs the
|
|
// associated steps:
|
|
|
|
switch (type) {
|
|
case 'DataURL': {
|
|
// 1. Return bytes as a DataURL [RFC2397] subject to
|
|
// the considerations below:
|
|
// * Use mimeType as part of the Data URL if it is
|
|
// available in keeping with the Data URL
|
|
// specification [RFC2397].
|
|
// * If mimeType is not available return a Data URL
|
|
// without a media-type. [RFC2397].
|
|
|
|
// https://datatracker.ietf.org/doc/html/rfc2397#section-3
|
|
// dataurl := "data:" [ mediatype ] [ ";base64" ] "," data
|
|
// mediatype := [ type "/" subtype ] *( ";" parameter )
|
|
// data := *urlchar
|
|
// parameter := attribute "=" value
|
|
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': {
|
|
// 1. Let encoding be failure
|
|
let encoding = 'failure'
|
|
|
|
// 2. If the encodingName is present, set encoding to the
|
|
// result of getting an encoding from encodingName.
|
|
if (encodingName) {
|
|
encoding = getEncoding(encodingName)
|
|
}
|
|
|
|
// 3. If encoding is failure, and mimeType is present:
|
|
if (encoding === 'failure' && mimeType) {
|
|
// 1. Let type be the result of parse a MIME type
|
|
// given mimeType.
|
|
const type = parseMIMEType(mimeType)
|
|
|
|
// 2. If type is not failure, set encoding to the result
|
|
// of getting an encoding from type’s parameters["charset"].
|
|
if (type !== 'failure') {
|
|
encoding = getEncoding(type.parameters.get('charset'))
|
|
}
|
|
}
|
|
|
|
// 4. If encoding is failure, then set encoding to UTF-8.
|
|
if (encoding === 'failure') {
|
|
encoding = 'UTF-8'
|
|
}
|
|
|
|
// 5. Decode bytes using fallback encoding encoding, and
|
|
// return the result.
|
|
return decode(bytes, encoding)
|
|
}
|
|
case 'ArrayBuffer': {
|
|
// Return a new ArrayBuffer whose contents are bytes.
|
|
const sequence = combineByteSequences(bytes)
|
|
|
|
return sequence.buffer
|
|
}
|
|
case 'BinaryString': {
|
|
// Return bytes as a binary string, in which every byte
|
|
// is represented by a code unit of equal value [0..255].
|
|
let binaryString = ''
|
|
|
|
const decoder = new StringDecoder('latin1')
|
|
|
|
for (const chunk of bytes) {
|
|
binaryString += decoder.write(chunk)
|
|
}
|
|
|
|
binaryString += decoder.end()
|
|
|
|
return binaryString
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://encoding.spec.whatwg.org/#decode
|
|
* @param {Uint8Array[]} ioQueue
|
|
* @param {string} encoding
|
|
*/
|
|
function decode (ioQueue, encoding) {
|
|
const bytes = combineByteSequences(ioQueue)
|
|
|
|
// 1. Let BOMEncoding be the result of BOM sniffing ioQueue.
|
|
const BOMEncoding = BOMSniffing(bytes)
|
|
|
|
let slice = 0
|
|
|
|
// 2. If BOMEncoding is non-null:
|
|
if (BOMEncoding !== null) {
|
|
// 1. Set encoding to BOMEncoding.
|
|
encoding = BOMEncoding
|
|
|
|
// 2. Read three bytes from ioQueue, if BOMEncoding is
|
|
// UTF-8; otherwise read two bytes.
|
|
// (Do nothing with those bytes.)
|
|
slice = BOMEncoding === 'UTF-8' ? 3 : 2
|
|
}
|
|
|
|
// 3. Process a queue with an instance of encoding’s
|
|
// decoder, ioQueue, output, and "replacement".
|
|
|
|
// 4. Return output.
|
|
|
|
const sliced = bytes.slice(slice)
|
|
return new TextDecoder(encoding).decode(sliced)
|
|
}
|
|
|
|
/**
|
|
* @see https://encoding.spec.whatwg.org/#bom-sniff
|
|
* @param {Uint8Array} ioQueue
|
|
*/
|
|
function BOMSniffing (ioQueue) {
|
|
// 1. Let BOM be the result of peeking 3 bytes from ioQueue,
|
|
// converted to a byte sequence.
|
|
const [a, b, c] = ioQueue
|
|
|
|
// 2. For each of the rows in the table below, starting with
|
|
// the first one and going down, if BOM starts with the
|
|
// bytes given in the first column, then return the
|
|
// encoding given in the cell in the second column of that
|
|
// row. Otherwise, return null.
|
|
if (a === 0xEF && b === 0xBB && c === 0xBF) {
|
|
return 'UTF-8'
|
|
} else if (a === 0xFE && b === 0xFF) {
|
|
return 'UTF-16BE'
|
|
} else if (a === 0xFF && b === 0xFE) {
|
|
return 'UTF-16LE'
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
/**
|
|
* @param {Uint8Array[]} sequences
|
|
*/
|
|
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))
|
|
}
|
|
|
|
module.exports = {
|
|
staticPropertyDescriptors,
|
|
readOperation,
|
|
fireAProgressEvent
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6897:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = __nccwpck_require__(736)
|
|
const {
|
|
kReadyState,
|
|
kSentClose,
|
|
kByteParser,
|
|
kReceivedClose,
|
|
kResponse
|
|
} = __nccwpck_require__(1216)
|
|
const { fireEvent, failWebsocketConnection, isClosing, isClosed, isEstablished, parseExtensions } = __nccwpck_require__(8625)
|
|
const { channels } = __nccwpck_require__(2414)
|
|
const { CloseEvent } = __nccwpck_require__(5188)
|
|
const { makeRequest } = __nccwpck_require__(9967)
|
|
const { fetching } = __nccwpck_require__(4398)
|
|
const { Headers, getHeadersList } = __nccwpck_require__(660)
|
|
const { getDecodeSplit } = __nccwpck_require__(3168)
|
|
const { WebsocketFrameSend } = __nccwpck_require__(3264)
|
|
|
|
/** @type {import('crypto')} */
|
|
let crypto
|
|
try {
|
|
crypto = __nccwpck_require__(7598)
|
|
/* c8 ignore next 3 */
|
|
} catch {
|
|
|
|
}
|
|
|
|
/**
|
|
* @see https://websockets.spec.whatwg.org/#concept-websocket-establish
|
|
* @param {URL} url
|
|
* @param {string|string[]} protocols
|
|
* @param {import('./websocket').WebSocket} ws
|
|
* @param {(response: any, extensions: string[] | undefined) => void} onEstablish
|
|
* @param {Partial<import('../../types/websocket').WebSocketInit>} options
|
|
*/
|
|
function establishWebSocketConnection (url, protocols, client, ws, onEstablish, options) {
|
|
// 1. Let requestURL be a copy of url, with its scheme set to "http", if url’s
|
|
// scheme is "ws", and to "https" otherwise.
|
|
const requestURL = url
|
|
|
|
requestURL.protocol = url.protocol === 'ws:' ? 'http:' : 'https:'
|
|
|
|
// 2. Let request be a new request, whose URL is requestURL, client is client,
|
|
// service-workers mode is "none", referrer is "no-referrer", mode is
|
|
// "websocket", credentials mode is "include", cache mode is "no-store" ,
|
|
// and redirect mode is "error".
|
|
const request = makeRequest({
|
|
urlList: [requestURL],
|
|
client,
|
|
serviceWorkers: 'none',
|
|
referrer: 'no-referrer',
|
|
mode: 'websocket',
|
|
credentials: 'include',
|
|
cache: 'no-store',
|
|
redirect: 'error'
|
|
})
|
|
|
|
// Note: undici extension, allow setting custom headers.
|
|
if (options.headers) {
|
|
const headersList = getHeadersList(new Headers(options.headers))
|
|
|
|
request.headersList = headersList
|
|
}
|
|
|
|
// 3. Append (`Upgrade`, `websocket`) to request’s header list.
|
|
// 4. Append (`Connection`, `Upgrade`) to request’s header list.
|
|
// Note: both of these are handled by undici currently.
|
|
// https://github.com/nodejs/undici/blob/68c269c4144c446f3f1220951338daef4a6b5ec4/lib/client.js#L1397
|
|
|
|
// 5. Let keyValue be a nonce consisting of a randomly selected
|
|
// 16-byte value that has been forgiving-base64-encoded and
|
|
// isomorphic encoded.
|
|
const keyValue = crypto.randomBytes(16).toString('base64')
|
|
|
|
// 6. Append (`Sec-WebSocket-Key`, keyValue) to request’s
|
|
// header list.
|
|
request.headersList.append('sec-websocket-key', keyValue)
|
|
|
|
// 7. Append (`Sec-WebSocket-Version`, `13`) to request’s
|
|
// header list.
|
|
request.headersList.append('sec-websocket-version', '13')
|
|
|
|
// 8. For each protocol in protocols, combine
|
|
// (`Sec-WebSocket-Protocol`, protocol) in request’s header
|
|
// list.
|
|
for (const protocol of protocols) {
|
|
request.headersList.append('sec-websocket-protocol', protocol)
|
|
}
|
|
|
|
// 9. Let permessageDeflate be a user-agent defined
|
|
// "permessage-deflate" extension header value.
|
|
// https://github.com/mozilla/gecko-dev/blob/ce78234f5e653a5d3916813ff990f053510227bc/netwerk/protocol/websocket/WebSocketChannel.cpp#L2673
|
|
const permessageDeflate = 'permessage-deflate; client_max_window_bits'
|
|
|
|
// 10. Append (`Sec-WebSocket-Extensions`, permessageDeflate) to
|
|
// request’s header list.
|
|
request.headersList.append('sec-websocket-extensions', permessageDeflate)
|
|
|
|
// 11. Fetch request with useParallelQueue set to true, and
|
|
// processResponse given response being these steps:
|
|
const controller = fetching({
|
|
request,
|
|
useParallelQueue: true,
|
|
dispatcher: options.dispatcher,
|
|
processResponse (response) {
|
|
// 1. If response is a network error or its status is not 101,
|
|
// fail the WebSocket connection.
|
|
if (response.type === 'error' || response.status !== 101) {
|
|
failWebsocketConnection(ws, 'Received network error or non-101 status code.')
|
|
return
|
|
}
|
|
|
|
// 2. If protocols is not the empty list and extracting header
|
|
// list values given `Sec-WebSocket-Protocol` and response’s
|
|
// header list results in null, failure, or the empty byte
|
|
// sequence, then fail the WebSocket connection.
|
|
if (protocols.length !== 0 && !response.headersList.get('Sec-WebSocket-Protocol')) {
|
|
failWebsocketConnection(ws, 'Server did not respond with sent protocols.')
|
|
return
|
|
}
|
|
|
|
// 3. Follow the requirements stated step 2 to step 6, inclusive,
|
|
// of the last set of steps in section 4.1 of The WebSocket
|
|
// Protocol to validate response. This either results in fail
|
|
// the WebSocket connection or the WebSocket connection is
|
|
// established.
|
|
|
|
// 2. If the response lacks an |Upgrade| header field or the |Upgrade|
|
|
// header field contains a value that is not an ASCII case-
|
|
// insensitive match for the value "websocket", the client MUST
|
|
// _Fail the WebSocket Connection_.
|
|
if (response.headersList.get('Upgrade')?.toLowerCase() !== 'websocket') {
|
|
failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".')
|
|
return
|
|
}
|
|
|
|
// 3. If the response lacks a |Connection| header field or the
|
|
// |Connection| header field doesn't contain a token that is an
|
|
// ASCII case-insensitive match for the value "Upgrade", the client
|
|
// MUST _Fail the WebSocket Connection_.
|
|
if (response.headersList.get('Connection')?.toLowerCase() !== 'upgrade') {
|
|
failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".')
|
|
return
|
|
}
|
|
|
|
// 4. If the response lacks a |Sec-WebSocket-Accept| header field or
|
|
// the |Sec-WebSocket-Accept| contains a value other than the
|
|
// base64-encoded SHA-1 of the concatenation of the |Sec-WebSocket-
|
|
// Key| (as a string, not base64-decoded) with the string "258EAFA5-
|
|
// E914-47DA-95CA-C5AB0DC85B11" but ignoring any leading and
|
|
// trailing whitespace, the client MUST _Fail the WebSocket
|
|
// Connection_.
|
|
const secWSAccept = response.headersList.get('Sec-WebSocket-Accept')
|
|
const digest = crypto.createHash('sha1').update(keyValue + uid).digest('base64')
|
|
if (secWSAccept !== digest) {
|
|
failWebsocketConnection(ws, 'Incorrect hash received in Sec-WebSocket-Accept header.')
|
|
return
|
|
}
|
|
|
|
// 5. If the response includes a |Sec-WebSocket-Extensions| header
|
|
// field and this header field indicates the use of an extension
|
|
// that was not present in the client's handshake (the server has
|
|
// indicated an extension not requested by the client), the client
|
|
// MUST _Fail the WebSocket Connection_. (The parsing of this
|
|
// header field to determine which extensions are requested is
|
|
// discussed in Section 9.1.)
|
|
const secExtension = response.headersList.get('Sec-WebSocket-Extensions')
|
|
let extensions
|
|
|
|
if (secExtension !== null) {
|
|
extensions = parseExtensions(secExtension)
|
|
|
|
if (!extensions.has('permessage-deflate')) {
|
|
failWebsocketConnection(ws, 'Sec-WebSocket-Extensions header does not match.')
|
|
return
|
|
}
|
|
}
|
|
|
|
// 6. If the response includes a |Sec-WebSocket-Protocol| header field
|
|
// and this header field indicates the use of a subprotocol that was
|
|
// not present in the client's handshake (the server has indicated a
|
|
// subprotocol not requested by the client), the client MUST _Fail
|
|
// the WebSocket Connection_.
|
|
const secProtocol = response.headersList.get('Sec-WebSocket-Protocol')
|
|
|
|
if (secProtocol !== null) {
|
|
const requestProtocols = getDecodeSplit('sec-websocket-protocol', request.headersList)
|
|
|
|
// The client can request that the server use a specific subprotocol by
|
|
// including the |Sec-WebSocket-Protocol| field in its handshake. If it
|
|
// is specified, the server needs to include the same field and one of
|
|
// the selected subprotocol values in its response for the connection to
|
|
// be established.
|
|
if (!requestProtocols.includes(secProtocol)) {
|
|
failWebsocketConnection(ws, 'Protocol was not set in the opening handshake.')
|
|
return
|
|
}
|
|
}
|
|
|
|
response.socket.on('data', onSocketData)
|
|
response.socket.on('close', onSocketClose)
|
|
response.socket.on('error', onSocketError)
|
|
|
|
if (channels.open.hasSubscribers) {
|
|
channels.open.publish({
|
|
address: response.socket.address(),
|
|
protocol: secProtocol,
|
|
extensions: secExtension
|
|
})
|
|
}
|
|
|
|
onEstablish(response, extensions)
|
|
}
|
|
})
|
|
|
|
return controller
|
|
}
|
|
|
|
function closeWebSocketConnection (ws, code, reason, reasonByteLength) {
|
|
if (isClosing(ws) || isClosed(ws)) {
|
|
// If this's ready state is CLOSING (2) or CLOSED (3)
|
|
// Do nothing.
|
|
} else if (!isEstablished(ws)) {
|
|
// If the WebSocket connection is not yet established
|
|
// Fail the WebSocket connection and set this's ready state
|
|
// to CLOSING (2).
|
|
failWebsocketConnection(ws, 'Connection was closed before it was established.')
|
|
ws[kReadyState] = states.CLOSING
|
|
} else if (ws[kSentClose] === sentCloseFrameState.NOT_SENT) {
|
|
// If the WebSocket closing handshake has not yet been started
|
|
// Start the WebSocket closing handshake and set this's ready
|
|
// state to CLOSING (2).
|
|
// - If neither code nor reason is present, the WebSocket Close
|
|
// message must not have a body.
|
|
// - If code is present, then the status code to use in the
|
|
// WebSocket Close message must be the integer given by code.
|
|
// - If reason is also present, then reasonBytes must be
|
|
// provided in the Close message after the status code.
|
|
|
|
ws[kSentClose] = sentCloseFrameState.PROCESSING
|
|
|
|
const frame = new WebsocketFrameSend()
|
|
|
|
// If neither code nor reason is present, the WebSocket Close
|
|
// message must not have a body.
|
|
|
|
// If code is present, then the status code to use in the
|
|
// WebSocket Close message must be the integer given by code.
|
|
if (code !== undefined && reason === undefined) {
|
|
frame.frameData = Buffer.allocUnsafe(2)
|
|
frame.frameData.writeUInt16BE(code, 0)
|
|
} else if (code !== undefined && reason !== undefined) {
|
|
// If reason is also present, then reasonBytes must be
|
|
// provided in the Close message after the status code.
|
|
frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength)
|
|
frame.frameData.writeUInt16BE(code, 0)
|
|
// the body MAY contain UTF-8-encoded data with value /reason/
|
|
frame.frameData.write(reason, 2, 'utf-8')
|
|
} else {
|
|
frame.frameData = emptyBuffer
|
|
}
|
|
|
|
/** @type {import('stream').Duplex} */
|
|
const socket = ws[kResponse].socket
|
|
|
|
socket.write(frame.createFrame(opcodes.CLOSE))
|
|
|
|
ws[kSentClose] = sentCloseFrameState.SENT
|
|
|
|
// Upon either sending or receiving a Close control frame, it is said
|
|
// that _The WebSocket Closing Handshake is Started_ and that the
|
|
// WebSocket connection is in the CLOSING state.
|
|
ws[kReadyState] = states.CLOSING
|
|
} else {
|
|
// Otherwise
|
|
// Set this's ready state to CLOSING (2).
|
|
ws[kReadyState] = states.CLOSING
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Buffer} chunk
|
|
*/
|
|
function onSocketData (chunk) {
|
|
if (!this.ws[kByteParser].write(chunk)) {
|
|
this.pause()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
|
|
* @see https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.4
|
|
*/
|
|
function onSocketClose () {
|
|
const { ws } = this
|
|
const { [kResponse]: response } = ws
|
|
|
|
response.socket.off('data', onSocketData)
|
|
response.socket.off('close', onSocketClose)
|
|
response.socket.off('error', onSocketError)
|
|
|
|
// If the TCP connection was closed after the
|
|
// WebSocket closing handshake was completed, the WebSocket connection
|
|
// is said to have been closed _cleanly_.
|
|
const wasClean = ws[kSentClose] === sentCloseFrameState.SENT && ws[kReceivedClose]
|
|
|
|
let code = 1005
|
|
let reason = ''
|
|
|
|
const result = ws[kByteParser].closingInfo
|
|
|
|
if (result && !result.error) {
|
|
code = result.code ?? 1005
|
|
reason = result.reason
|
|
} else if (!ws[kReceivedClose]) {
|
|
// If _The WebSocket
|
|
// Connection is Closed_ and no Close control frame was received by the
|
|
// endpoint (such as could occur if the underlying transport connection
|
|
// is lost), _The WebSocket Connection Close Code_ is considered to be
|
|
// 1006.
|
|
code = 1006
|
|
}
|
|
|
|
// 1. Change the ready state to CLOSED (3).
|
|
ws[kReadyState] = states.CLOSED
|
|
|
|
// 2. If the user agent was required to fail the WebSocket
|
|
// connection, or if the WebSocket connection was closed
|
|
// after being flagged as full, fire an event named error
|
|
// at the WebSocket object.
|
|
// TODO
|
|
|
|
// 3. Fire an event named close at the WebSocket object,
|
|
// using CloseEvent, with the wasClean attribute
|
|
// initialized to true if the connection closed cleanly
|
|
// and false otherwise, the code attribute initialized to
|
|
// the WebSocket connection close code, and the reason
|
|
// attribute initialized to the result of applying UTF-8
|
|
// decode without BOM to the WebSocket connection close
|
|
// reason.
|
|
// TODO: process.nextTick
|
|
fireEvent('close', ws, (type, init) => new CloseEvent(type, init), {
|
|
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()
|
|
}
|
|
|
|
module.exports = {
|
|
establishWebSocketConnection,
|
|
closeWebSocketConnection
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 736:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
// This is a Globally Unique Identifier unique used
|
|
// to validate that the endpoint accepts websocket
|
|
// connections.
|
|
// See https://www.rfc-editor.org/rfc/rfc6455.html#section-1.3
|
|
const uid = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
|
|
|
|
/** @type {PropertyDescriptor} */
|
|
const staticPropertyDescriptors = {
|
|
enumerable: true,
|
|
writable: false,
|
|
configurable: false
|
|
}
|
|
|
|
const states = {
|
|
CONNECTING: 0,
|
|
OPEN: 1,
|
|
CLOSING: 2,
|
|
CLOSED: 3
|
|
}
|
|
|
|
const sentCloseFrameState = {
|
|
NOT_SENT: 0,
|
|
PROCESSING: 1,
|
|
SENT: 2
|
|
}
|
|
|
|
const opcodes = {
|
|
CONTINUATION: 0x0,
|
|
TEXT: 0x1,
|
|
BINARY: 0x2,
|
|
CLOSE: 0x8,
|
|
PING: 0x9,
|
|
PONG: 0xA
|
|
}
|
|
|
|
const maxUnsigned16Bit = 2 ** 16 - 1 // 65535
|
|
|
|
const parserStates = {
|
|
INFO: 0,
|
|
PAYLOADLENGTH_16: 2,
|
|
PAYLOADLENGTH_64: 3,
|
|
READ_DATA: 4
|
|
}
|
|
|
|
const emptyBuffer = Buffer.allocUnsafe(0)
|
|
|
|
const sendHints = {
|
|
string: 1,
|
|
typedArray: 2,
|
|
arrayBuffer: 3,
|
|
blob: 4
|
|
}
|
|
|
|
module.exports = {
|
|
uid,
|
|
sentCloseFrameState,
|
|
staticPropertyDescriptors,
|
|
states,
|
|
opcodes,
|
|
maxUnsigned16Bit,
|
|
parserStates,
|
|
emptyBuffer,
|
|
sendHints
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5188:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const { kEnumerableProperty } = __nccwpck_require__(3440)
|
|
const { kConstruct } = __nccwpck_require__(6443)
|
|
const { MessagePort } = __nccwpck_require__(5919)
|
|
|
|
/**
|
|
* @see https://html.spec.whatwg.org/multipage/comms.html#messageevent
|
|
*/
|
|
class MessageEvent extends Event {
|
|
#eventInit
|
|
|
|
constructor (type, eventInitDict = {}) {
|
|
if (type === kConstruct) {
|
|
super(arguments[1], arguments[2])
|
|
webidl.util.markAsUncloneable(this)
|
|
return
|
|
}
|
|
|
|
const prefix = 'MessageEvent constructor'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
type = webidl.converters.DOMString(type, prefix, 'type')
|
|
eventInitDict = webidl.converters.MessageEventInit(eventInitDict, prefix, 'eventInitDict')
|
|
|
|
super(type, eventInitDict)
|
|
|
|
this.#eventInit = eventInitDict
|
|
webidl.util.markAsUncloneable(this)
|
|
}
|
|
|
|
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, 'MessageEvent.initMessageEvent')
|
|
|
|
return new MessageEvent(type, {
|
|
bubbles, cancelable, data, origin, lastEventId, source, ports
|
|
})
|
|
}
|
|
|
|
static createFastMessageEvent (type, init) {
|
|
const messageEvent = new MessageEvent(kConstruct, type, init)
|
|
messageEvent.#eventInit = init
|
|
messageEvent.#eventInit.data ??= null
|
|
messageEvent.#eventInit.origin ??= ''
|
|
messageEvent.#eventInit.lastEventId ??= ''
|
|
messageEvent.#eventInit.source ??= null
|
|
messageEvent.#eventInit.ports ??= []
|
|
return messageEvent
|
|
}
|
|
}
|
|
|
|
const { createFastMessageEvent } = MessageEvent
|
|
delete MessageEvent.createFastMessageEvent
|
|
|
|
/**
|
|
* @see https://websockets.spec.whatwg.org/#the-closeevent-interface
|
|
*/
|
|
class CloseEvent extends Event {
|
|
#eventInit
|
|
|
|
constructor (type, eventInitDict = {}) {
|
|
const prefix = 'CloseEvent constructor'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
type = webidl.converters.DOMString(type, prefix, 'type')
|
|
eventInitDict = webidl.converters.CloseEventInit(eventInitDict)
|
|
|
|
super(type, eventInitDict)
|
|
|
|
this.#eventInit = eventInitDict
|
|
webidl.util.markAsUncloneable(this)
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/multipage/webappapis.html#the-errorevent-interface
|
|
class ErrorEvent extends Event {
|
|
#eventInit
|
|
|
|
constructor (type, eventInitDict) {
|
|
const prefix = 'ErrorEvent constructor'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
super(type, eventInitDict)
|
|
webidl.util.markAsUncloneable(this)
|
|
|
|
type = webidl.converters.DOMString(type, prefix, '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
|
|
)
|
|
|
|
const 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>'],
|
|
defaultValue: () => new Array(0)
|
|
}
|
|
])
|
|
|
|
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
|
|
}
|
|
])
|
|
|
|
module.exports = {
|
|
MessageEvent,
|
|
CloseEvent,
|
|
ErrorEvent,
|
|
createFastMessageEvent
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3264:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { maxUnsigned16Bit } = __nccwpck_require__(736)
|
|
|
|
const BUFFER_SIZE = 16386
|
|
|
|
/** @type {import('crypto')} */
|
|
let crypto
|
|
let buffer = null
|
|
let bufIdx = BUFFER_SIZE
|
|
|
|
try {
|
|
crypto = __nccwpck_require__(7598)
|
|
/* c8 ignore next 3 */
|
|
} catch {
|
|
crypto = {
|
|
// not full compatibility, but minimum.
|
|
randomFillSync: function randomFillSync (buffer, _offset, _size) {
|
|
for (let i = 0; i < buffer.length; ++i) {
|
|
buffer[i] = Math.random() * 255 | 0
|
|
}
|
|
return buffer
|
|
}
|
|
}
|
|
}
|
|
|
|
function generateMask () {
|
|
if (bufIdx === BUFFER_SIZE) {
|
|
bufIdx = 0
|
|
crypto.randomFillSync((buffer ??= Buffer.allocUnsafe(BUFFER_SIZE)), 0, BUFFER_SIZE)
|
|
}
|
|
return [buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++]]
|
|
}
|
|
|
|
class WebsocketFrameSend {
|
|
/**
|
|
* @param {Buffer|undefined} data
|
|
*/
|
|
constructor (data) {
|
|
this.frameData = data
|
|
}
|
|
|
|
createFrame (opcode) {
|
|
const frameData = this.frameData
|
|
const maskKey = generateMask()
|
|
const bodyLength = frameData?.byteLength ?? 0
|
|
|
|
/** @type {number} */
|
|
let payloadLength = bodyLength // 0-125
|
|
let offset = 6
|
|
|
|
if (bodyLength > maxUnsigned16Bit) {
|
|
offset += 8 // payload length is next 8 bytes
|
|
payloadLength = 127
|
|
} else if (bodyLength > 125) {
|
|
offset += 2 // payload length is next 2 bytes
|
|
payloadLength = 126
|
|
}
|
|
|
|
const buffer = Buffer.allocUnsafe(bodyLength + offset)
|
|
|
|
// Clear first 2 bytes, everything else is overwritten
|
|
buffer[0] = buffer[1] = 0
|
|
buffer[0] |= 0x80 // FIN
|
|
buffer[0] = (buffer[0] & 0xF0) + opcode // opcode
|
|
|
|
/*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> */
|
|
buffer[offset - 4] = maskKey[0]
|
|
buffer[offset - 3] = maskKey[1]
|
|
buffer[offset - 2] = maskKey[2]
|
|
buffer[offset - 1] = maskKey[3]
|
|
|
|
buffer[1] = payloadLength
|
|
|
|
if (payloadLength === 126) {
|
|
buffer.writeUInt16BE(bodyLength, 2)
|
|
} else if (payloadLength === 127) {
|
|
// Clear extended payload length
|
|
buffer[2] = buffer[3] = 0
|
|
buffer.writeUIntBE(bodyLength, 4, 6)
|
|
}
|
|
|
|
buffer[1] |= 0x80 // MASK
|
|
|
|
// mask body
|
|
for (let i = 0; i < bodyLength; ++i) {
|
|
buffer[offset + i] = frameData[i] ^ maskKey[i & 3]
|
|
}
|
|
|
|
return buffer
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
WebsocketFrameSend
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9469:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { createInflateRaw, Z_DEFAULT_WINDOWBITS } = __nccwpck_require__(8522)
|
|
const { isValidClientWindowBits } = __nccwpck_require__(8625)
|
|
const { MessageSizeExceededError } = __nccwpck_require__(8707)
|
|
|
|
const tail = Buffer.from([0x00, 0x00, 0xff, 0xff])
|
|
const kBuffer = Symbol('kBuffer')
|
|
const kLength = Symbol('kLength')
|
|
|
|
class PerMessageDeflate {
|
|
/** @type {import('node:zlib').InflateRaw} */
|
|
#inflate
|
|
|
|
#options = {}
|
|
|
|
#maxPayloadSize = 0
|
|
|
|
/**
|
|
* @param {Map<string, string>} extensions
|
|
*/
|
|
constructor (extensions, options) {
|
|
this.#options.serverNoContextTakeover = extensions.has('server_no_context_takeover')
|
|
this.#options.serverMaxWindowBits = extensions.get('server_max_window_bits')
|
|
|
|
this.#maxPayloadSize = options.maxPayloadSize
|
|
}
|
|
|
|
/**
|
|
* Decompress a compressed payload.
|
|
* @param {Buffer} chunk Compressed data
|
|
* @param {boolean} fin Final fragment flag
|
|
* @param {Function} callback Callback function
|
|
*/
|
|
decompress (chunk, fin, callback) {
|
|
// An endpoint uses the following algorithm to decompress a message.
|
|
// 1. Append 4 octets of 0x00 0x00 0xff 0xff to the tail end of the
|
|
// payload of the message.
|
|
// 2. Decompress the resulting data using DEFLATE.
|
|
if (!this.#inflate) {
|
|
let windowBits = Z_DEFAULT_WINDOWBITS
|
|
|
|
if (this.#options.serverMaxWindowBits) { // empty values default to Z_DEFAULT_WINDOWBITS
|
|
if (!isValidClientWindowBits(this.#options.serverMaxWindowBits)) {
|
|
callback(new Error('Invalid server_max_window_bits'))
|
|
return
|
|
}
|
|
|
|
windowBits = Number.parseInt(this.#options.serverMaxWindowBits)
|
|
}
|
|
|
|
try {
|
|
this.#inflate = createInflateRaw({ windowBits })
|
|
} catch (err) {
|
|
callback(err)
|
|
return
|
|
}
|
|
this.#inflate[kBuffer] = []
|
|
this.#inflate[kLength] = 0
|
|
|
|
this.#inflate.on('data', (data) => {
|
|
this.#inflate[kLength] += data.length
|
|
|
|
if (this.#maxPayloadSize > 0 && this.#inflate[kLength] > this.#maxPayloadSize) {
|
|
callback(new MessageSizeExceededError())
|
|
this.#inflate.removeAllListeners()
|
|
this.#inflate = null
|
|
return
|
|
}
|
|
|
|
this.#inflate[kBuffer].push(data)
|
|
})
|
|
|
|
this.#inflate.on('error', (err) => {
|
|
this.#inflate = null
|
|
callback(err)
|
|
})
|
|
}
|
|
|
|
this.#inflate.write(chunk)
|
|
if (fin) {
|
|
this.#inflate.write(tail)
|
|
}
|
|
|
|
this.#inflate.flush(() => {
|
|
if (!this.#inflate) {
|
|
return
|
|
}
|
|
|
|
const full = Buffer.concat(this.#inflate[kBuffer], this.#inflate[kLength])
|
|
|
|
this.#inflate[kBuffer].length = 0
|
|
this.#inflate[kLength] = 0
|
|
|
|
callback(null, full)
|
|
})
|
|
}
|
|
}
|
|
|
|
module.exports = { PerMessageDeflate }
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1652:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { Writable } = __nccwpck_require__(7075)
|
|
const assert = __nccwpck_require__(4589)
|
|
const { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = __nccwpck_require__(736)
|
|
const { kReadyState, kSentClose, kResponse, kReceivedClose } = __nccwpck_require__(1216)
|
|
const { channels } = __nccwpck_require__(2414)
|
|
const {
|
|
isValidStatusCode,
|
|
isValidOpcode,
|
|
failWebsocketConnection,
|
|
websocketMessageReceived,
|
|
utf8Decode,
|
|
isControlFrame,
|
|
isTextBinaryFrame,
|
|
isContinuationFrame
|
|
} = __nccwpck_require__(8625)
|
|
const { WebsocketFrameSend } = __nccwpck_require__(3264)
|
|
const { closeWebSocketConnection } = __nccwpck_require__(6897)
|
|
const { PerMessageDeflate } = __nccwpck_require__(9469)
|
|
const { MessageSizeExceededError } = __nccwpck_require__(8707)
|
|
|
|
function failWebsocketConnectionWithCode (ws, code, reason) {
|
|
closeWebSocketConnection(ws, code, reason, Buffer.byteLength(reason))
|
|
failWebsocketConnection(ws, reason)
|
|
}
|
|
|
|
// This code was influenced by ws released under the MIT license.
|
|
// Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
|
|
// Copyright (c) 2013 Arnout Kazemier and contributors
|
|
// Copyright (c) 2016 Luigi Pinca and contributors
|
|
|
|
class ByteParser extends Writable {
|
|
#buffers = []
|
|
#fragmentsBytes = 0
|
|
#byteOffset = 0
|
|
#loop = false
|
|
|
|
#state = parserStates.INFO
|
|
|
|
#info = {}
|
|
#fragments = []
|
|
|
|
/** @type {Map<string, PerMessageDeflate>} */
|
|
#extensions
|
|
|
|
/** @type {number} */
|
|
#maxFragments
|
|
|
|
/** @type {number} */
|
|
#maxPayloadSize
|
|
|
|
/**
|
|
* @param {import('./websocket').WebSocket} ws
|
|
* @param {Map<string, string>|null} extensions
|
|
* @param {{ maxFragments?: number, maxPayloadSize?: number }} [options]
|
|
*/
|
|
constructor (ws, extensions, options = {}) {
|
|
super()
|
|
|
|
this.ws = ws
|
|
this.#extensions = extensions == null ? new Map() : extensions
|
|
this.#maxFragments = options.maxFragments ?? 0
|
|
this.#maxPayloadSize = options.maxPayloadSize ?? 0
|
|
|
|
if (this.#extensions.has('permessage-deflate')) {
|
|
this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions, options))
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Buffer} chunk
|
|
* @param {() => void} callback
|
|
*/
|
|
_write (chunk, _, callback) {
|
|
this.#buffers.push(chunk)
|
|
this.#byteOffset += chunk.length
|
|
this.#loop = true
|
|
|
|
this.run(callback)
|
|
}
|
|
|
|
#validatePayloadLength () {
|
|
if (
|
|
this.#maxPayloadSize > 0 &&
|
|
!isControlFrame(this.#info.opcode) &&
|
|
this.#info.payloadLength + this.#fragmentsBytes > this.#maxPayloadSize
|
|
) {
|
|
failWebsocketConnectionWithCode(this.ws, 1009, 'Payload size exceeds maximum allowed size')
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* 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 (this.#loop) {
|
|
if (this.#state === parserStates.INFO) {
|
|
// If there aren't enough bytes to parse the payload length, etc.
|
|
if (this.#byteOffset < 2) {
|
|
return callback()
|
|
}
|
|
|
|
const buffer = this.consume(2)
|
|
const fin = (buffer[0] & 0x80) !== 0
|
|
const opcode = buffer[0] & 0x0F
|
|
const masked = (buffer[1] & 0x80) === 0x80
|
|
|
|
const fragmented = !fin && opcode !== opcodes.CONTINUATION
|
|
const payloadLength = buffer[1] & 0x7F
|
|
|
|
const rsv1 = buffer[0] & 0x40
|
|
const rsv2 = buffer[0] & 0x20
|
|
const rsv3 = buffer[0] & 0x10
|
|
|
|
if (!isValidOpcode(opcode)) {
|
|
failWebsocketConnection(this.ws, 'Invalid opcode received')
|
|
return callback()
|
|
}
|
|
|
|
if (masked) {
|
|
failWebsocketConnection(this.ws, 'Frame cannot be masked')
|
|
return callback()
|
|
}
|
|
|
|
// MUST be 0 unless an extension is negotiated that defines meanings
|
|
// for non-zero values. If a nonzero value is received and none of
|
|
// the negotiated extensions defines the meaning of such a nonzero
|
|
// value, the receiving endpoint MUST _Fail the WebSocket
|
|
// Connection_.
|
|
// This document allocates the RSV1 bit of the WebSocket header for
|
|
// PMCEs and calls the bit the "Per-Message Compressed" bit. On a
|
|
// WebSocket connection where a PMCE is in use, this bit indicates
|
|
// whether a message is compressed or not.
|
|
if (rsv1 !== 0 && !this.#extensions.has('permessage-deflate')) {
|
|
failWebsocketConnection(this.ws, 'Expected RSV1 to be clear.')
|
|
return
|
|
}
|
|
|
|
if (rsv2 !== 0 || rsv3 !== 0) {
|
|
failWebsocketConnection(this.ws, 'RSV1, RSV2, RSV3 must be clear')
|
|
return
|
|
}
|
|
|
|
if (fragmented && !isTextBinaryFrame(opcode)) {
|
|
// Only text and binary frames can be fragmented
|
|
failWebsocketConnection(this.ws, 'Invalid frame type was fragmented.')
|
|
return
|
|
}
|
|
|
|
// If we are already parsing a text/binary frame and do not receive either
|
|
// a continuation frame or close frame, fail the connection.
|
|
if (isTextBinaryFrame(opcode) && this.#fragments.length > 0) {
|
|
failWebsocketConnection(this.ws, 'Expected continuation frame')
|
|
return
|
|
}
|
|
|
|
if (this.#info.fragmented && fragmented) {
|
|
// A fragmented frame can't be fragmented itself
|
|
failWebsocketConnection(this.ws, 'Fragmented frame exceeded 125 bytes.')
|
|
return
|
|
}
|
|
|
|
// "All control frames MUST have a payload length of 125 bytes or less
|
|
// and MUST NOT be fragmented."
|
|
if ((payloadLength > 125 || fragmented) && isControlFrame(opcode)) {
|
|
failWebsocketConnection(this.ws, 'Control frame either too large or fragmented')
|
|
return
|
|
}
|
|
|
|
if (isContinuationFrame(opcode) && this.#fragments.length === 0 && !this.#info.compressed) {
|
|
failWebsocketConnection(this.ws, 'Unexpected continuation frame')
|
|
return
|
|
}
|
|
|
|
if (payloadLength <= 125) {
|
|
this.#info.payloadLength = payloadLength
|
|
this.#state = parserStates.READ_DATA
|
|
|
|
if (!this.#validatePayloadLength()) {
|
|
return
|
|
}
|
|
} else if (payloadLength === 126) {
|
|
this.#state = parserStates.PAYLOADLENGTH_16
|
|
} else if (payloadLength === 127) {
|
|
this.#state = parserStates.PAYLOADLENGTH_64
|
|
}
|
|
|
|
if (isTextBinaryFrame(opcode)) {
|
|
this.#info.binaryType = opcode
|
|
this.#info.compressed = rsv1 !== 0
|
|
}
|
|
|
|
this.#info.opcode = opcode
|
|
this.#info.masked = masked
|
|
this.#info.fin = fin
|
|
this.#info.fragmented = fragmented
|
|
} else if (this.#state === parserStates.PAYLOADLENGTH_16) {
|
|
if (this.#byteOffset < 2) {
|
|
return callback()
|
|
}
|
|
|
|
const buffer = this.consume(2)
|
|
|
|
this.#info.payloadLength = buffer.readUInt16BE(0)
|
|
this.#state = parserStates.READ_DATA
|
|
|
|
if (!this.#validatePayloadLength()) {
|
|
return
|
|
}
|
|
} else if (this.#state === parserStates.PAYLOADLENGTH_64) {
|
|
if (this.#byteOffset < 8) {
|
|
return callback()
|
|
}
|
|
|
|
const buffer = this.consume(8)
|
|
const upper = buffer.readUInt32BE(0)
|
|
const lower = buffer.readUInt32BE(4)
|
|
|
|
// 2^31 is the maximum bytes an arraybuffer can contain
|
|
// on 32-bit systems. Although, on 64-bit systems, this is
|
|
// 2^53-1 bytes.
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length
|
|
// https://source.chromium.org/chromium/chromium/src/+/main:v8/src/common/globals.h;drc=1946212ac0100668f14eb9e2843bdd846e510a1e;bpv=1;bpt=1;l=1275
|
|
// https://source.chromium.org/chromium/chromium/src/+/main:v8/src/objects/js-array-buffer.h;l=34;drc=1946212ac0100668f14eb9e2843bdd846e510a1e
|
|
if (upper !== 0 || lower > 2 ** 31 - 1) {
|
|
failWebsocketConnection(this.ws, 'Received payload length > 2^31 bytes.')
|
|
return
|
|
}
|
|
|
|
this.#info.payloadLength = lower
|
|
this.#state = parserStates.READ_DATA
|
|
|
|
if (!this.#validatePayloadLength()) {
|
|
return
|
|
}
|
|
} else if (this.#state === parserStates.READ_DATA) {
|
|
if (this.#byteOffset < this.#info.payloadLength) {
|
|
return callback()
|
|
}
|
|
|
|
const body = this.consume(this.#info.payloadLength)
|
|
|
|
if (isControlFrame(this.#info.opcode)) {
|
|
this.#loop = this.parseControlFrame(body)
|
|
this.#state = parserStates.INFO
|
|
} else {
|
|
if (!this.#info.compressed) {
|
|
if (!this.writeFragments(body)) {
|
|
return
|
|
}
|
|
|
|
if (this.#maxPayloadSize > 0 && this.#fragmentsBytes > this.#maxPayloadSize) {
|
|
failWebsocketConnectionWithCode(this.ws, 1009, new MessageSizeExceededError().message)
|
|
return
|
|
}
|
|
|
|
// If the frame is not fragmented, a message has been received.
|
|
// If the frame is fragmented, it will terminate with a fin bit set
|
|
// and an opcode of 0 (continuation), therefore we handle that when
|
|
// parsing continuation frames, not here.
|
|
if (!this.#info.fragmented && this.#info.fin) {
|
|
websocketMessageReceived(this.ws, this.#info.binaryType, this.consumeFragments())
|
|
}
|
|
|
|
this.#state = parserStates.INFO
|
|
} else {
|
|
this.#extensions.get('permessage-deflate').decompress(
|
|
body,
|
|
this.#info.fin,
|
|
(error, data) => {
|
|
if (error) {
|
|
const code = error instanceof MessageSizeExceededError ? 1009 : 1007
|
|
failWebsocketConnectionWithCode(this.ws, code, error.message)
|
|
return
|
|
}
|
|
|
|
if (!this.writeFragments(data)) {
|
|
return
|
|
}
|
|
|
|
if (this.#maxPayloadSize > 0 && this.#fragmentsBytes > this.#maxPayloadSize) {
|
|
failWebsocketConnectionWithCode(this.ws, 1009, new MessageSizeExceededError().message)
|
|
return
|
|
}
|
|
|
|
if (!this.#info.fin) {
|
|
this.#state = parserStates.INFO
|
|
this.#loop = true
|
|
this.run(callback)
|
|
return
|
|
}
|
|
|
|
websocketMessageReceived(this.ws, this.#info.binaryType, this.consumeFragments())
|
|
|
|
this.#loop = true
|
|
this.#state = parserStates.INFO
|
|
this.run(callback)
|
|
}
|
|
)
|
|
|
|
this.#loop = false
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Take n bytes from the buffered Buffers
|
|
* @param {number} n
|
|
* @returns {Buffer}
|
|
*/
|
|
consume (n) {
|
|
if (n > this.#byteOffset) {
|
|
throw new Error('Called consume() before buffers satiated.')
|
|
} 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
|
|
}
|
|
|
|
writeFragments (fragment) {
|
|
if (
|
|
this.#maxFragments > 0 &&
|
|
this.#fragments.length === this.#maxFragments
|
|
) {
|
|
failWebsocketConnectionWithCode(this.ws, 1008, 'Too many message fragments')
|
|
return false
|
|
}
|
|
|
|
this.#fragmentsBytes += fragment.length
|
|
this.#fragments.push(fragment)
|
|
return true
|
|
}
|
|
|
|
consumeFragments () {
|
|
const fragments = this.#fragments
|
|
|
|
if (fragments.length === 1) {
|
|
this.#fragmentsBytes = 0
|
|
return fragments.shift()
|
|
}
|
|
|
|
const output = Buffer.concat(fragments, this.#fragmentsBytes)
|
|
this.#fragments = []
|
|
this.#fragmentsBytes = 0
|
|
|
|
return output
|
|
}
|
|
|
|
parseCloseBody (data) {
|
|
assert(data.length !== 1)
|
|
|
|
// https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.5
|
|
/** @type {number|undefined} */
|
|
let code
|
|
|
|
if (data.length >= 2) {
|
|
// _The WebSocket Connection Close Code_ is
|
|
// defined as the status code (Section 7.4) contained in the first Close
|
|
// control frame received by the application
|
|
code = data.readUInt16BE(0)
|
|
}
|
|
|
|
if (code !== undefined && !isValidStatusCode(code)) {
|
|
return { code: 1002, reason: 'Invalid status code', error: true }
|
|
}
|
|
|
|
// https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.6
|
|
/** @type {Buffer} */
|
|
let reason = data.subarray(2)
|
|
|
|
// Remove BOM
|
|
if (reason[0] === 0xEF && reason[1] === 0xBB && reason[2] === 0xBF) {
|
|
reason = reason.subarray(3)
|
|
}
|
|
|
|
try {
|
|
reason = utf8Decode(reason)
|
|
} catch {
|
|
return { code: 1007, reason: 'Invalid UTF-8', error: true }
|
|
}
|
|
|
|
return { code, reason, error: false }
|
|
}
|
|
|
|
/**
|
|
* Parses control frames.
|
|
* @param {Buffer} body
|
|
*/
|
|
parseControlFrame (body) {
|
|
const { opcode, payloadLength } = this.#info
|
|
|
|
if (opcode === opcodes.CLOSE) {
|
|
if (payloadLength === 1) {
|
|
failWebsocketConnection(this.ws, 'Received close frame with a 1-byte body.')
|
|
return false
|
|
}
|
|
|
|
this.#info.closeInfo = this.parseCloseBody(body)
|
|
|
|
if (this.#info.closeInfo.error) {
|
|
const { code, reason } = this.#info.closeInfo
|
|
|
|
closeWebSocketConnection(this.ws, code, reason, reason.length)
|
|
failWebsocketConnection(this.ws, reason)
|
|
return false
|
|
}
|
|
|
|
if (this.ws[kSentClose] !== sentCloseFrameState.SENT) {
|
|
// If an endpoint receives a Close frame and did not previously send a
|
|
// Close frame, the endpoint MUST send a Close frame in response. (When
|
|
// sending a Close frame in response, the endpoint typically echos the
|
|
// status code it received.)
|
|
let body = emptyBuffer
|
|
if (this.#info.closeInfo.code) {
|
|
body = Buffer.allocUnsafe(2)
|
|
body.writeUInt16BE(this.#info.closeInfo.code, 0)
|
|
}
|
|
const closeFrame = new WebsocketFrameSend(body)
|
|
|
|
this.ws[kResponse].socket.write(
|
|
closeFrame.createFrame(opcodes.CLOSE),
|
|
(err) => {
|
|
if (!err) {
|
|
this.ws[kSentClose] = sentCloseFrameState.SENT
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
// Upon either sending or receiving a Close control frame, it is said
|
|
// that _The WebSocket Closing Handshake is Started_ and that the
|
|
// WebSocket connection is in the CLOSING state.
|
|
this.ws[kReadyState] = states.CLOSING
|
|
this.ws[kReceivedClose] = true
|
|
|
|
return false
|
|
} else if (opcode === opcodes.PING) {
|
|
// Upon receipt of a Ping frame, an endpoint MUST send a Pong frame in
|
|
// response, unless it already received a Close frame.
|
|
// A Pong frame sent in response to a Ping frame must have identical
|
|
// "Application data"
|
|
|
|
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
|
|
})
|
|
}
|
|
}
|
|
} else if (opcode === opcodes.PONG) {
|
|
// A Pong frame MAY be sent unsolicited. This serves as a
|
|
// unidirectional heartbeat. A response to an unsolicited Pong frame is
|
|
// not expected.
|
|
|
|
if (channels.pong.hasSubscribers) {
|
|
channels.pong.publish({
|
|
payload: body
|
|
})
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
get closingInfo () {
|
|
return this.#info.closeInfo
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
ByteParser
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3900:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { WebsocketFrameSend } = __nccwpck_require__(3264)
|
|
const { opcodes, sendHints } = __nccwpck_require__(736)
|
|
const FixedQueue = __nccwpck_require__(4660)
|
|
|
|
/** @type {typeof Uint8Array} */
|
|
const FastBuffer = Buffer[Symbol.species]
|
|
|
|
/**
|
|
* @typedef {object} SendQueueNode
|
|
* @property {Promise<void> | null} promise
|
|
* @property {((...args: any[]) => any)} callback
|
|
* @property {Buffer | null} frame
|
|
*/
|
|
|
|
class SendQueue {
|
|
/**
|
|
* @type {FixedQueue}
|
|
*/
|
|
#queue = new FixedQueue()
|
|
|
|
/**
|
|
* @type {boolean}
|
|
*/
|
|
#running = false
|
|
|
|
/** @type {import('node:net').Socket} */
|
|
#socket
|
|
|
|
constructor (socket) {
|
|
this.#socket = socket
|
|
}
|
|
|
|
add (item, cb, hint) {
|
|
if (hint !== sendHints.blob) {
|
|
const frame = createFrame(item, hint)
|
|
if (!this.#running) {
|
|
// fast-path
|
|
this.#socket.write(frame, cb)
|
|
} else {
|
|
/** @type {SendQueueNode} */
|
|
const node = {
|
|
promise: null,
|
|
callback: cb,
|
|
frame
|
|
}
|
|
this.#queue.push(node)
|
|
}
|
|
return
|
|
}
|
|
|
|
/** @type {SendQueueNode} */
|
|
const node = {
|
|
promise: item.arrayBuffer().then((ab) => {
|
|
node.promise = null
|
|
node.frame = createFrame(ab, hint)
|
|
}),
|
|
callback: cb,
|
|
frame: null
|
|
}
|
|
|
|
this.#queue.push(node)
|
|
|
|
if (!this.#running) {
|
|
this.#run()
|
|
}
|
|
}
|
|
|
|
async #run () {
|
|
this.#running = true
|
|
const queue = this.#queue
|
|
while (!queue.isEmpty()) {
|
|
const node = queue.shift()
|
|
// wait pending promise
|
|
if (node.promise !== null) {
|
|
await node.promise
|
|
}
|
|
// write
|
|
this.#socket.write(node.frame, node.callback)
|
|
// cleanup
|
|
node.callback = node.frame = null
|
|
}
|
|
this.#running = false
|
|
}
|
|
}
|
|
|
|
function createFrame (data, hint) {
|
|
return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.string ? opcodes.TEXT : opcodes.BINARY)
|
|
}
|
|
|
|
function toBuffer (data, hint) {
|
|
switch (hint) {
|
|
case sendHints.string:
|
|
return Buffer.from(data)
|
|
case sendHints.arrayBuffer:
|
|
case sendHints.blob:
|
|
return new FastBuffer(data)
|
|
case sendHints.typedArray:
|
|
return new FastBuffer(data.buffer, data.byteOffset, data.byteLength)
|
|
}
|
|
}
|
|
|
|
module.exports = { SendQueue }
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1216:
|
|
/***/ ((module) => {
|
|
|
|
|
|
|
|
module.exports = {
|
|
kWebSocketURL: Symbol('url'),
|
|
kReadyState: Symbol('ready state'),
|
|
kController: Symbol('controller'),
|
|
kResponse: Symbol('response'),
|
|
kBinaryType: Symbol('binary type'),
|
|
kSentClose: Symbol('sent close'),
|
|
kReceivedClose: Symbol('received close'),
|
|
kByteParser: Symbol('byte parser')
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8625:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = __nccwpck_require__(1216)
|
|
const { states, opcodes } = __nccwpck_require__(736)
|
|
const { ErrorEvent, createFastMessageEvent } = __nccwpck_require__(5188)
|
|
const { isUtf8 } = __nccwpck_require__(4573)
|
|
const { collectASequenceOfCodePointsFast, removeHTTPWhitespace } = __nccwpck_require__(1900)
|
|
|
|
/* globals Blob */
|
|
|
|
/**
|
|
* @param {import('./websocket').WebSocket} ws
|
|
* @returns {boolean}
|
|
*/
|
|
function isConnecting (ws) {
|
|
// If the WebSocket connection is not yet established, and the connection
|
|
// is not yet closed, then the WebSocket connection is in the CONNECTING state.
|
|
return ws[kReadyState] === states.CONNECTING
|
|
}
|
|
|
|
/**
|
|
* @param {import('./websocket').WebSocket} ws
|
|
* @returns {boolean}
|
|
*/
|
|
function isEstablished (ws) {
|
|
// If the server's response is validated as provided for above, it is
|
|
// said that _The WebSocket Connection is Established_ and that the
|
|
// WebSocket Connection is in the OPEN state.
|
|
return ws[kReadyState] === states.OPEN
|
|
}
|
|
|
|
/**
|
|
* @param {import('./websocket').WebSocket} ws
|
|
* @returns {boolean}
|
|
*/
|
|
function isClosing (ws) {
|
|
// Upon either sending or receiving a Close control frame, it is said
|
|
// that _The WebSocket Closing Handshake is Started_ and that the
|
|
// WebSocket connection is in the CLOSING state.
|
|
return ws[kReadyState] === states.CLOSING
|
|
}
|
|
|
|
/**
|
|
* @param {import('./websocket').WebSocket} ws
|
|
* @returns {boolean}
|
|
*/
|
|
function isClosed (ws) {
|
|
return ws[kReadyState] === states.CLOSED
|
|
}
|
|
|
|
/**
|
|
* @see https://dom.spec.whatwg.org/#concept-event-fire
|
|
* @param {string} e
|
|
* @param {EventTarget} target
|
|
* @param {(...args: ConstructorParameters<typeof Event>) => Event} eventFactory
|
|
* @param {EventInit | undefined} eventInitDict
|
|
*/
|
|
function fireEvent (e, target, eventFactory = (type, init) => new Event(type, init), eventInitDict = {}) {
|
|
// 1. If eventConstructor is not given, then let eventConstructor be Event.
|
|
|
|
// 2. Let event be the result of creating an event given eventConstructor,
|
|
// in the relevant realm of target.
|
|
// 3. Initialize event’s type attribute to e.
|
|
const event = eventFactory(e, eventInitDict)
|
|
|
|
// 4. Initialize any other IDL attributes of event as described in the
|
|
// invocation of this algorithm.
|
|
|
|
// 5. Return the result of dispatching event at target, with legacy target
|
|
// override flag set if set.
|
|
target.dispatchEvent(event)
|
|
}
|
|
|
|
/**
|
|
* @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
|
|
* @param {import('./websocket').WebSocket} ws
|
|
* @param {number} type Opcode
|
|
* @param {Buffer} data application data
|
|
*/
|
|
function websocketMessageReceived (ws, type, data) {
|
|
// 1. If ready state is not OPEN (1), then return.
|
|
if (ws[kReadyState] !== states.OPEN) {
|
|
return
|
|
}
|
|
|
|
// 2. Let dataForEvent be determined by switching on type and binary type:
|
|
let dataForEvent
|
|
|
|
if (type === opcodes.TEXT) {
|
|
// -> type indicates that the data is Text
|
|
// a new DOMString containing data
|
|
try {
|
|
dataForEvent = utf8Decode(data)
|
|
} catch {
|
|
failWebsocketConnection(ws, 'Received invalid UTF-8 in text frame.')
|
|
return
|
|
}
|
|
} else if (type === opcodes.BINARY) {
|
|
if (ws[kBinaryType] === 'blob') {
|
|
// -> type indicates that the data is Binary and binary type is "blob"
|
|
// a new Blob object, created in the relevant Realm of the WebSocket
|
|
// object, that represents data as its raw data
|
|
dataForEvent = new Blob([data])
|
|
} else {
|
|
// -> type indicates that the data is Binary and binary type is "arraybuffer"
|
|
// a new ArrayBuffer object, created in the relevant Realm of the
|
|
// WebSocket object, whose contents are data
|
|
dataForEvent = toArrayBuffer(data)
|
|
}
|
|
}
|
|
|
|
// 3. Fire an event named message at the WebSocket object, using MessageEvent,
|
|
// with the origin attribute initialized to the serialization of the WebSocket
|
|
// object’s url's origin, and the data attribute initialized to dataForEvent.
|
|
fireEvent('message', ws, createFastMessageEvent, {
|
|
origin: ws[kWebSocketURL].origin,
|
|
data: dataForEvent
|
|
})
|
|
}
|
|
|
|
function toArrayBuffer (buffer) {
|
|
if (buffer.byteLength === buffer.buffer.byteLength) {
|
|
return buffer.buffer
|
|
}
|
|
return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
|
|
}
|
|
|
|
/**
|
|
* @see https://datatracker.ietf.org/doc/html/rfc6455
|
|
* @see https://datatracker.ietf.org/doc/html/rfc2616
|
|
* @see https://bugs.chromium.org/p/chromium/issues/detail?id=398407
|
|
* @param {string} protocol
|
|
*/
|
|
function isValidSubprotocol (protocol) {
|
|
// If present, this value indicates one
|
|
// or more comma-separated subprotocol the client wishes to speak,
|
|
// ordered by preference. The elements that comprise this value
|
|
// MUST be non-empty strings with characters in the range U+0021 to
|
|
// U+007E not including separator characters as defined in
|
|
// [RFC2616] and MUST all be unique strings.
|
|
if (protocol.length === 0) {
|
|
return false
|
|
}
|
|
|
|
for (let i = 0; i < protocol.length; ++i) {
|
|
const code = protocol.charCodeAt(i)
|
|
|
|
if (
|
|
code < 0x21 || // CTL, contains SP (0x20) and HT (0x09)
|
|
code > 0x7E ||
|
|
code === 0x22 || // "
|
|
code === 0x28 || // (
|
|
code === 0x29 || // )
|
|
code === 0x2C || // ,
|
|
code === 0x2F || // /
|
|
code === 0x3A || // :
|
|
code === 0x3B || // ;
|
|
code === 0x3C || // <
|
|
code === 0x3D || // =
|
|
code === 0x3E || // >
|
|
code === 0x3F || // ?
|
|
code === 0x40 || // @
|
|
code === 0x5B || // [
|
|
code === 0x5C || // \
|
|
code === 0x5D || // ]
|
|
code === 0x7B || // {
|
|
code === 0x7D // }
|
|
) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* @see https://datatracker.ietf.org/doc/html/rfc6455#section-7-4
|
|
* @param {number} code
|
|
*/
|
|
function isValidStatusCode (code) {
|
|
if (code >= 1000 && code < 1015) {
|
|
return (
|
|
code !== 1004 && // reserved
|
|
code !== 1005 && // "MUST NOT be set as a status code"
|
|
code !== 1006 // "MUST NOT be set as a status code"
|
|
)
|
|
}
|
|
|
|
return code >= 3000 && code <= 4999
|
|
}
|
|
|
|
/**
|
|
* @param {import('./websocket').WebSocket} ws
|
|
* @param {string|undefined} reason
|
|
*/
|
|
function failWebsocketConnection (ws, reason) {
|
|
const { [kController]: controller, [kResponse]: response } = ws
|
|
|
|
controller.abort()
|
|
|
|
if (response?.socket && !response.socket.destroyed) {
|
|
response.socket.destroy()
|
|
}
|
|
|
|
if (reason) {
|
|
// TODO: process.nextTick
|
|
fireEvent('error', ws, (type, init) => new ErrorEvent(type, init), {
|
|
error: new Error(reason),
|
|
message: reason
|
|
})
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://datatracker.ietf.org/doc/html/rfc6455#section-5.5
|
|
* @param {number} opcode
|
|
*/
|
|
function isControlFrame (opcode) {
|
|
return (
|
|
opcode === opcodes.CLOSE ||
|
|
opcode === opcodes.PING ||
|
|
opcode === opcodes.PONG
|
|
)
|
|
}
|
|
|
|
function isContinuationFrame (opcode) {
|
|
return opcode === opcodes.CONTINUATION
|
|
}
|
|
|
|
function isTextBinaryFrame (opcode) {
|
|
return opcode === opcodes.TEXT || opcode === opcodes.BINARY
|
|
}
|
|
|
|
function isValidOpcode (opcode) {
|
|
return isTextBinaryFrame(opcode) || isContinuationFrame(opcode) || isControlFrame(opcode)
|
|
}
|
|
|
|
/**
|
|
* Parses a Sec-WebSocket-Extensions header value.
|
|
* @param {string} extensions
|
|
* @returns {Map<string, string>}
|
|
*/
|
|
// TODO(@Uzlopak, @KhafraDev): make compliant https://datatracker.ietf.org/doc/html/rfc6455#section-9.1
|
|
function parseExtensions (extensions) {
|
|
const position = { position: 0 }
|
|
const extensionList = new Map()
|
|
|
|
while (position.position < extensions.length) {
|
|
const pair = collectASequenceOfCodePointsFast(';', extensions, position)
|
|
const [name, value = ''] = pair.split('=')
|
|
|
|
extensionList.set(
|
|
removeHTTPWhitespace(name, true, false),
|
|
removeHTTPWhitespace(value, false, true)
|
|
)
|
|
|
|
position.position++
|
|
}
|
|
|
|
return extensionList
|
|
}
|
|
|
|
/**
|
|
* @see https://www.rfc-editor.org/rfc/rfc7692#section-7.1.2.2
|
|
* @description "client-max-window-bits = 1*DIGIT"
|
|
* @param {string} value
|
|
*/
|
|
function isValidClientWindowBits (value) {
|
|
// Must have at least one character
|
|
if (value.length === 0) {
|
|
return false
|
|
}
|
|
|
|
// Check all characters are ASCII digits
|
|
for (let i = 0; i < value.length; i++) {
|
|
const byte = value.charCodeAt(i)
|
|
|
|
if (byte < 0x30 || byte > 0x39) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Check numeric range: zlib requires windowBits in range 8-15
|
|
const num = Number.parseInt(value, 10)
|
|
return num >= 8 && num <= 15
|
|
}
|
|
|
|
// https://nodejs.org/api/intl.html#detecting-internationalization-support
|
|
const hasIntl = typeof process.versions.icu === 'string'
|
|
const fatalDecoder = hasIntl ? new TextDecoder('utf-8', { fatal: true }) : undefined
|
|
|
|
/**
|
|
* Converts a Buffer to utf-8, even on platforms without icu.
|
|
* @param {Buffer} buffer
|
|
*/
|
|
const utf8Decode = hasIntl
|
|
? fatalDecoder.decode.bind(fatalDecoder)
|
|
: function (buffer) {
|
|
if (isUtf8(buffer)) {
|
|
return buffer.toString('utf-8')
|
|
}
|
|
throw new TypeError('Invalid utf-8 received.')
|
|
}
|
|
|
|
module.exports = {
|
|
isConnecting,
|
|
isEstablished,
|
|
isClosing,
|
|
isClosed,
|
|
fireEvent,
|
|
isValidSubprotocol,
|
|
isValidStatusCode,
|
|
failWebsocketConnection,
|
|
websocketMessageReceived,
|
|
utf8Decode,
|
|
isControlFrame,
|
|
isContinuationFrame,
|
|
isTextBinaryFrame,
|
|
isValidOpcode,
|
|
parseExtensions,
|
|
isValidClientWindowBits
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3726:
|
|
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
const { webidl } = __nccwpck_require__(5893)
|
|
const { URLSerializer } = __nccwpck_require__(1900)
|
|
const { environmentSettingsObject } = __nccwpck_require__(3168)
|
|
const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints } = __nccwpck_require__(736)
|
|
const {
|
|
kWebSocketURL,
|
|
kReadyState,
|
|
kController,
|
|
kBinaryType,
|
|
kResponse,
|
|
kSentClose,
|
|
kByteParser
|
|
} = __nccwpck_require__(1216)
|
|
const {
|
|
isConnecting,
|
|
isEstablished,
|
|
isClosing,
|
|
isValidSubprotocol,
|
|
fireEvent
|
|
} = __nccwpck_require__(8625)
|
|
const { establishWebSocketConnection, closeWebSocketConnection } = __nccwpck_require__(6897)
|
|
const { ByteParser } = __nccwpck_require__(1652)
|
|
const { kEnumerableProperty, isBlobLike } = __nccwpck_require__(3440)
|
|
const { getGlobalDispatcher } = __nccwpck_require__(2581)
|
|
const { types } = __nccwpck_require__(7975)
|
|
const { ErrorEvent, CloseEvent } = __nccwpck_require__(5188)
|
|
const { SendQueue } = __nccwpck_require__(3900)
|
|
|
|
// https://websockets.spec.whatwg.org/#interface-definition
|
|
class WebSocket extends EventTarget {
|
|
#events = {
|
|
open: null,
|
|
error: null,
|
|
close: null,
|
|
message: null
|
|
}
|
|
|
|
#bufferedAmount = 0
|
|
#protocol = ''
|
|
#extensions = ''
|
|
|
|
/** @type {SendQueue} */
|
|
#sendQueue
|
|
|
|
/**
|
|
* @param {string} url
|
|
* @param {string|string[]} protocols
|
|
*/
|
|
constructor (url, protocols = []) {
|
|
super()
|
|
|
|
webidl.util.markAsUncloneable(this)
|
|
|
|
const prefix = 'WebSocket constructor'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
const options = webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'](protocols, prefix, 'options')
|
|
|
|
url = webidl.converters.USVString(url, prefix, 'url')
|
|
protocols = options.protocols
|
|
|
|
// 1. Let baseURL be this's relevant settings object's API base URL.
|
|
const baseURL = environmentSettingsObject.settingsObject.baseUrl
|
|
|
|
// 1. Let urlRecord be the result of applying the URL parser to url with baseURL.
|
|
let urlRecord
|
|
|
|
try {
|
|
urlRecord = new URL(url, baseURL)
|
|
} catch (e) {
|
|
// 3. If urlRecord is failure, then throw a "SyntaxError" DOMException.
|
|
throw new DOMException(e, 'SyntaxError')
|
|
}
|
|
|
|
// 4. If urlRecord’s scheme is "http", then set urlRecord’s scheme to "ws".
|
|
if (urlRecord.protocol === 'http:') {
|
|
urlRecord.protocol = 'ws:'
|
|
} else if (urlRecord.protocol === 'https:') {
|
|
// 5. Otherwise, if urlRecord’s scheme is "https", set urlRecord’s scheme to "wss".
|
|
urlRecord.protocol = 'wss:'
|
|
}
|
|
|
|
// 6. If urlRecord’s scheme is not "ws" or "wss", then throw a "SyntaxError" DOMException.
|
|
if (urlRecord.protocol !== 'ws:' && urlRecord.protocol !== 'wss:') {
|
|
throw new DOMException(
|
|
`Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
|
|
'SyntaxError'
|
|
)
|
|
}
|
|
|
|
// 7. If urlRecord’s fragment is non-null, then throw a "SyntaxError"
|
|
// DOMException.
|
|
if (urlRecord.hash || urlRecord.href.endsWith('#')) {
|
|
throw new DOMException('Got fragment', 'SyntaxError')
|
|
}
|
|
|
|
// 8. If protocols is a string, set protocols to a sequence consisting
|
|
// of just that string.
|
|
if (typeof protocols === 'string') {
|
|
protocols = [protocols]
|
|
}
|
|
|
|
// 9. If any of the values in protocols occur more than once or otherwise
|
|
// fail to match the requirements for elements that comprise the value
|
|
// of `Sec-WebSocket-Protocol` fields as defined by The WebSocket
|
|
// protocol, then throw a "SyntaxError" DOMException.
|
|
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')
|
|
}
|
|
|
|
// 10. Set this's url to urlRecord.
|
|
this[kWebSocketURL] = new URL(urlRecord.href)
|
|
|
|
// 11. Let client be this's relevant settings object.
|
|
const client = environmentSettingsObject.settingsObject
|
|
|
|
// 12. Run this step in parallel:
|
|
|
|
// 1. Establish a WebSocket connection given urlRecord, protocols,
|
|
// and client.
|
|
this[kController] = establishWebSocketConnection(
|
|
urlRecord,
|
|
protocols,
|
|
client,
|
|
this,
|
|
(response, extensions) => this.#onConnectionEstablished(response, extensions),
|
|
options
|
|
)
|
|
|
|
// Each WebSocket object has an associated ready state, which is a
|
|
// number representing the state of the connection. Initially it must
|
|
// be CONNECTING (0).
|
|
this[kReadyState] = WebSocket.CONNECTING
|
|
|
|
this[kSentClose] = sentCloseFrameState.NOT_SENT
|
|
|
|
// The extensions attribute must initially return the empty string.
|
|
|
|
// The protocol attribute must initially return the empty string.
|
|
|
|
// Each WebSocket object has an associated binary type, which is a
|
|
// BinaryType. Initially it must be "blob".
|
|
this[kBinaryType] = 'blob'
|
|
}
|
|
|
|
/**
|
|
* @see https://websockets.spec.whatwg.org/#dom-websocket-close
|
|
* @param {number|undefined} code
|
|
* @param {string|undefined} reason
|
|
*/
|
|
close (code = undefined, reason = undefined) {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
const prefix = 'WebSocket.close'
|
|
|
|
if (code !== undefined) {
|
|
code = webidl.converters['unsigned short'](code, prefix, 'code', { clamp: true })
|
|
}
|
|
|
|
if (reason !== undefined) {
|
|
reason = webidl.converters.USVString(reason, prefix, 'reason')
|
|
}
|
|
|
|
// 1. If code is present, but is neither an integer equal to 1000 nor an
|
|
// integer in the range 3000 to 4999, inclusive, throw an
|
|
// "InvalidAccessError" DOMException.
|
|
if (code !== undefined) {
|
|
if (code !== 1000 && (code < 3000 || code > 4999)) {
|
|
throw new DOMException('invalid code', 'InvalidAccessError')
|
|
}
|
|
}
|
|
|
|
let reasonByteLength = 0
|
|
|
|
// 2. If reason is present, then run these substeps:
|
|
if (reason !== undefined) {
|
|
// 1. Let reasonBytes be the result of encoding reason.
|
|
// 2. If reasonBytes is longer than 123 bytes, then throw a
|
|
// "SyntaxError" DOMException.
|
|
reasonByteLength = Buffer.byteLength(reason)
|
|
|
|
if (reasonByteLength > 123) {
|
|
throw new DOMException(
|
|
`Reason must be less than 123 bytes; received ${reasonByteLength}`,
|
|
'SyntaxError'
|
|
)
|
|
}
|
|
}
|
|
|
|
// 3. Run the first matching steps from the following list:
|
|
closeWebSocketConnection(this, code, reason, reasonByteLength)
|
|
}
|
|
|
|
/**
|
|
* @see https://websockets.spec.whatwg.org/#dom-websocket-send
|
|
* @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data
|
|
*/
|
|
send (data) {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
const prefix = 'WebSocket.send'
|
|
webidl.argumentLengthCheck(arguments, 1, prefix)
|
|
|
|
data = webidl.converters.WebSocketSendData(data, prefix, 'data')
|
|
|
|
// 1. If this's ready state is CONNECTING, then throw an
|
|
// "InvalidStateError" DOMException.
|
|
if (isConnecting(this)) {
|
|
throw new DOMException('Sent before connected.', 'InvalidStateError')
|
|
}
|
|
|
|
// 2. Run the appropriate set of steps from the following list:
|
|
// https://datatracker.ietf.org/doc/html/rfc6455#section-6.1
|
|
// https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
|
|
|
|
if (!isEstablished(this) || isClosing(this)) {
|
|
return
|
|
}
|
|
|
|
// If data is a string
|
|
if (typeof data === 'string') {
|
|
// If the WebSocket connection is established and the WebSocket
|
|
// closing handshake has not yet started, then the user agent
|
|
// must send a WebSocket Message comprised of the data argument
|
|
// using a text frame opcode; if the data cannot be sent, e.g.
|
|
// because it would need to be buffered but the buffer is full,
|
|
// the user agent must flag the WebSocket as full and then close
|
|
// the WebSocket connection. Any invocation of this method with a
|
|
// string argument that does not throw an exception must increase
|
|
// the bufferedAmount attribute by the number of bytes needed to
|
|
// express the argument as UTF-8.
|
|
|
|
const length = Buffer.byteLength(data)
|
|
|
|
this.#bufferedAmount += length
|
|
this.#sendQueue.add(data, () => {
|
|
this.#bufferedAmount -= length
|
|
}, sendHints.string)
|
|
} else if (types.isArrayBuffer(data)) {
|
|
// If the WebSocket connection is established, and the WebSocket
|
|
// closing handshake has not yet started, then the user agent must
|
|
// send a WebSocket Message comprised of data using a binary frame
|
|
// opcode; if the data cannot be sent, e.g. because it would need
|
|
// to be buffered but the buffer is full, the user agent must flag
|
|
// the WebSocket as full and then close the WebSocket connection.
|
|
// The data to be sent is the data stored in the buffer described
|
|
// by the ArrayBuffer object. Any invocation of this method with an
|
|
// ArrayBuffer argument that does not throw an exception must
|
|
// increase the bufferedAmount attribute by the length of the
|
|
// ArrayBuffer in bytes.
|
|
|
|
this.#bufferedAmount += data.byteLength
|
|
this.#sendQueue.add(data, () => {
|
|
this.#bufferedAmount -= data.byteLength
|
|
}, sendHints.arrayBuffer)
|
|
} else if (ArrayBuffer.isView(data)) {
|
|
// If the WebSocket connection is established, and the WebSocket
|
|
// closing handshake has not yet started, then the user agent must
|
|
// send a WebSocket Message comprised of data using a binary frame
|
|
// opcode; if the data cannot be sent, e.g. because it would need to
|
|
// be buffered but the buffer is full, the user agent must flag the
|
|
// WebSocket as full and then close the WebSocket connection. The
|
|
// data to be sent is the data stored in the section of the buffer
|
|
// described by the ArrayBuffer object that data references. Any
|
|
// invocation of this method with this kind of argument that does
|
|
// not throw an exception must increase the bufferedAmount attribute
|
|
// by the length of data’s buffer in bytes.
|
|
|
|
this.#bufferedAmount += data.byteLength
|
|
this.#sendQueue.add(data, () => {
|
|
this.#bufferedAmount -= data.byteLength
|
|
}, sendHints.typedArray)
|
|
} else if (isBlobLike(data)) {
|
|
// If the WebSocket connection is established, and the WebSocket
|
|
// closing handshake has not yet started, then the user agent must
|
|
// send a WebSocket Message comprised of data using a binary frame
|
|
// opcode; if the data cannot be sent, e.g. because it would need to
|
|
// be buffered but the buffer is full, the user agent must flag the
|
|
// WebSocket as full and then close the WebSocket connection. The data
|
|
// to be sent is the raw data represented by the Blob object. Any
|
|
// invocation of this method with a Blob argument that does not throw
|
|
// an exception must increase the bufferedAmount attribute by the size
|
|
// of the Blob object’s raw data, in bytes.
|
|
|
|
this.#bufferedAmount += data.size
|
|
this.#sendQueue.add(data, () => {
|
|
this.#bufferedAmount -= data.size
|
|
}, sendHints.blob)
|
|
}
|
|
}
|
|
|
|
get readyState () {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
// The readyState getter steps are to return this's ready state.
|
|
return this[kReadyState]
|
|
}
|
|
|
|
get bufferedAmount () {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
return this.#bufferedAmount
|
|
}
|
|
|
|
get url () {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
// The url getter steps are to return this's url, serialized.
|
|
return URLSerializer(this[kWebSocketURL])
|
|
}
|
|
|
|
get extensions () {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
return this.#extensions
|
|
}
|
|
|
|
get protocol () {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
return this.#protocol
|
|
}
|
|
|
|
get onopen () {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
return this.#events.open
|
|
}
|
|
|
|
set onopen (fn) {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
if (this.#events.open) {
|
|
this.removeEventListener('open', this.#events.open)
|
|
}
|
|
|
|
if (typeof fn === 'function') {
|
|
this.#events.open = fn
|
|
this.addEventListener('open', fn)
|
|
} else {
|
|
this.#events.open = null
|
|
}
|
|
}
|
|
|
|
get onerror () {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
return this.#events.error
|
|
}
|
|
|
|
set onerror (fn) {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
if (this.#events.error) {
|
|
this.removeEventListener('error', this.#events.error)
|
|
}
|
|
|
|
if (typeof fn === 'function') {
|
|
this.#events.error = fn
|
|
this.addEventListener('error', fn)
|
|
} else {
|
|
this.#events.error = null
|
|
}
|
|
}
|
|
|
|
get onclose () {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
return this.#events.close
|
|
}
|
|
|
|
set onclose (fn) {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
if (this.#events.close) {
|
|
this.removeEventListener('close', this.#events.close)
|
|
}
|
|
|
|
if (typeof fn === 'function') {
|
|
this.#events.close = fn
|
|
this.addEventListener('close', fn)
|
|
} else {
|
|
this.#events.close = null
|
|
}
|
|
}
|
|
|
|
get onmessage () {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
return this.#events.message
|
|
}
|
|
|
|
set onmessage (fn) {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
if (this.#events.message) {
|
|
this.removeEventListener('message', this.#events.message)
|
|
}
|
|
|
|
if (typeof fn === 'function') {
|
|
this.#events.message = fn
|
|
this.addEventListener('message', fn)
|
|
} else {
|
|
this.#events.message = null
|
|
}
|
|
}
|
|
|
|
get binaryType () {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
return this[kBinaryType]
|
|
}
|
|
|
|
set binaryType (type) {
|
|
webidl.brandCheck(this, WebSocket)
|
|
|
|
if (type !== 'blob' && type !== 'arraybuffer') {
|
|
this[kBinaryType] = 'blob'
|
|
} else {
|
|
this[kBinaryType] = type
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
|
|
*/
|
|
#onConnectionEstablished (response, parsedExtensions) {
|
|
// processResponse is called when the "response's header list has been received and initialized."
|
|
// once this happens, the connection is open
|
|
this[kResponse] = response
|
|
|
|
const webSocketOptions = this[kController]?.dispatcher?.webSocketOptions
|
|
const maxFragments = webSocketOptions?.maxFragments
|
|
const maxPayloadSize = webSocketOptions?.maxPayloadSize
|
|
|
|
const parser = new ByteParser(this, parsedExtensions, {
|
|
maxFragments,
|
|
maxPayloadSize
|
|
})
|
|
parser.on('drain', onParserDrain)
|
|
parser.on('error', onParserError.bind(this))
|
|
|
|
response.socket.ws = this
|
|
this[kByteParser] = parser
|
|
|
|
this.#sendQueue = new SendQueue(response.socket)
|
|
|
|
// 1. Change the ready state to OPEN (1).
|
|
this[kReadyState] = states.OPEN
|
|
|
|
// 2. Change the extensions attribute’s value to the extensions in use, if
|
|
// it is not the null value.
|
|
// https://datatracker.ietf.org/doc/html/rfc6455#section-9.1
|
|
const extensions = response.headersList.get('sec-websocket-extensions')
|
|
|
|
if (extensions !== null) {
|
|
this.#extensions = extensions
|
|
}
|
|
|
|
// 3. Change the protocol attribute’s value to the subprotocol in use, if
|
|
// it is not the null value.
|
|
// https://datatracker.ietf.org/doc/html/rfc6455#section-1.9
|
|
const protocol = response.headersList.get('sec-websocket-protocol')
|
|
|
|
if (protocol !== null) {
|
|
this.#protocol = protocol
|
|
}
|
|
|
|
// 4. Fire an event named open at the WebSocket object.
|
|
fireEvent('open', this)
|
|
}
|
|
}
|
|
|
|
// https://websockets.spec.whatwg.org/#dom-websocket-connecting
|
|
WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING
|
|
// https://websockets.spec.whatwg.org/#dom-websocket-open
|
|
WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN
|
|
// https://websockets.spec.whatwg.org/#dom-websocket-closing
|
|
WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING
|
|
// https://websockets.spec.whatwg.org/#dom-websocket-closed
|
|
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, prefix, argument) {
|
|
if (webidl.util.Type(V) === 'Object' && Symbol.iterator in V) {
|
|
return webidl.converters['sequence<DOMString>'](V)
|
|
}
|
|
|
|
return webidl.converters.DOMString(V, prefix, argument)
|
|
}
|
|
|
|
// This implements the proposal made in https://github.com/whatwg/websockets/issues/42
|
|
webidl.converters.WebSocketInit = webidl.dictionaryConverter([
|
|
{
|
|
key: 'protocols',
|
|
converter: webidl.converters['DOMString or sequence<DOMString>'],
|
|
defaultValue: () => new Array(0)
|
|
},
|
|
{
|
|
key: 'dispatcher',
|
|
converter: webidl.converters.any,
|
|
defaultValue: () => getGlobalDispatcher()
|
|
},
|
|
{
|
|
key: 'headers',
|
|
converter: webidl.nullableConverter(webidl.converters.HeadersInit)
|
|
}
|
|
])
|
|
|
|
webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'] = function (V) {
|
|
if (webidl.util.Type(V) === 'Object' && !(Symbol.iterator in V)) {
|
|
return webidl.converters.WebSocketInit(V)
|
|
}
|
|
|
|
return { protocols: webidl.converters['DOMString or sequence<DOMString>'](V) }
|
|
}
|
|
|
|
webidl.converters.WebSocketSendData = function (V) {
|
|
if (webidl.util.Type(V) === 'Object') {
|
|
if (isBlobLike(V)) {
|
|
return webidl.converters.Blob(V, { strict: false })
|
|
}
|
|
|
|
if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
|
|
return webidl.converters.BufferSource(V)
|
|
}
|
|
}
|
|
|
|
return webidl.converters.USVString(V)
|
|
}
|
|
|
|
function onParserDrain () {
|
|
this.ws[kResponse].socket.resume()
|
|
}
|
|
|
|
function onParserError (err) {
|
|
let message
|
|
let code
|
|
|
|
if (err instanceof CloseEvent) {
|
|
message = err.reason
|
|
code = err.code
|
|
} else {
|
|
message = err.message
|
|
}
|
|
|
|
fireEvent('error', this, () => new ErrorEvent('error', { error: err, message }))
|
|
|
|
closeWebSocketConnection(this, code)
|
|
}
|
|
|
|
module.exports = {
|
|
WebSocket
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2613:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("assert");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4434:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("events");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8611:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("http");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5692:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("https");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9278:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("net");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4589:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:assert");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6698:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:async_hooks");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4573:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:buffer");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7540:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:console");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7598:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:crypto");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3053:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:diagnostics_channel");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 610:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:dns");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8474:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:events");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7067:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:http");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2467:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:http2");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7030:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:net");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 643:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:perf_hooks");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1792:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:querystring");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7075:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:stream");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1692:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:tls");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3136:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:url");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7975:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:util");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3429:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:util/types");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5919:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:worker_threads");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8522:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:zlib");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3193:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("string_decoder");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4756:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("tls");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9023:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("util");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4649:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
var __webpack_unused_export__;
|
|
|
|
/*!
|
|
* content-type
|
|
* Copyright(c) 2015 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
__webpack_unused_export__ = ({ value: true });
|
|
__webpack_unused_export__ = format;
|
|
exports.qg = parse;
|
|
const TEXT_REGEXP = /^[\u0009\u0020-\u007e\u0080-\u00ff]*$/;
|
|
const TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
|
|
/**
|
|
* RegExp to match chars that must be quoted-pair in RFC 9110 sec 5.6.4
|
|
*/
|
|
const QUOTE_REGEXP = /[\\"]/g;
|
|
/**
|
|
* RegExp to match type in RFC 9110 sec 8.3.1
|
|
*
|
|
* media-type = type "/" subtype
|
|
* type = token
|
|
* subtype = token
|
|
*/
|
|
const TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
|
|
/**
|
|
* Null object perf optimization. Faster than `Object.create(null)` and `{ __proto__: null }`.
|
|
*/
|
|
const NullObject = /* @__PURE__ */ (() => {
|
|
const C = function () { };
|
|
C.prototype = Object.create(null);
|
|
return C;
|
|
})();
|
|
/**
|
|
* Format an object into a `Content-Type` header.
|
|
*/
|
|
function format(obj) {
|
|
const { type, parameters } = obj;
|
|
if (!type || !TYPE_REGEXP.test(type)) {
|
|
throw new TypeError(`Invalid type: ${type}`);
|
|
}
|
|
let result = type;
|
|
if (parameters) {
|
|
for (const param of Object.keys(parameters)) {
|
|
if (!TOKEN_REGEXP.test(param)) {
|
|
throw new TypeError(`Invalid parameter name: ${param}`);
|
|
}
|
|
result += `; ${param}=${qstring(parameters[param])}`;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Parse a `Content-Type` header.
|
|
*/
|
|
function parse(header, options) {
|
|
const len = header.length;
|
|
let index = skipOWS(header, 0, len);
|
|
const valueStart = index;
|
|
index = skipValue(header, index, len);
|
|
const valueEnd = trailingOWS(header, valueStart, index);
|
|
const type = header.slice(valueStart, valueEnd).toLowerCase();
|
|
const parameters = options?.parameters === false
|
|
? new NullObject()
|
|
: parseParameters(header, index, len);
|
|
return { type, parameters };
|
|
}
|
|
const SP = 32; // " "
|
|
const HTAB = 9; // "\t"
|
|
const SEMI = 59; // ";"
|
|
const EQ = 61; // "="
|
|
const DQUOTE = 34; // '"'
|
|
const BSLASH = 92; // "\\"
|
|
/**
|
|
* Parses the parameters of a `Content-Type` header starting at the given index.
|
|
*/
|
|
function parseParameters(header, index, len) {
|
|
const parameters = new NullObject();
|
|
parameter: while (index < len) {
|
|
index = skipOWS(header, index + 1 /* Skip over ; */, len);
|
|
const keyStart = index;
|
|
while (index < len) {
|
|
const code = header.charCodeAt(index);
|
|
if (code === SEMI)
|
|
continue parameter;
|
|
if (code === EQ) {
|
|
const keyEnd = trailingOWS(header, keyStart, index);
|
|
const key = header.slice(keyStart, keyEnd).toLowerCase();
|
|
index = skipOWS(header, index + 1, len);
|
|
if (index < len && header.charCodeAt(index) === DQUOTE) {
|
|
index++;
|
|
let value = "";
|
|
while (index < len) {
|
|
const code = header.charCodeAt(index++);
|
|
if (code === DQUOTE) {
|
|
index = skipValue(header, index, len);
|
|
if (parameters[key] === undefined)
|
|
parameters[key] = value;
|
|
break;
|
|
}
|
|
if (code === BSLASH && index < len) {
|
|
value += header[index++];
|
|
continue;
|
|
}
|
|
value += String.fromCharCode(code);
|
|
}
|
|
continue parameter;
|
|
}
|
|
const valueStart = index;
|
|
index = skipValue(header, index, len);
|
|
if (parameters[key] === undefined) {
|
|
const valueEnd = trailingOWS(header, valueStart, index);
|
|
parameters[key] = header.slice(valueStart, valueEnd);
|
|
}
|
|
continue parameter;
|
|
}
|
|
index++;
|
|
}
|
|
}
|
|
return parameters;
|
|
}
|
|
/**
|
|
* Skip over characters until a semicolon.
|
|
*/
|
|
function skipValue(str, index, len) {
|
|
while (index < len) {
|
|
const char = str.charCodeAt(index);
|
|
if (char === SEMI)
|
|
break;
|
|
index++;
|
|
}
|
|
return index;
|
|
}
|
|
/**
|
|
* Skip optional whitespace (OWS) in an HTTP header value.
|
|
*
|
|
* OWS is defined in RFC 9110 sec 5.6.3 as SP (" ") or HTAB ("\t").
|
|
*/
|
|
function skipOWS(header, index, len) {
|
|
while (index < len) {
|
|
const char = header.charCodeAt(index);
|
|
if (char !== SP && char !== HTAB)
|
|
break;
|
|
index++;
|
|
}
|
|
return index;
|
|
}
|
|
/**
|
|
* Trim optional whitespace (OWS) from the end of a substring.
|
|
*
|
|
* OWS is defined in RFC 9110 sec 5.6.3 as SP (" ") or HTAB ("\t").
|
|
*/
|
|
function trailingOWS(header, start, end) {
|
|
while (end > start) {
|
|
const char = header.charCodeAt(end - 1);
|
|
if (char !== SP && char !== HTAB)
|
|
break;
|
|
end--;
|
|
}
|
|
return end;
|
|
}
|
|
/**
|
|
* Serialize a parameter value.
|
|
*/
|
|
function qstring(str) {
|
|
if (TOKEN_REGEXP.test(str))
|
|
return str;
|
|
if (TEXT_REGEXP.test(str))
|
|
return `"${str.replace(QUOTE_REGEXP, "\\$&")}"`;
|
|
throw new TypeError(`Invalid parameter value: ${str}`);
|
|
}
|
|
//# sourceMappingURL=index.js.map
|
|
|
|
/***/ })
|
|
|
|
/******/ });
|
|
/************************************************************************/
|
|
/******/ // The module cache
|
|
/******/ var __webpack_module_cache__ = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __nccwpck_require__(moduleId) {
|
|
/******/ // Check if module is in cache
|
|
/******/ var cachedModule = __webpack_module_cache__[moduleId];
|
|
/******/ if (cachedModule !== undefined) {
|
|
/******/ return cachedModule.exports;
|
|
/******/ }
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = __webpack_module_cache__[moduleId] = {
|
|
/******/ // no module.id needed
|
|
/******/ // no module.loaded needed
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ var threw = true;
|
|
/******/ try {
|
|
/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __nccwpck_require__);
|
|
/******/ threw = false;
|
|
/******/ } finally {
|
|
/******/ if(threw) delete __webpack_module_cache__[moduleId];
|
|
/******/ }
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/************************************************************************/
|
|
/******/ /* webpack/runtime/compat */
|
|
/******/
|
|
/******/ if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = new URL('.', import.meta.url).pathname.slice(import.meta.url.match(/^file:\/\/\/\w:/) ? 1 : 0, -1) + "/";
|
|
/******/
|
|
/************************************************************************/
|
|
var __webpack_exports__ = {};
|
|
|
|
;// CONCATENATED MODULE: external "os"
|
|
const external_os_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("os");
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/core/lib/utils.js
|
|
// We use any as a valid input type
|
|
/* eslint-disable @typescript-eslint/no-explicit-any */
|
|
/**
|
|
* Sanitizes an input into a string so it can be passed into issueCommand safely
|
|
* @param input input to sanitize into a string
|
|
*/
|
|
function utils_toCommandValue(input) {
|
|
if (input === null || input === undefined) {
|
|
return '';
|
|
}
|
|
else if (typeof input === 'string' || input instanceof String) {
|
|
return input;
|
|
}
|
|
return JSON.stringify(input);
|
|
}
|
|
/**
|
|
*
|
|
* @param annotationProperties
|
|
* @returns The command properties to send with the actual annotation command
|
|
* See IssueCommandProperties: https://github.com/actions/runner/blob/main/src/Runner.Worker/ActionCommandManager.cs#L646
|
|
*/
|
|
function utils_toCommandProperties(annotationProperties) {
|
|
if (!Object.keys(annotationProperties).length) {
|
|
return {};
|
|
}
|
|
return {
|
|
title: annotationProperties.title,
|
|
file: annotationProperties.file,
|
|
line: annotationProperties.startLine,
|
|
endLine: annotationProperties.endLine,
|
|
col: annotationProperties.startColumn,
|
|
endColumn: annotationProperties.endColumn
|
|
};
|
|
}
|
|
//# sourceMappingURL=utils.js.map
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/core/lib/command.js
|
|
|
|
|
|
/**
|
|
* Issues a command to the GitHub Actions runner
|
|
*
|
|
* @param command - The command name to issue
|
|
* @param properties - Additional properties for the command (key-value pairs)
|
|
* @param message - The message to include with the command
|
|
* @remarks
|
|
* This function outputs a specially formatted string to stdout that the Actions
|
|
* runner interprets as a command. These commands can control workflow behavior,
|
|
* set outputs, create annotations, mask values, and more.
|
|
*
|
|
* Command Format:
|
|
* ::name key=value,key=value::message
|
|
*
|
|
* @example
|
|
* ```typescript
|
|
* // Issue a warning annotation
|
|
* issueCommand('warning', {}, 'This is a warning message');
|
|
* // Output: ::warning::This is a warning message
|
|
*
|
|
* // Set an environment variable
|
|
* issueCommand('set-env', { name: 'MY_VAR' }, 'some value');
|
|
* // Output: ::set-env name=MY_VAR::some value
|
|
*
|
|
* // Add a secret mask
|
|
* issueCommand('add-mask', {}, 'secretValue123');
|
|
* // Output: ::add-mask::secretValue123
|
|
* ```
|
|
*
|
|
* @internal
|
|
* This is an internal utility function that powers the public API functions
|
|
* such as setSecret, warning, error, and exportVariable.
|
|
*/
|
|
function command_issueCommand(command, properties, message) {
|
|
const cmd = new Command(command, properties, message);
|
|
process.stdout.write(cmd.toString() + external_os_namespaceObject.EOL);
|
|
}
|
|
function command_issue(name, message = '') {
|
|
command_issueCommand(name, {}, message);
|
|
}
|
|
const CMD_STRING = '::';
|
|
class Command {
|
|
constructor(command, properties, message) {
|
|
if (!command) {
|
|
command = 'missing.command';
|
|
}
|
|
this.command = command;
|
|
this.properties = properties;
|
|
this.message = message;
|
|
}
|
|
toString() {
|
|
let cmdStr = CMD_STRING + this.command;
|
|
if (this.properties && Object.keys(this.properties).length > 0) {
|
|
cmdStr += ' ';
|
|
let first = true;
|
|
for (const key in this.properties) {
|
|
if (this.properties.hasOwnProperty(key)) {
|
|
const val = this.properties[key];
|
|
if (val) {
|
|
if (first) {
|
|
first = false;
|
|
}
|
|
else {
|
|
cmdStr += ',';
|
|
}
|
|
cmdStr += `${key}=${escapeProperty(val)}`;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
|
|
return cmdStr;
|
|
}
|
|
}
|
|
function escapeData(s) {
|
|
return utils_toCommandValue(s)
|
|
.replace(/%/g, '%25')
|
|
.replace(/\r/g, '%0D')
|
|
.replace(/\n/g, '%0A');
|
|
}
|
|
function escapeProperty(s) {
|
|
return utils_toCommandValue(s)
|
|
.replace(/%/g, '%25')
|
|
.replace(/\r/g, '%0D')
|
|
.replace(/\n/g, '%0A')
|
|
.replace(/:/g, '%3A')
|
|
.replace(/,/g, '%2C');
|
|
}
|
|
//# sourceMappingURL=command.js.map
|
|
;// CONCATENATED MODULE: external "crypto"
|
|
const external_crypto_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("crypto");
|
|
;// CONCATENATED MODULE: external "fs"
|
|
const external_fs_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("fs");
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/core/lib/file-command.js
|
|
// For internal use, subject to change.
|
|
// We use any as a valid input type
|
|
/* eslint-disable @typescript-eslint/no-explicit-any */
|
|
|
|
|
|
|
|
|
|
function file_command_issueFileCommand(command, message) {
|
|
const filePath = process.env[`GITHUB_${command}`];
|
|
if (!filePath) {
|
|
throw new Error(`Unable to find environment variable for file command ${command}`);
|
|
}
|
|
if (!external_fs_namespaceObject.existsSync(filePath)) {
|
|
throw new Error(`Missing file at path: ${filePath}`);
|
|
}
|
|
external_fs_namespaceObject.appendFileSync(filePath, `${utils_toCommandValue(message)}${external_os_namespaceObject.EOL}`, {
|
|
encoding: 'utf8'
|
|
});
|
|
}
|
|
function file_command_prepareKeyValueMessage(key, value) {
|
|
const delimiter = `ghadelimiter_${external_crypto_namespaceObject.randomUUID()}`;
|
|
const convertedValue = utils_toCommandValue(value);
|
|
// These should realistically never happen, but just in case someone finds a
|
|
// way to exploit uuid generation let's not allow keys or values that contain
|
|
// the delimiter.
|
|
if (key.includes(delimiter)) {
|
|
throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`);
|
|
}
|
|
if (convertedValue.includes(delimiter)) {
|
|
throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`);
|
|
}
|
|
return `${key}<<${delimiter}${external_os_namespaceObject.EOL}${convertedValue}${external_os_namespaceObject.EOL}${delimiter}`;
|
|
}
|
|
//# sourceMappingURL=file-command.js.map
|
|
;// CONCATENATED MODULE: external "path"
|
|
const external_path_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("path");
|
|
// EXTERNAL MODULE: external "http"
|
|
var external_http_ = __nccwpck_require__(8611);
|
|
// EXTERNAL MODULE: external "https"
|
|
var external_https_ = __nccwpck_require__(5692);
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/http-client/lib/proxy.js
|
|
function getProxyUrl(reqUrl) {
|
|
const usingSsl = reqUrl.protocol === 'https:';
|
|
if (checkBypass(reqUrl)) {
|
|
return undefined;
|
|
}
|
|
const proxyVar = (() => {
|
|
if (usingSsl) {
|
|
return process.env['https_proxy'] || process.env['HTTPS_PROXY'];
|
|
}
|
|
else {
|
|
return process.env['http_proxy'] || process.env['HTTP_PROXY'];
|
|
}
|
|
})();
|
|
if (proxyVar) {
|
|
try {
|
|
return new DecodedURL(proxyVar);
|
|
}
|
|
catch (_a) {
|
|
if (!proxyVar.startsWith('http://') && !proxyVar.startsWith('https://'))
|
|
return new DecodedURL(`http://${proxyVar}`);
|
|
}
|
|
}
|
|
else {
|
|
return undefined;
|
|
}
|
|
}
|
|
function checkBypass(reqUrl) {
|
|
if (!reqUrl.hostname) {
|
|
return false;
|
|
}
|
|
const reqHost = reqUrl.hostname;
|
|
if (isLoopbackAddress(reqHost)) {
|
|
return true;
|
|
}
|
|
const noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || '';
|
|
if (!noProxy) {
|
|
return false;
|
|
}
|
|
// Determine the request port
|
|
let reqPort;
|
|
if (reqUrl.port) {
|
|
reqPort = Number(reqUrl.port);
|
|
}
|
|
else if (reqUrl.protocol === 'http:') {
|
|
reqPort = 80;
|
|
}
|
|
else if (reqUrl.protocol === 'https:') {
|
|
reqPort = 443;
|
|
}
|
|
// Format the request hostname and hostname with port
|
|
const upperReqHosts = [reqUrl.hostname.toUpperCase()];
|
|
if (typeof reqPort === 'number') {
|
|
upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`);
|
|
}
|
|
// Compare request host against noproxy
|
|
for (const upperNoProxyItem of noProxy
|
|
.split(',')
|
|
.map(x => x.trim().toUpperCase())
|
|
.filter(x => x)) {
|
|
if (upperNoProxyItem === '*' ||
|
|
upperReqHosts.some(x => x === upperNoProxyItem ||
|
|
x.endsWith(`.${upperNoProxyItem}`) ||
|
|
(upperNoProxyItem.startsWith('.') &&
|
|
x.endsWith(`${upperNoProxyItem}`)))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isLoopbackAddress(host) {
|
|
const hostLower = host.toLowerCase();
|
|
return (hostLower === 'localhost' ||
|
|
hostLower.startsWith('127.') ||
|
|
hostLower.startsWith('[::1]') ||
|
|
hostLower.startsWith('[0:0:0:0:0:0:0:1]'));
|
|
}
|
|
class DecodedURL extends URL {
|
|
constructor(url, base) {
|
|
super(url, base);
|
|
this._decodedUsername = decodeURIComponent(super.username);
|
|
this._decodedPassword = decodeURIComponent(super.password);
|
|
}
|
|
get username() {
|
|
return this._decodedUsername;
|
|
}
|
|
get password() {
|
|
return this._decodedPassword;
|
|
}
|
|
}
|
|
//# sourceMappingURL=proxy.js.map
|
|
// EXTERNAL MODULE: ./node_modules/tunnel/index.js
|
|
var node_modules_tunnel = __nccwpck_require__(770);
|
|
// EXTERNAL MODULE: ./node_modules/undici/index.js
|
|
var undici = __nccwpck_require__(6752);
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/http-client/lib/index.js
|
|
/* eslint-disable @typescript-eslint/no-explicit-any */
|
|
var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
var HttpCodes;
|
|
(function (HttpCodes) {
|
|
HttpCodes[HttpCodes["OK"] = 200] = "OK";
|
|
HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices";
|
|
HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently";
|
|
HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved";
|
|
HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther";
|
|
HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified";
|
|
HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy";
|
|
HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy";
|
|
HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect";
|
|
HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect";
|
|
HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest";
|
|
HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized";
|
|
HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired";
|
|
HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden";
|
|
HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound";
|
|
HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed";
|
|
HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable";
|
|
HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
|
|
HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout";
|
|
HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict";
|
|
HttpCodes[HttpCodes["Gone"] = 410] = "Gone";
|
|
HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests";
|
|
HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError";
|
|
HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented";
|
|
HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway";
|
|
HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable";
|
|
HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout";
|
|
})(HttpCodes || (HttpCodes = {}));
|
|
var Headers;
|
|
(function (Headers) {
|
|
Headers["Accept"] = "accept";
|
|
Headers["ContentType"] = "content-type";
|
|
})(Headers || (Headers = {}));
|
|
var MediaTypes;
|
|
(function (MediaTypes) {
|
|
MediaTypes["ApplicationJson"] = "application/json";
|
|
})(MediaTypes || (MediaTypes = {}));
|
|
/**
|
|
* Returns the proxy URL, depending upon the supplied url and proxy environment variables.
|
|
* @param serverUrl The server URL where the request will be sent. For example, https://api.github.com
|
|
*/
|
|
function lib_getProxyUrl(serverUrl) {
|
|
const proxyUrl = pm.getProxyUrl(new URL(serverUrl));
|
|
return proxyUrl ? proxyUrl.href : '';
|
|
}
|
|
const HttpRedirectCodes = [
|
|
HttpCodes.MovedPermanently,
|
|
HttpCodes.ResourceMoved,
|
|
HttpCodes.SeeOther,
|
|
HttpCodes.TemporaryRedirect,
|
|
HttpCodes.PermanentRedirect
|
|
];
|
|
const HttpResponseRetryCodes = [
|
|
HttpCodes.BadGateway,
|
|
HttpCodes.ServiceUnavailable,
|
|
HttpCodes.GatewayTimeout
|
|
];
|
|
const RetryableHttpVerbs = (/* unused pure expression or super */ null && (['OPTIONS', 'GET', 'DELETE', 'HEAD']));
|
|
const ExponentialBackoffCeiling = 10;
|
|
const ExponentialBackoffTimeSlice = 5;
|
|
class HttpClientError extends Error {
|
|
constructor(message, statusCode) {
|
|
super(message);
|
|
this.name = 'HttpClientError';
|
|
this.statusCode = statusCode;
|
|
Object.setPrototypeOf(this, HttpClientError.prototype);
|
|
}
|
|
}
|
|
class HttpClientResponse {
|
|
constructor(message) {
|
|
this.message = message;
|
|
}
|
|
readBody() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
|
|
let output = Buffer.alloc(0);
|
|
this.message.on('data', (chunk) => {
|
|
output = Buffer.concat([output, chunk]);
|
|
});
|
|
this.message.on('end', () => {
|
|
resolve(output.toString());
|
|
});
|
|
}));
|
|
});
|
|
}
|
|
readBodyBuffer() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
|
|
const chunks = [];
|
|
this.message.on('data', (chunk) => {
|
|
chunks.push(chunk);
|
|
});
|
|
this.message.on('end', () => {
|
|
resolve(Buffer.concat(chunks));
|
|
});
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
function isHttps(requestUrl) {
|
|
const parsedUrl = new URL(requestUrl);
|
|
return parsedUrl.protocol === 'https:';
|
|
}
|
|
class lib_HttpClient {
|
|
constructor(userAgent, handlers, requestOptions) {
|
|
this._ignoreSslError = false;
|
|
this._allowRedirects = true;
|
|
this._allowRedirectDowngrade = false;
|
|
this._maxRedirects = 50;
|
|
this._allowRetries = false;
|
|
this._maxRetries = 1;
|
|
this._keepAlive = false;
|
|
this._disposed = false;
|
|
this.userAgent = this._getUserAgentWithOrchestrationId(userAgent);
|
|
this.handlers = handlers || [];
|
|
this.requestOptions = requestOptions;
|
|
if (requestOptions) {
|
|
if (requestOptions.ignoreSslError != null) {
|
|
this._ignoreSslError = requestOptions.ignoreSslError;
|
|
}
|
|
this._socketTimeout = requestOptions.socketTimeout;
|
|
if (requestOptions.allowRedirects != null) {
|
|
this._allowRedirects = requestOptions.allowRedirects;
|
|
}
|
|
if (requestOptions.allowRedirectDowngrade != null) {
|
|
this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade;
|
|
}
|
|
if (requestOptions.maxRedirects != null) {
|
|
this._maxRedirects = Math.max(requestOptions.maxRedirects, 0);
|
|
}
|
|
if (requestOptions.keepAlive != null) {
|
|
this._keepAlive = requestOptions.keepAlive;
|
|
}
|
|
if (requestOptions.allowRetries != null) {
|
|
this._allowRetries = requestOptions.allowRetries;
|
|
}
|
|
if (requestOptions.maxRetries != null) {
|
|
this._maxRetries = requestOptions.maxRetries;
|
|
}
|
|
}
|
|
}
|
|
options(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('OPTIONS', requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
get(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('GET', requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
del(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('DELETE', requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
post(requestUrl, data, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('POST', requestUrl, data, additionalHeaders || {});
|
|
});
|
|
}
|
|
patch(requestUrl, data, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('PATCH', requestUrl, data, additionalHeaders || {});
|
|
});
|
|
}
|
|
put(requestUrl, data, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('PUT', requestUrl, data, additionalHeaders || {});
|
|
});
|
|
}
|
|
head(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request('HEAD', requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
sendStream(verb, requestUrl, stream, additionalHeaders) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return this.request(verb, requestUrl, stream, additionalHeaders);
|
|
});
|
|
}
|
|
/**
|
|
* Gets a typed object from an endpoint
|
|
* Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise
|
|
*/
|
|
getJson(requestUrl_1) {
|
|
return __awaiter(this, arguments, void 0, function* (requestUrl, additionalHeaders = {}) {
|
|
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
|
const res = yield this.get(requestUrl, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
postJson(requestUrl_1, obj_1) {
|
|
return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) {
|
|
const data = JSON.stringify(obj, null, 2);
|
|
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
|
additionalHeaders[Headers.ContentType] =
|
|
this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson);
|
|
const res = yield this.post(requestUrl, data, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
putJson(requestUrl_1, obj_1) {
|
|
return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) {
|
|
const data = JSON.stringify(obj, null, 2);
|
|
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
|
additionalHeaders[Headers.ContentType] =
|
|
this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson);
|
|
const res = yield this.put(requestUrl, data, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
patchJson(requestUrl_1, obj_1) {
|
|
return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) {
|
|
const data = JSON.stringify(obj, null, 2);
|
|
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
|
additionalHeaders[Headers.ContentType] =
|
|
this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson);
|
|
const res = yield this.patch(requestUrl, data, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
/**
|
|
* Makes a raw http request.
|
|
* All other methods such as get, post, patch, and request ultimately call this.
|
|
* Prefer get, del, post and patch
|
|
*/
|
|
request(verb, requestUrl, data, headers) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (this._disposed) {
|
|
throw new Error('Client has already been disposed.');
|
|
}
|
|
const parsedUrl = new URL(requestUrl);
|
|
let info = this._prepareRequest(verb, parsedUrl, headers);
|
|
// Only perform retries on reads since writes may not be idempotent.
|
|
const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb)
|
|
? this._maxRetries + 1
|
|
: 1;
|
|
let numTries = 0;
|
|
let response;
|
|
do {
|
|
response = yield this.requestRaw(info, data);
|
|
// Check if it's an authentication challenge
|
|
if (response &&
|
|
response.message &&
|
|
response.message.statusCode === HttpCodes.Unauthorized) {
|
|
let authenticationHandler;
|
|
for (const handler of this.handlers) {
|
|
if (handler.canHandleAuthentication(response)) {
|
|
authenticationHandler = handler;
|
|
break;
|
|
}
|
|
}
|
|
if (authenticationHandler) {
|
|
return authenticationHandler.handleAuthentication(this, info, data);
|
|
}
|
|
else {
|
|
// We have received an unauthorized response but have no handlers to handle it.
|
|
// Let the response return to the caller.
|
|
return response;
|
|
}
|
|
}
|
|
let redirectsRemaining = this._maxRedirects;
|
|
while (response.message.statusCode &&
|
|
HttpRedirectCodes.includes(response.message.statusCode) &&
|
|
this._allowRedirects &&
|
|
redirectsRemaining > 0) {
|
|
const redirectUrl = response.message.headers['location'];
|
|
if (!redirectUrl) {
|
|
// if there's no location to redirect to, we won't
|
|
break;
|
|
}
|
|
const parsedRedirectUrl = new URL(redirectUrl);
|
|
if (parsedUrl.protocol === 'https:' &&
|
|
parsedUrl.protocol !== parsedRedirectUrl.protocol &&
|
|
!this._allowRedirectDowngrade) {
|
|
throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.');
|
|
}
|
|
// we need to finish reading the response before reassigning response
|
|
// which will leak the open socket.
|
|
yield response.readBody();
|
|
// strip authorization header if redirected to a different hostname
|
|
if (parsedRedirectUrl.hostname !== parsedUrl.hostname) {
|
|
for (const header in headers) {
|
|
// header names are case insensitive
|
|
if (header.toLowerCase() === 'authorization') {
|
|
delete headers[header];
|
|
}
|
|
}
|
|
}
|
|
// let's make the request with the new redirectUrl
|
|
info = this._prepareRequest(verb, parsedRedirectUrl, headers);
|
|
response = yield this.requestRaw(info, data);
|
|
redirectsRemaining--;
|
|
}
|
|
if (!response.message.statusCode ||
|
|
!HttpResponseRetryCodes.includes(response.message.statusCode)) {
|
|
// If not a retry code, return immediately instead of retrying
|
|
return response;
|
|
}
|
|
numTries += 1;
|
|
if (numTries < maxTries) {
|
|
yield response.readBody();
|
|
yield this._performExponentialBackoff(numTries);
|
|
}
|
|
} while (numTries < maxTries);
|
|
return response;
|
|
});
|
|
}
|
|
/**
|
|
* Needs to be called if keepAlive is set to true in request options.
|
|
*/
|
|
dispose() {
|
|
if (this._agent) {
|
|
this._agent.destroy();
|
|
}
|
|
this._disposed = true;
|
|
}
|
|
/**
|
|
* Raw request.
|
|
* @param info
|
|
* @param data
|
|
*/
|
|
requestRaw(info, data) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve, reject) => {
|
|
function callbackForResult(err, res) {
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
else if (!res) {
|
|
// If `err` is not passed, then `res` must be passed.
|
|
reject(new Error('Unknown error'));
|
|
}
|
|
else {
|
|
resolve(res);
|
|
}
|
|
}
|
|
this.requestRawWithCallback(info, data, callbackForResult);
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Raw request with callback.
|
|
* @param info
|
|
* @param data
|
|
* @param onResult
|
|
*/
|
|
requestRawWithCallback(info, data, onResult) {
|
|
if (typeof data === 'string') {
|
|
if (!info.options.headers) {
|
|
info.options.headers = {};
|
|
}
|
|
info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8');
|
|
}
|
|
let callbackCalled = false;
|
|
function handleResult(err, res) {
|
|
if (!callbackCalled) {
|
|
callbackCalled = true;
|
|
onResult(err, res);
|
|
}
|
|
}
|
|
const req = info.httpModule.request(info.options, (msg) => {
|
|
const res = new HttpClientResponse(msg);
|
|
handleResult(undefined, res);
|
|
});
|
|
let socket;
|
|
req.on('socket', sock => {
|
|
socket = sock;
|
|
});
|
|
// If we ever get disconnected, we want the socket to timeout eventually
|
|
req.setTimeout(this._socketTimeout || 3 * 60000, () => {
|
|
if (socket) {
|
|
socket.end();
|
|
}
|
|
handleResult(new Error(`Request timeout: ${info.options.path}`));
|
|
});
|
|
req.on('error', function (err) {
|
|
// err has statusCode property
|
|
// res should have headers
|
|
handleResult(err);
|
|
});
|
|
if (data && typeof data === 'string') {
|
|
req.write(data, 'utf8');
|
|
}
|
|
if (data && typeof data !== 'string') {
|
|
data.on('close', function () {
|
|
req.end();
|
|
});
|
|
data.pipe(req);
|
|
}
|
|
else {
|
|
req.end();
|
|
}
|
|
}
|
|
/**
|
|
* Gets an http agent. This function is useful when you need an http agent that handles
|
|
* routing through a proxy server - depending upon the url and proxy environment variables.
|
|
* @param serverUrl The server URL where the request will be sent. For example, https://api.github.com
|
|
*/
|
|
getAgent(serverUrl) {
|
|
const parsedUrl = new URL(serverUrl);
|
|
return this._getAgent(parsedUrl);
|
|
}
|
|
getAgentDispatcher(serverUrl) {
|
|
const parsedUrl = new URL(serverUrl);
|
|
const proxyUrl = pm.getProxyUrl(parsedUrl);
|
|
const useProxy = proxyUrl && proxyUrl.hostname;
|
|
if (!useProxy) {
|
|
return;
|
|
}
|
|
return this._getProxyAgentDispatcher(parsedUrl, proxyUrl);
|
|
}
|
|
_prepareRequest(method, requestUrl, headers) {
|
|
const info = {};
|
|
info.parsedUrl = requestUrl;
|
|
const usingSsl = info.parsedUrl.protocol === 'https:';
|
|
info.httpModule = usingSsl ? https : http;
|
|
const defaultPort = usingSsl ? 443 : 80;
|
|
info.options = {};
|
|
info.options.host = info.parsedUrl.hostname;
|
|
info.options.port = info.parsedUrl.port
|
|
? parseInt(info.parsedUrl.port)
|
|
: defaultPort;
|
|
info.options.path =
|
|
(info.parsedUrl.pathname || '') + (info.parsedUrl.search || '');
|
|
info.options.method = method;
|
|
info.options.headers = this._mergeHeaders(headers);
|
|
if (this.userAgent != null) {
|
|
info.options.headers['user-agent'] = this.userAgent;
|
|
}
|
|
info.options.agent = this._getAgent(info.parsedUrl);
|
|
// gives handlers an opportunity to participate
|
|
if (this.handlers) {
|
|
for (const handler of this.handlers) {
|
|
handler.prepareRequest(info.options);
|
|
}
|
|
}
|
|
return info;
|
|
}
|
|
_mergeHeaders(headers) {
|
|
if (this.requestOptions && this.requestOptions.headers) {
|
|
return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {}));
|
|
}
|
|
return lowercaseKeys(headers || {});
|
|
}
|
|
/**
|
|
* Gets an existing header value or returns a default.
|
|
* Handles converting number header values to strings since HTTP headers must be strings.
|
|
* Note: This returns string | string[] since some headers can have multiple values.
|
|
* For headers that must always be a single string (like Content-Type), use the
|
|
* specialized _getExistingOrDefaultContentTypeHeader method instead.
|
|
*/
|
|
_getExistingOrDefaultHeader(additionalHeaders, header, _default) {
|
|
let clientHeader;
|
|
if (this.requestOptions && this.requestOptions.headers) {
|
|
const headerValue = lowercaseKeys(this.requestOptions.headers)[header];
|
|
if (headerValue) {
|
|
clientHeader =
|
|
typeof headerValue === 'number' ? headerValue.toString() : headerValue;
|
|
}
|
|
}
|
|
const additionalValue = additionalHeaders[header];
|
|
if (additionalValue !== undefined) {
|
|
return typeof additionalValue === 'number'
|
|
? additionalValue.toString()
|
|
: additionalValue;
|
|
}
|
|
if (clientHeader !== undefined) {
|
|
return clientHeader;
|
|
}
|
|
return _default;
|
|
}
|
|
/**
|
|
* Specialized version of _getExistingOrDefaultHeader for Content-Type header.
|
|
* Always returns a single string (not an array) since Content-Type should be a single value.
|
|
* Converts arrays to comma-separated strings and numbers to strings to ensure type safety.
|
|
* This was split from _getExistingOrDefaultHeader to provide stricter typing for callers
|
|
* that assign the result to places expecting a string (e.g., additionalHeaders[Headers.ContentType]).
|
|
*/
|
|
_getExistingOrDefaultContentTypeHeader(additionalHeaders, _default) {
|
|
let clientHeader;
|
|
if (this.requestOptions && this.requestOptions.headers) {
|
|
const headerValue = lowercaseKeys(this.requestOptions.headers)[Headers.ContentType];
|
|
if (headerValue) {
|
|
if (typeof headerValue === 'number') {
|
|
clientHeader = String(headerValue);
|
|
}
|
|
else if (Array.isArray(headerValue)) {
|
|
clientHeader = headerValue.join(', ');
|
|
}
|
|
else {
|
|
clientHeader = headerValue;
|
|
}
|
|
}
|
|
}
|
|
const additionalValue = additionalHeaders[Headers.ContentType];
|
|
// Return the first non-undefined value, converting numbers or arrays to strings if necessary
|
|
if (additionalValue !== undefined) {
|
|
if (typeof additionalValue === 'number') {
|
|
return String(additionalValue);
|
|
}
|
|
else if (Array.isArray(additionalValue)) {
|
|
return additionalValue.join(', ');
|
|
}
|
|
else {
|
|
return additionalValue;
|
|
}
|
|
}
|
|
if (clientHeader !== undefined) {
|
|
return clientHeader;
|
|
}
|
|
return _default;
|
|
}
|
|
_getAgent(parsedUrl) {
|
|
let agent;
|
|
const proxyUrl = pm.getProxyUrl(parsedUrl);
|
|
const useProxy = proxyUrl && proxyUrl.hostname;
|
|
if (this._keepAlive && useProxy) {
|
|
agent = this._proxyAgent;
|
|
}
|
|
if (!useProxy) {
|
|
agent = this._agent;
|
|
}
|
|
// if agent is already assigned use that agent.
|
|
if (agent) {
|
|
return agent;
|
|
}
|
|
const usingSsl = parsedUrl.protocol === 'https:';
|
|
let maxSockets = 100;
|
|
if (this.requestOptions) {
|
|
maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets;
|
|
}
|
|
// This is `useProxy` again, but we need to check `proxyURl` directly for TypeScripts's flow analysis.
|
|
if (proxyUrl && proxyUrl.hostname) {
|
|
const agentOptions = {
|
|
maxSockets,
|
|
keepAlive: this._keepAlive,
|
|
proxy: Object.assign(Object.assign({}, ((proxyUrl.username || proxyUrl.password) && {
|
|
proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`
|
|
})), { host: proxyUrl.hostname, port: proxyUrl.port })
|
|
};
|
|
let tunnelAgent;
|
|
const overHttps = proxyUrl.protocol === 'https:';
|
|
if (usingSsl) {
|
|
tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp;
|
|
}
|
|
else {
|
|
tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp;
|
|
}
|
|
agent = tunnelAgent(agentOptions);
|
|
this._proxyAgent = agent;
|
|
}
|
|
// if tunneling agent isn't assigned create a new agent
|
|
if (!agent) {
|
|
const options = { keepAlive: this._keepAlive, maxSockets };
|
|
agent = usingSsl ? new https.Agent(options) : new http.Agent(options);
|
|
this._agent = agent;
|
|
}
|
|
if (usingSsl && this._ignoreSslError) {
|
|
// we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process
|
|
// http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options
|
|
// we have to cast it to any and change it directly
|
|
agent.options = Object.assign(agent.options || {}, {
|
|
rejectUnauthorized: false
|
|
});
|
|
}
|
|
return agent;
|
|
}
|
|
_getProxyAgentDispatcher(parsedUrl, proxyUrl) {
|
|
let proxyAgent;
|
|
if (this._keepAlive) {
|
|
proxyAgent = this._proxyAgentDispatcher;
|
|
}
|
|
// if agent is already assigned use that agent.
|
|
if (proxyAgent) {
|
|
return proxyAgent;
|
|
}
|
|
const usingSsl = parsedUrl.protocol === 'https:';
|
|
proxyAgent = new ProxyAgent(Object.assign({ uri: proxyUrl.href, pipelining: !this._keepAlive ? 0 : 1 }, ((proxyUrl.username || proxyUrl.password) && {
|
|
token: `Basic ${Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`).toString('base64')}`
|
|
})));
|
|
this._proxyAgentDispatcher = proxyAgent;
|
|
if (usingSsl && this._ignoreSslError) {
|
|
// we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process
|
|
// http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options
|
|
// we have to cast it to any and change it directly
|
|
proxyAgent.options = Object.assign(proxyAgent.options.requestTls || {}, {
|
|
rejectUnauthorized: false
|
|
});
|
|
}
|
|
return proxyAgent;
|
|
}
|
|
_getUserAgentWithOrchestrationId(userAgent) {
|
|
const baseUserAgent = userAgent || 'actions/http-client';
|
|
const orchId = process.env['ACTIONS_ORCHESTRATION_ID'];
|
|
if (orchId) {
|
|
// Sanitize the orchestration ID to ensure it contains only valid characters
|
|
// Valid characters: 0-9, a-z, _, -, .
|
|
const sanitizedId = orchId.replace(/[^a-z0-9_.-]/gi, '_');
|
|
return `${baseUserAgent} actions_orchestration_id/${sanitizedId}`;
|
|
}
|
|
return baseUserAgent;
|
|
}
|
|
_performExponentialBackoff(retryNumber) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
|
|
const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
|
|
return new Promise(resolve => setTimeout(() => resolve(), ms));
|
|
});
|
|
}
|
|
_processResponse(res, options) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
|
|
const statusCode = res.message.statusCode || 0;
|
|
const response = {
|
|
statusCode,
|
|
result: null,
|
|
headers: {}
|
|
};
|
|
// not found leads to null obj returned
|
|
if (statusCode === HttpCodes.NotFound) {
|
|
resolve(response);
|
|
}
|
|
// get the result from the body
|
|
function dateTimeDeserializer(key, value) {
|
|
if (typeof value === 'string') {
|
|
const a = new Date(value);
|
|
if (!isNaN(a.valueOf())) {
|
|
return a;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
let obj;
|
|
let contents;
|
|
try {
|
|
contents = yield res.readBody();
|
|
if (contents && contents.length > 0) {
|
|
if (options && options.deserializeDates) {
|
|
obj = JSON.parse(contents, dateTimeDeserializer);
|
|
}
|
|
else {
|
|
obj = JSON.parse(contents);
|
|
}
|
|
response.result = obj;
|
|
}
|
|
response.headers = res.message.headers;
|
|
}
|
|
catch (err) {
|
|
// Invalid resource (contents not json); leaving result obj null
|
|
}
|
|
// note that 3xx redirects are handled by the http layer.
|
|
if (statusCode > 299) {
|
|
let msg;
|
|
// if exception/error in body, attempt to get better error
|
|
if (obj && obj.message) {
|
|
msg = obj.message;
|
|
}
|
|
else if (contents && contents.length > 0) {
|
|
// it may be the case that the exception is in the body message as string
|
|
msg = contents;
|
|
}
|
|
else {
|
|
msg = `Failed request: (${statusCode})`;
|
|
}
|
|
const err = new HttpClientError(msg, statusCode);
|
|
err.result = response.result;
|
|
reject(err);
|
|
}
|
|
else {
|
|
resolve(response);
|
|
}
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
const lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {});
|
|
//# sourceMappingURL=index.js.map
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/http-client/lib/auth.js
|
|
var auth_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
class BasicCredentialHandler {
|
|
constructor(username, password) {
|
|
this.username = username;
|
|
this.password = password;
|
|
}
|
|
prepareRequest(options) {
|
|
if (!options.headers) {
|
|
throw Error('The request has no headers');
|
|
}
|
|
options.headers['Authorization'] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString('base64')}`;
|
|
}
|
|
// This handler cannot handle 401
|
|
canHandleAuthentication() {
|
|
return false;
|
|
}
|
|
handleAuthentication() {
|
|
return auth_awaiter(this, void 0, void 0, function* () {
|
|
throw new Error('not implemented');
|
|
});
|
|
}
|
|
}
|
|
class auth_BearerCredentialHandler {
|
|
constructor(token) {
|
|
this.token = token;
|
|
}
|
|
// currently implements pre-authorization
|
|
// TODO: support preAuth = false where it hooks on 401
|
|
prepareRequest(options) {
|
|
if (!options.headers) {
|
|
throw Error('The request has no headers');
|
|
}
|
|
options.headers['Authorization'] = `Bearer ${this.token}`;
|
|
}
|
|
// This handler cannot handle 401
|
|
canHandleAuthentication() {
|
|
return false;
|
|
}
|
|
handleAuthentication() {
|
|
return auth_awaiter(this, void 0, void 0, function* () {
|
|
throw new Error('not implemented');
|
|
});
|
|
}
|
|
}
|
|
class PersonalAccessTokenCredentialHandler {
|
|
constructor(token) {
|
|
this.token = token;
|
|
}
|
|
// currently implements pre-authorization
|
|
// TODO: support preAuth = false where it hooks on 401
|
|
prepareRequest(options) {
|
|
if (!options.headers) {
|
|
throw Error('The request has no headers');
|
|
}
|
|
options.headers['Authorization'] = `Basic ${Buffer.from(`PAT:${this.token}`).toString('base64')}`;
|
|
}
|
|
// This handler cannot handle 401
|
|
canHandleAuthentication() {
|
|
return false;
|
|
}
|
|
handleAuthentication() {
|
|
return auth_awaiter(this, void 0, void 0, function* () {
|
|
throw new Error('not implemented');
|
|
});
|
|
}
|
|
}
|
|
//# sourceMappingURL=auth.js.map
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/core/lib/oidc-utils.js
|
|
var oidc_utils_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
|
|
|
|
class oidc_utils_OidcClient {
|
|
static createHttpClient(allowRetry = true, maxRetry = 10) {
|
|
const requestOptions = {
|
|
allowRetries: allowRetry,
|
|
maxRetries: maxRetry
|
|
};
|
|
return new HttpClient('actions/oidc-client', [new BearerCredentialHandler(oidc_utils_OidcClient.getRequestToken())], requestOptions);
|
|
}
|
|
static getRequestToken() {
|
|
const token = process.env['ACTIONS_ID_TOKEN_REQUEST_TOKEN'];
|
|
if (!token) {
|
|
throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable');
|
|
}
|
|
return token;
|
|
}
|
|
static getIDTokenUrl() {
|
|
const runtimeUrl = process.env['ACTIONS_ID_TOKEN_REQUEST_URL'];
|
|
if (!runtimeUrl) {
|
|
throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable');
|
|
}
|
|
return runtimeUrl;
|
|
}
|
|
static getCall(id_token_url) {
|
|
return oidc_utils_awaiter(this, void 0, void 0, function* () {
|
|
var _a;
|
|
const httpclient = oidc_utils_OidcClient.createHttpClient();
|
|
const res = yield httpclient
|
|
.getJson(id_token_url)
|
|
.catch(error => {
|
|
throw new Error(`Failed to get ID Token. \n
|
|
Error Code : ${error.statusCode}\n
|
|
Error Message: ${error.message}`);
|
|
});
|
|
const id_token = (_a = res.result) === null || _a === void 0 ? void 0 : _a.value;
|
|
if (!id_token) {
|
|
throw new Error('Response json body do not have ID Token field');
|
|
}
|
|
return id_token;
|
|
});
|
|
}
|
|
static getIDToken(audience) {
|
|
return oidc_utils_awaiter(this, void 0, void 0, function* () {
|
|
try {
|
|
// New ID Token is requested from action service
|
|
let id_token_url = oidc_utils_OidcClient.getIDTokenUrl();
|
|
if (audience) {
|
|
const encodedAudience = encodeURIComponent(audience);
|
|
id_token_url = `${id_token_url}&audience=${encodedAudience}`;
|
|
}
|
|
debug(`ID token url is ${id_token_url}`);
|
|
const id_token = yield oidc_utils_OidcClient.getCall(id_token_url);
|
|
setSecret(id_token);
|
|
return id_token;
|
|
}
|
|
catch (error) {
|
|
throw new Error(`Error message: ${error.message}`);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
//# sourceMappingURL=oidc-utils.js.map
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/core/lib/summary.js
|
|
var summary_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
|
|
const { access, appendFile, writeFile } = external_fs_namespaceObject.promises;
|
|
const SUMMARY_ENV_VAR = 'GITHUB_STEP_SUMMARY';
|
|
const SUMMARY_DOCS_URL = 'https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary';
|
|
class Summary {
|
|
constructor() {
|
|
this._buffer = '';
|
|
}
|
|
/**
|
|
* Finds the summary file path from the environment, rejects if env var is not found or file does not exist
|
|
* Also checks r/w permissions.
|
|
*
|
|
* @returns step summary file path
|
|
*/
|
|
filePath() {
|
|
return summary_awaiter(this, void 0, void 0, function* () {
|
|
if (this._filePath) {
|
|
return this._filePath;
|
|
}
|
|
const pathFromEnv = process.env[SUMMARY_ENV_VAR];
|
|
if (!pathFromEnv) {
|
|
throw new Error(`Unable to find environment variable for $${SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`);
|
|
}
|
|
try {
|
|
yield access(pathFromEnv, external_fs_namespaceObject.constants.R_OK | external_fs_namespaceObject.constants.W_OK);
|
|
}
|
|
catch (_a) {
|
|
throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`);
|
|
}
|
|
this._filePath = pathFromEnv;
|
|
return this._filePath;
|
|
});
|
|
}
|
|
/**
|
|
* Wraps content in an HTML tag, adding any HTML attributes
|
|
*
|
|
* @param {string} tag HTML tag to wrap
|
|
* @param {string | null} content content within the tag
|
|
* @param {[attribute: string]: string} attrs key-value list of HTML attributes to add
|
|
*
|
|
* @returns {string} content wrapped in HTML element
|
|
*/
|
|
wrap(tag, content, attrs = {}) {
|
|
const htmlAttrs = Object.entries(attrs)
|
|
.map(([key, value]) => ` ${key}="${value}"`)
|
|
.join('');
|
|
if (!content) {
|
|
return `<${tag}${htmlAttrs}>`;
|
|
}
|
|
return `<${tag}${htmlAttrs}>${content}</${tag}>`;
|
|
}
|
|
/**
|
|
* Writes text in the buffer to the summary buffer file and empties buffer. Will append by default.
|
|
*
|
|
* @param {SummaryWriteOptions} [options] (optional) options for write operation
|
|
*
|
|
* @returns {Promise<Summary>} summary instance
|
|
*/
|
|
write(options) {
|
|
return summary_awaiter(this, void 0, void 0, function* () {
|
|
const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite);
|
|
const filePath = yield this.filePath();
|
|
const writeFunc = overwrite ? writeFile : appendFile;
|
|
yield writeFunc(filePath, this._buffer, { encoding: 'utf8' });
|
|
return this.emptyBuffer();
|
|
});
|
|
}
|
|
/**
|
|
* Clears the summary buffer and wipes the summary file
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
clear() {
|
|
return summary_awaiter(this, void 0, void 0, function* () {
|
|
return this.emptyBuffer().write({ overwrite: true });
|
|
});
|
|
}
|
|
/**
|
|
* Returns the current summary buffer as a string
|
|
*
|
|
* @returns {string} string of summary buffer
|
|
*/
|
|
stringify() {
|
|
return this._buffer;
|
|
}
|
|
/**
|
|
* If the summary buffer is empty
|
|
*
|
|
* @returns {boolen} true if the buffer is empty
|
|
*/
|
|
isEmptyBuffer() {
|
|
return this._buffer.length === 0;
|
|
}
|
|
/**
|
|
* Resets the summary buffer without writing to summary file
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
emptyBuffer() {
|
|
this._buffer = '';
|
|
return this;
|
|
}
|
|
/**
|
|
* Adds raw text to the summary buffer
|
|
*
|
|
* @param {string} text content to add
|
|
* @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false)
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addRaw(text, addEOL = false) {
|
|
this._buffer += text;
|
|
return addEOL ? this.addEOL() : this;
|
|
}
|
|
/**
|
|
* Adds the operating system-specific end-of-line marker to the buffer
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addEOL() {
|
|
return this.addRaw(external_os_namespaceObject.EOL);
|
|
}
|
|
/**
|
|
* Adds an HTML codeblock to the summary buffer
|
|
*
|
|
* @param {string} code content to render within fenced code block
|
|
* @param {string} lang (optional) language to syntax highlight code
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addCodeBlock(code, lang) {
|
|
const attrs = Object.assign({}, (lang && { lang }));
|
|
const element = this.wrap('pre', this.wrap('code', code), attrs);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML list to the summary buffer
|
|
*
|
|
* @param {string[]} items list of items to render
|
|
* @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false)
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addList(items, ordered = false) {
|
|
const tag = ordered ? 'ol' : 'ul';
|
|
const listItems = items.map(item => this.wrap('li', item)).join('');
|
|
const element = this.wrap(tag, listItems);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML table to the summary buffer
|
|
*
|
|
* @param {SummaryTableCell[]} rows table rows
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addTable(rows) {
|
|
const tableBody = rows
|
|
.map(row => {
|
|
const cells = row
|
|
.map(cell => {
|
|
if (typeof cell === 'string') {
|
|
return this.wrap('td', cell);
|
|
}
|
|
const { header, data, colspan, rowspan } = cell;
|
|
const tag = header ? 'th' : 'td';
|
|
const attrs = Object.assign(Object.assign({}, (colspan && { colspan })), (rowspan && { rowspan }));
|
|
return this.wrap(tag, data, attrs);
|
|
})
|
|
.join('');
|
|
return this.wrap('tr', cells);
|
|
})
|
|
.join('');
|
|
const element = this.wrap('table', tableBody);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds a collapsable HTML details element to the summary buffer
|
|
*
|
|
* @param {string} label text for the closed state
|
|
* @param {string} content collapsable content
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addDetails(label, content) {
|
|
const element = this.wrap('details', this.wrap('summary', label) + content);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML image tag to the summary buffer
|
|
*
|
|
* @param {string} src path to the image you to embed
|
|
* @param {string} alt text description of the image
|
|
* @param {SummaryImageOptions} options (optional) addition image attributes
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addImage(src, alt, options) {
|
|
const { width, height } = options || {};
|
|
const attrs = Object.assign(Object.assign({}, (width && { width })), (height && { height }));
|
|
const element = this.wrap('img', null, Object.assign({ src, alt }, attrs));
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML section heading element
|
|
*
|
|
* @param {string} text heading text
|
|
* @param {number | string} [level=1] (optional) the heading level, default: 1
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addHeading(text, level) {
|
|
const tag = `h${level}`;
|
|
const allowedTag = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(tag)
|
|
? tag
|
|
: 'h1';
|
|
const element = this.wrap(allowedTag, text);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML thematic break (<hr>) to the summary buffer
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addSeparator() {
|
|
const element = this.wrap('hr', null);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML line break (<br>) to the summary buffer
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addBreak() {
|
|
const element = this.wrap('br', null);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML blockquote to the summary buffer
|
|
*
|
|
* @param {string} text quote text
|
|
* @param {string} cite (optional) citation url
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addQuote(text, cite) {
|
|
const attrs = Object.assign({}, (cite && { cite }));
|
|
const element = this.wrap('blockquote', text, attrs);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
/**
|
|
* Adds an HTML anchor tag to the summary buffer
|
|
*
|
|
* @param {string} text link text/content
|
|
* @param {string} href hyperlink
|
|
*
|
|
* @returns {Summary} summary instance
|
|
*/
|
|
addLink(text, href) {
|
|
const element = this.wrap('a', text, { href });
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
}
|
|
const _summary = new Summary();
|
|
/**
|
|
* @deprecated use `core.summary`
|
|
*/
|
|
const markdownSummary = (/* unused pure expression or super */ null && (_summary));
|
|
const summary = (/* unused pure expression or super */ null && (_summary));
|
|
//# sourceMappingURL=summary.js.map
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/core/lib/path-utils.js
|
|
|
|
/**
|
|
* toPosixPath converts the given path to the posix form. On Windows, \\ will be
|
|
* replaced with /.
|
|
*
|
|
* @param pth. Path to transform.
|
|
* @return string Posix path.
|
|
*/
|
|
function toPosixPath(pth) {
|
|
return pth.replace(/[\\]/g, '/');
|
|
}
|
|
/**
|
|
* toWin32Path converts the given path to the win32 form. On Linux, / will be
|
|
* replaced with \\.
|
|
*
|
|
* @param pth. Path to transform.
|
|
* @return string Win32 path.
|
|
*/
|
|
function toWin32Path(pth) {
|
|
return pth.replace(/[/]/g, '\\');
|
|
}
|
|
/**
|
|
* toPlatformPath converts the given path to a platform-specific path. It does
|
|
* this by replacing instances of / and \ with the platform-specific path
|
|
* separator.
|
|
*
|
|
* @param pth The path to platformize.
|
|
* @return string The platform-specific path.
|
|
*/
|
|
function toPlatformPath(pth) {
|
|
return pth.replace(/[/\\]/g, path.sep);
|
|
}
|
|
//# sourceMappingURL=path-utils.js.map
|
|
// EXTERNAL MODULE: external "string_decoder"
|
|
var external_string_decoder_ = __nccwpck_require__(3193);
|
|
// EXTERNAL MODULE: external "events"
|
|
var external_events_ = __nccwpck_require__(4434);
|
|
;// CONCATENATED MODULE: external "child_process"
|
|
const external_child_process_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("child_process");
|
|
// EXTERNAL MODULE: external "assert"
|
|
var external_assert_ = __nccwpck_require__(2613);
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/io/lib/io-util.js
|
|
var io_util_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
|
|
const { chmod, copyFile, lstat, mkdir, open: io_util_open, readdir, rename, rm, rmdir, stat, symlink, unlink } = external_fs_namespaceObject.promises;
|
|
// export const {open} = 'fs'
|
|
const IS_WINDOWS = process.platform === 'win32';
|
|
/**
|
|
* Custom implementation of readlink to ensure Windows junctions
|
|
* maintain trailing backslash for backward compatibility with Node.js < 24
|
|
*
|
|
* In Node.js 20, Windows junctions (directory symlinks) always returned paths
|
|
* with trailing backslashes. Node.js 24 removed this behavior, which breaks
|
|
* code that relied on this format for path operations.
|
|
*
|
|
* This implementation restores the Node 20 behavior by adding a trailing
|
|
* backslash to all junction results on Windows.
|
|
*/
|
|
function readlink(fsPath) {
|
|
return io_util_awaiter(this, void 0, void 0, function* () {
|
|
const result = yield external_fs_namespaceObject.promises.readlink(fsPath);
|
|
// On Windows, restore Node 20 behavior: add trailing backslash to all results
|
|
// since junctions on Windows are always directory links
|
|
if (IS_WINDOWS && !result.endsWith('\\')) {
|
|
return `${result}\\`;
|
|
}
|
|
return result;
|
|
});
|
|
}
|
|
// See https://github.com/nodejs/node/blob/d0153aee367422d0858105abec186da4dff0a0c5/deps/uv/include/uv/win.h#L691
|
|
const UV_FS_O_EXLOCK = 0x10000000;
|
|
const READONLY = external_fs_namespaceObject.constants.O_RDONLY;
|
|
function exists(fsPath) {
|
|
return io_util_awaiter(this, void 0, void 0, function* () {
|
|
try {
|
|
yield stat(fsPath);
|
|
}
|
|
catch (err) {
|
|
if (err.code === 'ENOENT') {
|
|
return false;
|
|
}
|
|
throw err;
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
function isDirectory(fsPath_1) {
|
|
return io_util_awaiter(this, arguments, void 0, function* (fsPath, useStat = false) {
|
|
const stats = useStat ? yield stat(fsPath) : yield lstat(fsPath);
|
|
return stats.isDirectory();
|
|
});
|
|
}
|
|
/**
|
|
* On OSX/Linux, true if path starts with '/'. On Windows, true for paths like:
|
|
* \, \hello, \\hello\share, C:, and C:\hello (and corresponding alternate separator cases).
|
|
*/
|
|
function isRooted(p) {
|
|
p = normalizeSeparators(p);
|
|
if (!p) {
|
|
throw new Error('isRooted() parameter "p" cannot be empty');
|
|
}
|
|
if (IS_WINDOWS) {
|
|
return (p.startsWith('\\') || /^[A-Z]:/i.test(p) // e.g. \ or \hello or \\hello
|
|
); // e.g. C: or C:\hello
|
|
}
|
|
return p.startsWith('/');
|
|
}
|
|
/**
|
|
* Best effort attempt to determine whether a file exists and is executable.
|
|
* @param filePath file path to check
|
|
* @param extensions additional file extensions to try
|
|
* @return if file exists and is executable, returns the file path. otherwise empty string.
|
|
*/
|
|
function tryGetExecutablePath(filePath, extensions) {
|
|
return io_util_awaiter(this, void 0, void 0, function* () {
|
|
let stats = undefined;
|
|
try {
|
|
// test file exists
|
|
stats = yield stat(filePath);
|
|
}
|
|
catch (err) {
|
|
if (err.code !== 'ENOENT') {
|
|
// eslint-disable-next-line no-console
|
|
console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
|
|
}
|
|
}
|
|
if (stats && stats.isFile()) {
|
|
if (IS_WINDOWS) {
|
|
// on Windows, test for valid extension
|
|
const upperExt = external_path_namespaceObject.extname(filePath).toUpperCase();
|
|
if (extensions.some(validExt => validExt.toUpperCase() === upperExt)) {
|
|
return filePath;
|
|
}
|
|
}
|
|
else {
|
|
if (isUnixExecutable(stats)) {
|
|
return filePath;
|
|
}
|
|
}
|
|
}
|
|
// try each extension
|
|
const originalFilePath = filePath;
|
|
for (const extension of extensions) {
|
|
filePath = originalFilePath + extension;
|
|
stats = undefined;
|
|
try {
|
|
stats = yield stat(filePath);
|
|
}
|
|
catch (err) {
|
|
if (err.code !== 'ENOENT') {
|
|
// eslint-disable-next-line no-console
|
|
console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
|
|
}
|
|
}
|
|
if (stats && stats.isFile()) {
|
|
if (IS_WINDOWS) {
|
|
// preserve the case of the actual file (since an extension was appended)
|
|
try {
|
|
const directory = external_path_namespaceObject.dirname(filePath);
|
|
const upperName = external_path_namespaceObject.basename(filePath).toUpperCase();
|
|
for (const actualName of yield readdir(directory)) {
|
|
if (upperName === actualName.toUpperCase()) {
|
|
filePath = external_path_namespaceObject.join(directory, actualName);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (err) {
|
|
// eslint-disable-next-line no-console
|
|
console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`);
|
|
}
|
|
return filePath;
|
|
}
|
|
else {
|
|
if (isUnixExecutable(stats)) {
|
|
return filePath;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return '';
|
|
});
|
|
}
|
|
function normalizeSeparators(p) {
|
|
p = p || '';
|
|
if (IS_WINDOWS) {
|
|
// convert slashes on Windows
|
|
p = p.replace(/\//g, '\\');
|
|
// remove redundant slashes
|
|
return p.replace(/\\\\+/g, '\\');
|
|
}
|
|
// remove redundant slashes
|
|
return p.replace(/\/\/+/g, '/');
|
|
}
|
|
// on Mac/Linux, test the execute bit
|
|
// R W X R W X R W X
|
|
// 256 128 64 32 16 8 4 2 1
|
|
function isUnixExecutable(stats) {
|
|
return ((stats.mode & 1) > 0 ||
|
|
((stats.mode & 8) > 0 &&
|
|
process.getgid !== undefined &&
|
|
stats.gid === process.getgid()) ||
|
|
((stats.mode & 64) > 0 &&
|
|
process.getuid !== undefined &&
|
|
stats.uid === process.getuid()));
|
|
}
|
|
// Get the path of cmd.exe in windows
|
|
function getCmdPath() {
|
|
var _a;
|
|
return (_a = process.env['COMSPEC']) !== null && _a !== void 0 ? _a : `cmd.exe`;
|
|
}
|
|
//# sourceMappingURL=io-util.js.map
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/io/lib/io.js
|
|
var io_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* Copies a file or folder.
|
|
* Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js
|
|
*
|
|
* @param source source path
|
|
* @param dest destination path
|
|
* @param options optional. See CopyOptions.
|
|
*/
|
|
function io_cp(source_1, dest_1) {
|
|
return io_awaiter(this, arguments, void 0, function* (source, dest, options = {}) {
|
|
const { force, recursive, copySourceDirectory } = readCopyOptions(options);
|
|
const destStat = (yield exists(dest)) ? yield stat(dest) : null;
|
|
// Dest is an existing file, but not forcing
|
|
if (destStat && destStat.isFile() && !force) {
|
|
return;
|
|
}
|
|
// If dest is an existing directory, should copy inside.
|
|
const newDest = destStat && destStat.isDirectory() && copySourceDirectory
|
|
? external_path_namespaceObject.join(dest, external_path_namespaceObject.basename(source))
|
|
: dest;
|
|
if (!(yield exists(source))) {
|
|
throw new Error(`no such file or directory: ${source}`);
|
|
}
|
|
const sourceStat = yield stat(source);
|
|
if (sourceStat.isDirectory()) {
|
|
if (!recursive) {
|
|
throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`);
|
|
}
|
|
else {
|
|
yield cpDirRecursive(source, newDest, 0, force);
|
|
}
|
|
}
|
|
else {
|
|
if (external_path_namespaceObject.relative(source, newDest) === '') {
|
|
// a file cannot be copied to itself
|
|
throw new Error(`'${newDest}' and '${source}' are the same file`);
|
|
}
|
|
yield io_copyFile(source, newDest, force);
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Moves a path.
|
|
*
|
|
* @param source source path
|
|
* @param dest destination path
|
|
* @param options optional. See MoveOptions.
|
|
*/
|
|
function mv(source_1, dest_1) {
|
|
return io_awaiter(this, arguments, void 0, function* (source, dest, options = {}) {
|
|
if (yield exists(dest)) {
|
|
let destExists = true;
|
|
if (yield isDirectory(dest)) {
|
|
// If dest is directory copy src into dest
|
|
dest = external_path_namespaceObject.join(dest, external_path_namespaceObject.basename(source));
|
|
destExists = yield exists(dest);
|
|
}
|
|
if (destExists) {
|
|
if (options.force == null || options.force) {
|
|
yield rmRF(dest);
|
|
}
|
|
else {
|
|
throw new Error('Destination already exists');
|
|
}
|
|
}
|
|
}
|
|
yield mkdirP(external_path_namespaceObject.dirname(dest));
|
|
yield rename(source, dest);
|
|
});
|
|
}
|
|
/**
|
|
* Remove a path recursively with force
|
|
*
|
|
* @param inputPath path to remove
|
|
*/
|
|
function rmRF(inputPath) {
|
|
return io_awaiter(this, void 0, void 0, function* () {
|
|
if (IS_WINDOWS) {
|
|
// Check for invalid characters
|
|
// https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file
|
|
if (/[*"<>|]/.test(inputPath)) {
|
|
throw new Error('File path must not contain `*`, `"`, `<`, `>` or `|` on Windows');
|
|
}
|
|
}
|
|
try {
|
|
// note if path does not exist, error is silent
|
|
yield rm(inputPath, {
|
|
force: true,
|
|
maxRetries: 3,
|
|
recursive: true,
|
|
retryDelay: 300
|
|
});
|
|
}
|
|
catch (err) {
|
|
throw new Error(`File was unable to be removed ${err}`);
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Make a directory. Creates the full path with folders in between
|
|
* Will throw if it fails
|
|
*
|
|
* @param fsPath path to create
|
|
* @returns Promise<void>
|
|
*/
|
|
function mkdirP(fsPath) {
|
|
return io_awaiter(this, void 0, void 0, function* () {
|
|
(0,external_assert_.ok)(fsPath, 'a path argument must be provided');
|
|
yield mkdir(fsPath, { recursive: true });
|
|
});
|
|
}
|
|
/**
|
|
* Returns path of a tool had the tool actually been invoked. Resolves via paths.
|
|
* If you check and the tool does not exist, it will throw.
|
|
*
|
|
* @param tool name of the tool
|
|
* @param check whether to check if tool exists
|
|
* @returns Promise<string> path to tool
|
|
*/
|
|
function which(tool, check) {
|
|
return io_awaiter(this, void 0, void 0, function* () {
|
|
if (!tool) {
|
|
throw new Error("parameter 'tool' is required");
|
|
}
|
|
// recursive when check=true
|
|
if (check) {
|
|
const result = yield which(tool, false);
|
|
if (!result) {
|
|
if (IS_WINDOWS) {
|
|
throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`);
|
|
}
|
|
else {
|
|
throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
const matches = yield findInPath(tool);
|
|
if (matches && matches.length > 0) {
|
|
return matches[0];
|
|
}
|
|
return '';
|
|
});
|
|
}
|
|
/**
|
|
* Returns a list of all occurrences of the given tool on the system path.
|
|
*
|
|
* @returns Promise<string[]> the paths of the tool
|
|
*/
|
|
function findInPath(tool) {
|
|
return io_awaiter(this, void 0, void 0, function* () {
|
|
if (!tool) {
|
|
throw new Error("parameter 'tool' is required");
|
|
}
|
|
// build the list of extensions to try
|
|
const extensions = [];
|
|
if (IS_WINDOWS && process.env['PATHEXT']) {
|
|
for (const extension of process.env['PATHEXT'].split(external_path_namespaceObject.delimiter)) {
|
|
if (extension) {
|
|
extensions.push(extension);
|
|
}
|
|
}
|
|
}
|
|
// if it's rooted, return it if exists. otherwise return empty.
|
|
if (isRooted(tool)) {
|
|
const filePath = yield tryGetExecutablePath(tool, extensions);
|
|
if (filePath) {
|
|
return [filePath];
|
|
}
|
|
return [];
|
|
}
|
|
// if any path separators, return empty
|
|
if (tool.includes(external_path_namespaceObject.sep)) {
|
|
return [];
|
|
}
|
|
// build the list of directories
|
|
//
|
|
// Note, technically "where" checks the current directory on Windows. From a toolkit perspective,
|
|
// it feels like we should not do this. Checking the current directory seems like more of a use
|
|
// case of a shell, and the which() function exposed by the toolkit should strive for consistency
|
|
// across platforms.
|
|
const directories = [];
|
|
if (process.env.PATH) {
|
|
for (const p of process.env.PATH.split(external_path_namespaceObject.delimiter)) {
|
|
if (p) {
|
|
directories.push(p);
|
|
}
|
|
}
|
|
}
|
|
// find all matches
|
|
const matches = [];
|
|
for (const directory of directories) {
|
|
const filePath = yield tryGetExecutablePath(external_path_namespaceObject.join(directory, tool), extensions);
|
|
if (filePath) {
|
|
matches.push(filePath);
|
|
}
|
|
}
|
|
return matches;
|
|
});
|
|
}
|
|
function readCopyOptions(options) {
|
|
const force = options.force == null ? true : options.force;
|
|
const recursive = Boolean(options.recursive);
|
|
const copySourceDirectory = options.copySourceDirectory == null
|
|
? true
|
|
: Boolean(options.copySourceDirectory);
|
|
return { force, recursive, copySourceDirectory };
|
|
}
|
|
function cpDirRecursive(sourceDir, destDir, currentDepth, force) {
|
|
return io_awaiter(this, void 0, void 0, function* () {
|
|
// Ensure there is not a run away recursive copy
|
|
if (currentDepth >= 255)
|
|
return;
|
|
currentDepth++;
|
|
yield mkdirP(destDir);
|
|
const files = yield readdir(sourceDir);
|
|
for (const fileName of files) {
|
|
const srcFile = `${sourceDir}/${fileName}`;
|
|
const destFile = `${destDir}/${fileName}`;
|
|
const srcFileStat = yield lstat(srcFile);
|
|
if (srcFileStat.isDirectory()) {
|
|
// Recurse
|
|
yield cpDirRecursive(srcFile, destFile, currentDepth, force);
|
|
}
|
|
else {
|
|
yield io_copyFile(srcFile, destFile, force);
|
|
}
|
|
}
|
|
// Change the mode for the newly created directory
|
|
yield chmod(destDir, (yield stat(sourceDir)).mode);
|
|
});
|
|
}
|
|
// Buffered file copy
|
|
function io_copyFile(srcFile, destFile, force) {
|
|
return io_awaiter(this, void 0, void 0, function* () {
|
|
if ((yield lstat(srcFile)).isSymbolicLink()) {
|
|
// unlink/re-link it
|
|
try {
|
|
yield lstat(destFile);
|
|
yield unlink(destFile);
|
|
}
|
|
catch (e) {
|
|
// Try to override file permission
|
|
if (e.code === 'EPERM') {
|
|
yield chmod(destFile, '0666');
|
|
yield unlink(destFile);
|
|
}
|
|
// other errors = it doesn't exist, no work to do
|
|
}
|
|
// Copy over symlink
|
|
const symlinkFull = yield readlink(srcFile);
|
|
yield symlink(symlinkFull, destFile, IS_WINDOWS ? 'junction' : null);
|
|
}
|
|
else if (!(yield exists(destFile)) || force) {
|
|
yield copyFile(srcFile, destFile);
|
|
}
|
|
});
|
|
}
|
|
//# sourceMappingURL=io.js.map
|
|
;// CONCATENATED MODULE: external "timers"
|
|
const external_timers_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("timers");
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/exec/lib/toolrunner.js
|
|
var toolrunner_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* eslint-disable @typescript-eslint/unbound-method */
|
|
const toolrunner_IS_WINDOWS = process.platform === 'win32';
|
|
/*
|
|
* Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way.
|
|
*/
|
|
class ToolRunner extends external_events_.EventEmitter {
|
|
constructor(toolPath, args, options) {
|
|
super();
|
|
if (!toolPath) {
|
|
throw new Error("Parameter 'toolPath' cannot be null or empty.");
|
|
}
|
|
this.toolPath = toolPath;
|
|
this.args = args || [];
|
|
this.options = options || {};
|
|
}
|
|
_debug(message) {
|
|
if (this.options.listeners && this.options.listeners.debug) {
|
|
this.options.listeners.debug(message);
|
|
}
|
|
}
|
|
_getCommandString(options, noPrefix) {
|
|
const toolPath = this._getSpawnFileName();
|
|
const args = this._getSpawnArgs(options);
|
|
let cmd = noPrefix ? '' : '[command]'; // omit prefix when piped to a second tool
|
|
if (toolrunner_IS_WINDOWS) {
|
|
// Windows + cmd file
|
|
if (this._isCmdFile()) {
|
|
cmd += toolPath;
|
|
for (const a of args) {
|
|
cmd += ` ${a}`;
|
|
}
|
|
}
|
|
// Windows + verbatim
|
|
else if (options.windowsVerbatimArguments) {
|
|
cmd += `"${toolPath}"`;
|
|
for (const a of args) {
|
|
cmd += ` ${a}`;
|
|
}
|
|
}
|
|
// Windows (regular)
|
|
else {
|
|
cmd += this._windowsQuoteCmdArg(toolPath);
|
|
for (const a of args) {
|
|
cmd += ` ${this._windowsQuoteCmdArg(a)}`;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// OSX/Linux - this can likely be improved with some form of quoting.
|
|
// creating processes on Unix is fundamentally different than Windows.
|
|
// on Unix, execvp() takes an arg array.
|
|
cmd += toolPath;
|
|
for (const a of args) {
|
|
cmd += ` ${a}`;
|
|
}
|
|
}
|
|
return cmd;
|
|
}
|
|
_processLineBuffer(data, strBuffer, onLine) {
|
|
try {
|
|
let s = strBuffer + data.toString();
|
|
let n = s.indexOf(external_os_namespaceObject.EOL);
|
|
while (n > -1) {
|
|
const line = s.substring(0, n);
|
|
onLine(line);
|
|
// the rest of the string ...
|
|
s = s.substring(n + external_os_namespaceObject.EOL.length);
|
|
n = s.indexOf(external_os_namespaceObject.EOL);
|
|
}
|
|
return s;
|
|
}
|
|
catch (err) {
|
|
// streaming lines to console is best effort. Don't fail a build.
|
|
this._debug(`error processing line. Failed with error ${err}`);
|
|
return '';
|
|
}
|
|
}
|
|
_getSpawnFileName() {
|
|
if (toolrunner_IS_WINDOWS) {
|
|
if (this._isCmdFile()) {
|
|
return process.env['COMSPEC'] || 'cmd.exe';
|
|
}
|
|
}
|
|
return this.toolPath;
|
|
}
|
|
_getSpawnArgs(options) {
|
|
if (toolrunner_IS_WINDOWS) {
|
|
if (this._isCmdFile()) {
|
|
let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`;
|
|
for (const a of this.args) {
|
|
argline += ' ';
|
|
argline += options.windowsVerbatimArguments
|
|
? a
|
|
: this._windowsQuoteCmdArg(a);
|
|
}
|
|
argline += '"';
|
|
return [argline];
|
|
}
|
|
}
|
|
return this.args;
|
|
}
|
|
_endsWith(str, end) {
|
|
return str.endsWith(end);
|
|
}
|
|
_isCmdFile() {
|
|
const upperToolPath = this.toolPath.toUpperCase();
|
|
return (this._endsWith(upperToolPath, '.CMD') ||
|
|
this._endsWith(upperToolPath, '.BAT'));
|
|
}
|
|
_windowsQuoteCmdArg(arg) {
|
|
// for .exe, apply the normal quoting rules that libuv applies
|
|
if (!this._isCmdFile()) {
|
|
return this._uvQuoteCmdArg(arg);
|
|
}
|
|
// otherwise apply quoting rules specific to the cmd.exe command line parser.
|
|
// the libuv rules are generic and are not designed specifically for cmd.exe
|
|
// command line parser.
|
|
//
|
|
// for a detailed description of the cmd.exe command line parser, refer to
|
|
// http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912
|
|
// need quotes for empty arg
|
|
if (!arg) {
|
|
return '""';
|
|
}
|
|
// determine whether the arg needs to be quoted
|
|
const cmdSpecialChars = [
|
|
' ',
|
|
'\t',
|
|
'&',
|
|
'(',
|
|
')',
|
|
'[',
|
|
']',
|
|
'{',
|
|
'}',
|
|
'^',
|
|
'=',
|
|
';',
|
|
'!',
|
|
"'",
|
|
'+',
|
|
',',
|
|
'`',
|
|
'~',
|
|
'|',
|
|
'<',
|
|
'>',
|
|
'"'
|
|
];
|
|
let needsQuotes = false;
|
|
for (const char of arg) {
|
|
if (cmdSpecialChars.some(x => x === char)) {
|
|
needsQuotes = true;
|
|
break;
|
|
}
|
|
}
|
|
// short-circuit if quotes not needed
|
|
if (!needsQuotes) {
|
|
return arg;
|
|
}
|
|
// the following quoting rules are very similar to the rules that by libuv applies.
|
|
//
|
|
// 1) wrap the string in quotes
|
|
//
|
|
// 2) double-up quotes - i.e. " => ""
|
|
//
|
|
// this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately
|
|
// doesn't work well with a cmd.exe command line.
|
|
//
|
|
// note, replacing " with "" also works well if the arg is passed to a downstream .NET console app.
|
|
// for example, the command line:
|
|
// foo.exe "myarg:""my val"""
|
|
// is parsed by a .NET console app into an arg array:
|
|
// [ "myarg:\"my val\"" ]
|
|
// which is the same end result when applying libuv quoting rules. although the actual
|
|
// command line from libuv quoting rules would look like:
|
|
// foo.exe "myarg:\"my val\""
|
|
//
|
|
// 3) double-up slashes that precede a quote,
|
|
// e.g. hello \world => "hello \world"
|
|
// hello\"world => "hello\\""world"
|
|
// hello\\"world => "hello\\\\""world"
|
|
// hello world\ => "hello world\\"
|
|
//
|
|
// technically this is not required for a cmd.exe command line, or the batch argument parser.
|
|
// the reasons for including this as a .cmd quoting rule are:
|
|
//
|
|
// a) this is optimized for the scenario where the argument is passed from the .cmd file to an
|
|
// external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule.
|
|
//
|
|
// b) it's what we've been doing previously (by deferring to node default behavior) and we
|
|
// haven't heard any complaints about that aspect.
|
|
//
|
|
// note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be
|
|
// escaped when used on the command line directly - even though within a .cmd file % can be escaped
|
|
// by using %%.
|
|
//
|
|
// the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts
|
|
// the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing.
|
|
//
|
|
// one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would
|
|
// often work, since it is unlikely that var^ would exist, and the ^ character is removed when the
|
|
// variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args
|
|
// to an external program.
|
|
//
|
|
// an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file.
|
|
// % can be escaped within a .cmd file.
|
|
let reverse = '"';
|
|
let quoteHit = true;
|
|
for (let i = arg.length; i > 0; i--) {
|
|
// walk the string in reverse
|
|
reverse += arg[i - 1];
|
|
if (quoteHit && arg[i - 1] === '\\') {
|
|
reverse += '\\'; // double the slash
|
|
}
|
|
else if (arg[i - 1] === '"') {
|
|
quoteHit = true;
|
|
reverse += '"'; // double the quote
|
|
}
|
|
else {
|
|
quoteHit = false;
|
|
}
|
|
}
|
|
reverse += '"';
|
|
return reverse.split('').reverse().join('');
|
|
}
|
|
_uvQuoteCmdArg(arg) {
|
|
// Tool runner wraps child_process.spawn() and needs to apply the same quoting as
|
|
// Node in certain cases where the undocumented spawn option windowsVerbatimArguments
|
|
// is used.
|
|
//
|
|
// Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV,
|
|
// see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details),
|
|
// pasting copyright notice from Node within this function:
|
|
//
|
|
// Copyright Joyent, Inc. and other Node contributors. All rights reserved.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
if (!arg) {
|
|
// Need double quotation for empty argument
|
|
return '""';
|
|
}
|
|
if (!arg.includes(' ') && !arg.includes('\t') && !arg.includes('"')) {
|
|
// No quotation needed
|
|
return arg;
|
|
}
|
|
if (!arg.includes('"') && !arg.includes('\\')) {
|
|
// No embedded double quotes or backslashes, so I can just wrap
|
|
// quote marks around the whole thing.
|
|
return `"${arg}"`;
|
|
}
|
|
// Expected input/output:
|
|
// input : hello"world
|
|
// output: "hello\"world"
|
|
// input : hello""world
|
|
// output: "hello\"\"world"
|
|
// input : hello\world
|
|
// output: hello\world
|
|
// input : hello\\world
|
|
// output: hello\\world
|
|
// input : hello\"world
|
|
// output: "hello\\\"world"
|
|
// input : hello\\"world
|
|
// output: "hello\\\\\"world"
|
|
// input : hello world\
|
|
// output: "hello world\\" - note the comment in libuv actually reads "hello world\"
|
|
// but it appears the comment is wrong, it should be "hello world\\"
|
|
let reverse = '"';
|
|
let quoteHit = true;
|
|
for (let i = arg.length; i > 0; i--) {
|
|
// walk the string in reverse
|
|
reverse += arg[i - 1];
|
|
if (quoteHit && arg[i - 1] === '\\') {
|
|
reverse += '\\';
|
|
}
|
|
else if (arg[i - 1] === '"') {
|
|
quoteHit = true;
|
|
reverse += '\\';
|
|
}
|
|
else {
|
|
quoteHit = false;
|
|
}
|
|
}
|
|
reverse += '"';
|
|
return reverse.split('').reverse().join('');
|
|
}
|
|
_cloneExecOptions(options) {
|
|
options = options || {};
|
|
const result = {
|
|
cwd: options.cwd || process.cwd(),
|
|
env: options.env || process.env,
|
|
silent: options.silent || false,
|
|
windowsVerbatimArguments: options.windowsVerbatimArguments || false,
|
|
failOnStdErr: options.failOnStdErr || false,
|
|
ignoreReturnCode: options.ignoreReturnCode || false,
|
|
delay: options.delay || 10000
|
|
};
|
|
result.outStream = options.outStream || process.stdout;
|
|
result.errStream = options.errStream || process.stderr;
|
|
return result;
|
|
}
|
|
_getSpawnOptions(options, toolPath) {
|
|
options = options || {};
|
|
const result = {};
|
|
result.cwd = options.cwd;
|
|
result.env = options.env;
|
|
result['windowsVerbatimArguments'] =
|
|
options.windowsVerbatimArguments || this._isCmdFile();
|
|
if (options.windowsVerbatimArguments) {
|
|
result.argv0 = `"${toolPath}"`;
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Exec a tool.
|
|
* Output will be streamed to the live console.
|
|
* Returns promise with return code
|
|
*
|
|
* @param tool path to tool to exec
|
|
* @param options optional exec options. See ExecOptions
|
|
* @returns number
|
|
*/
|
|
exec() {
|
|
return toolrunner_awaiter(this, void 0, void 0, function* () {
|
|
// root the tool path if it is unrooted and contains relative pathing
|
|
if (!isRooted(this.toolPath) &&
|
|
(this.toolPath.includes('/') ||
|
|
(toolrunner_IS_WINDOWS && this.toolPath.includes('\\')))) {
|
|
// prefer options.cwd if it is specified, however options.cwd may also need to be rooted
|
|
this.toolPath = external_path_namespaceObject.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
|
|
}
|
|
// if the tool is only a file name, then resolve it from the PATH
|
|
// otherwise verify it exists (add extension on Windows if necessary)
|
|
this.toolPath = yield which(this.toolPath, true);
|
|
return new Promise((resolve, reject) => toolrunner_awaiter(this, void 0, void 0, function* () {
|
|
this._debug(`exec tool: ${this.toolPath}`);
|
|
this._debug('arguments:');
|
|
for (const arg of this.args) {
|
|
this._debug(` ${arg}`);
|
|
}
|
|
const optionsNonNull = this._cloneExecOptions(this.options);
|
|
if (!optionsNonNull.silent && optionsNonNull.outStream) {
|
|
optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + external_os_namespaceObject.EOL);
|
|
}
|
|
const state = new ExecState(optionsNonNull, this.toolPath);
|
|
state.on('debug', (message) => {
|
|
this._debug(message);
|
|
});
|
|
if (this.options.cwd && !(yield exists(this.options.cwd))) {
|
|
return reject(new Error(`The cwd: ${this.options.cwd} does not exist!`));
|
|
}
|
|
const fileName = this._getSpawnFileName();
|
|
const cp = external_child_process_namespaceObject.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName));
|
|
let stdbuffer = '';
|
|
if (cp.stdout) {
|
|
cp.stdout.on('data', (data) => {
|
|
if (this.options.listeners && this.options.listeners.stdout) {
|
|
this.options.listeners.stdout(data);
|
|
}
|
|
if (!optionsNonNull.silent && optionsNonNull.outStream) {
|
|
optionsNonNull.outStream.write(data);
|
|
}
|
|
stdbuffer = this._processLineBuffer(data, stdbuffer, (line) => {
|
|
if (this.options.listeners && this.options.listeners.stdline) {
|
|
this.options.listeners.stdline(line);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
let errbuffer = '';
|
|
if (cp.stderr) {
|
|
cp.stderr.on('data', (data) => {
|
|
state.processStderr = true;
|
|
if (this.options.listeners && this.options.listeners.stderr) {
|
|
this.options.listeners.stderr(data);
|
|
}
|
|
if (!optionsNonNull.silent &&
|
|
optionsNonNull.errStream &&
|
|
optionsNonNull.outStream) {
|
|
const s = optionsNonNull.failOnStdErr
|
|
? optionsNonNull.errStream
|
|
: optionsNonNull.outStream;
|
|
s.write(data);
|
|
}
|
|
errbuffer = this._processLineBuffer(data, errbuffer, (line) => {
|
|
if (this.options.listeners && this.options.listeners.errline) {
|
|
this.options.listeners.errline(line);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
cp.on('error', (err) => {
|
|
state.processError = err.message;
|
|
state.processExited = true;
|
|
state.processClosed = true;
|
|
state.CheckComplete();
|
|
});
|
|
cp.on('exit', (code) => {
|
|
state.processExitCode = code;
|
|
state.processExited = true;
|
|
this._debug(`Exit code ${code} received from tool '${this.toolPath}'`);
|
|
state.CheckComplete();
|
|
});
|
|
cp.on('close', (code) => {
|
|
state.processExitCode = code;
|
|
state.processExited = true;
|
|
state.processClosed = true;
|
|
this._debug(`STDIO streams have closed for tool '${this.toolPath}'`);
|
|
state.CheckComplete();
|
|
});
|
|
state.on('done', (error, exitCode) => {
|
|
if (stdbuffer.length > 0) {
|
|
this.emit('stdline', stdbuffer);
|
|
}
|
|
if (errbuffer.length > 0) {
|
|
this.emit('errline', errbuffer);
|
|
}
|
|
cp.removeAllListeners();
|
|
if (error) {
|
|
reject(error);
|
|
}
|
|
else {
|
|
resolve(exitCode);
|
|
}
|
|
});
|
|
if (this.options.input) {
|
|
if (!cp.stdin) {
|
|
throw new Error('child process missing stdin');
|
|
}
|
|
cp.stdin.end(this.options.input);
|
|
}
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* Convert an arg string to an array of args. Handles escaping
|
|
*
|
|
* @param argString string of arguments
|
|
* @returns string[] array of arguments
|
|
*/
|
|
function argStringToArray(argString) {
|
|
const args = [];
|
|
let inQuotes = false;
|
|
let escaped = false;
|
|
let arg = '';
|
|
function append(c) {
|
|
// we only escape double quotes.
|
|
if (escaped && c !== '"') {
|
|
arg += '\\';
|
|
}
|
|
arg += c;
|
|
escaped = false;
|
|
}
|
|
for (let i = 0; i < argString.length; i++) {
|
|
const c = argString.charAt(i);
|
|
if (c === '"') {
|
|
if (!escaped) {
|
|
inQuotes = !inQuotes;
|
|
}
|
|
else {
|
|
append(c);
|
|
}
|
|
continue;
|
|
}
|
|
if (c === '\\' && escaped) {
|
|
append(c);
|
|
continue;
|
|
}
|
|
if (c === '\\' && inQuotes) {
|
|
escaped = true;
|
|
continue;
|
|
}
|
|
if (c === ' ' && !inQuotes) {
|
|
if (arg.length > 0) {
|
|
args.push(arg);
|
|
arg = '';
|
|
}
|
|
continue;
|
|
}
|
|
append(c);
|
|
}
|
|
if (arg.length > 0) {
|
|
args.push(arg.trim());
|
|
}
|
|
return args;
|
|
}
|
|
class ExecState extends external_events_.EventEmitter {
|
|
constructor(options, toolPath) {
|
|
super();
|
|
this.processClosed = false; // tracks whether the process has exited and stdio is closed
|
|
this.processError = '';
|
|
this.processExitCode = 0;
|
|
this.processExited = false; // tracks whether the process has exited
|
|
this.processStderr = false; // tracks whether stderr was written to
|
|
this.delay = 10000; // 10 seconds
|
|
this.done = false;
|
|
this.timeout = null;
|
|
if (!toolPath) {
|
|
throw new Error('toolPath must not be empty');
|
|
}
|
|
this.options = options;
|
|
this.toolPath = toolPath;
|
|
if (options.delay) {
|
|
this.delay = options.delay;
|
|
}
|
|
}
|
|
CheckComplete() {
|
|
if (this.done) {
|
|
return;
|
|
}
|
|
if (this.processClosed) {
|
|
this._setResult();
|
|
}
|
|
else if (this.processExited) {
|
|
this.timeout = (0,external_timers_namespaceObject.setTimeout)(ExecState.HandleTimeout, this.delay, this);
|
|
}
|
|
}
|
|
_debug(message) {
|
|
this.emit('debug', message);
|
|
}
|
|
_setResult() {
|
|
// determine whether there is an error
|
|
let error;
|
|
if (this.processExited) {
|
|
if (this.processError) {
|
|
error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`);
|
|
}
|
|
else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) {
|
|
error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`);
|
|
}
|
|
else if (this.processStderr && this.options.failOnStdErr) {
|
|
error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`);
|
|
}
|
|
}
|
|
// clear the timeout
|
|
if (this.timeout) {
|
|
clearTimeout(this.timeout);
|
|
this.timeout = null;
|
|
}
|
|
this.done = true;
|
|
this.emit('done', error, this.processExitCode);
|
|
}
|
|
static HandleTimeout(state) {
|
|
if (state.done) {
|
|
return;
|
|
}
|
|
if (!state.processClosed && state.processExited) {
|
|
const message = `The STDIO streams did not close within ${state.delay / 1000} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`;
|
|
state._debug(message);
|
|
}
|
|
state._setResult();
|
|
}
|
|
}
|
|
//# sourceMappingURL=toolrunner.js.map
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/exec/lib/exec.js
|
|
var exec_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* Exec a command.
|
|
* Output will be streamed to the live console.
|
|
* Returns promise with return code
|
|
*
|
|
* @param commandLine command to execute (can include additional args). Must be correctly escaped.
|
|
* @param args optional arguments for tool. Escaping is handled by the lib.
|
|
* @param options optional exec options. See ExecOptions
|
|
* @returns Promise<number> exit code
|
|
*/
|
|
function exec_exec(commandLine, args, options) {
|
|
return exec_awaiter(this, void 0, void 0, function* () {
|
|
const commandArgs = argStringToArray(commandLine);
|
|
if (commandArgs.length === 0) {
|
|
throw new Error(`Parameter 'commandLine' cannot be null or empty.`);
|
|
}
|
|
// Path to tool to execute should be first arg
|
|
const toolPath = commandArgs[0];
|
|
args = commandArgs.slice(1).concat(args || []);
|
|
const runner = new ToolRunner(toolPath, args, options);
|
|
return runner.exec();
|
|
});
|
|
}
|
|
/**
|
|
* Exec a command and get the output.
|
|
* Output will be streamed to the live console.
|
|
* Returns promise with the exit code and collected stdout and stderr
|
|
*
|
|
* @param commandLine command to execute (can include additional args). Must be correctly escaped.
|
|
* @param args optional arguments for tool. Escaping is handled by the lib.
|
|
* @param options optional exec options. See ExecOptions
|
|
* @returns Promise<ExecOutput> exit code, stdout, and stderr
|
|
*/
|
|
function getExecOutput(commandLine, args, options) {
|
|
return exec_awaiter(this, void 0, void 0, function* () {
|
|
var _a, _b;
|
|
let stdout = '';
|
|
let stderr = '';
|
|
//Using string decoder covers the case where a mult-byte character is split
|
|
const stdoutDecoder = new StringDecoder('utf8');
|
|
const stderrDecoder = new StringDecoder('utf8');
|
|
const originalStdoutListener = (_a = options === null || options === void 0 ? void 0 : options.listeners) === null || _a === void 0 ? void 0 : _a.stdout;
|
|
const originalStdErrListener = (_b = options === null || options === void 0 ? void 0 : options.listeners) === null || _b === void 0 ? void 0 : _b.stderr;
|
|
const stdErrListener = (data) => {
|
|
stderr += stderrDecoder.write(data);
|
|
if (originalStdErrListener) {
|
|
originalStdErrListener(data);
|
|
}
|
|
};
|
|
const stdOutListener = (data) => {
|
|
stdout += stdoutDecoder.write(data);
|
|
if (originalStdoutListener) {
|
|
originalStdoutListener(data);
|
|
}
|
|
};
|
|
const listeners = Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.listeners), { stdout: stdOutListener, stderr: stdErrListener });
|
|
const exitCode = yield exec_exec(commandLine, args, Object.assign(Object.assign({}, options), { listeners }));
|
|
//flush any remaining characters
|
|
stdout += stdoutDecoder.end();
|
|
stderr += stderrDecoder.end();
|
|
return {
|
|
exitCode,
|
|
stdout,
|
|
stderr
|
|
};
|
|
});
|
|
}
|
|
//# sourceMappingURL=exec.js.map
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/core/lib/platform.js
|
|
var platform_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
|
|
const getWindowsInfo = () => platform_awaiter(void 0, void 0, void 0, function* () {
|
|
const { stdout: version } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Version"', undefined, {
|
|
silent: true
|
|
});
|
|
const { stdout: name } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Caption"', undefined, {
|
|
silent: true
|
|
});
|
|
return {
|
|
name: name.trim(),
|
|
version: version.trim()
|
|
};
|
|
});
|
|
const getMacOsInfo = () => platform_awaiter(void 0, void 0, void 0, function* () {
|
|
var _a, _b, _c, _d;
|
|
const { stdout } = yield exec.getExecOutput('sw_vers', undefined, {
|
|
silent: true
|
|
});
|
|
const version = (_b = (_a = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : '';
|
|
const name = (_d = (_c = stdout.match(/ProductName:\s*(.+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : '';
|
|
return {
|
|
name,
|
|
version
|
|
};
|
|
});
|
|
const getLinuxInfo = () => platform_awaiter(void 0, void 0, void 0, function* () {
|
|
const { stdout } = yield exec.getExecOutput('lsb_release', ['-i', '-r', '-s'], {
|
|
silent: true
|
|
});
|
|
const [name, version] = stdout.trim().split('\n');
|
|
return {
|
|
name,
|
|
version
|
|
};
|
|
});
|
|
const platform = external_os_namespaceObject.platform();
|
|
const arch = external_os_namespaceObject.arch();
|
|
const isWindows = platform === 'win32';
|
|
const isMacOS = platform === 'darwin';
|
|
const isLinux = platform === 'linux';
|
|
function getDetails() {
|
|
return platform_awaiter(this, void 0, void 0, function* () {
|
|
return Object.assign(Object.assign({}, (yield (isWindows
|
|
? getWindowsInfo()
|
|
: isMacOS
|
|
? getMacOsInfo()
|
|
: getLinuxInfo()))), { platform,
|
|
arch,
|
|
isWindows,
|
|
isMacOS,
|
|
isLinux });
|
|
});
|
|
}
|
|
//# sourceMappingURL=platform.js.map
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/core/lib/core.js
|
|
var core_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* The code to exit an action
|
|
*/
|
|
var ExitCode;
|
|
(function (ExitCode) {
|
|
/**
|
|
* A code indicating that the action was successful
|
|
*/
|
|
ExitCode[ExitCode["Success"] = 0] = "Success";
|
|
/**
|
|
* A code indicating that the action was a failure
|
|
*/
|
|
ExitCode[ExitCode["Failure"] = 1] = "Failure";
|
|
})(ExitCode || (ExitCode = {}));
|
|
//-----------------------------------------------------------------------
|
|
// Variables
|
|
//-----------------------------------------------------------------------
|
|
/**
|
|
* Sets env variable for this action and future actions in the job
|
|
* @param name the name of the variable to set
|
|
* @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify
|
|
*/
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
function exportVariable(name, val) {
|
|
const convertedVal = toCommandValue(val);
|
|
process.env[name] = convertedVal;
|
|
const filePath = process.env['GITHUB_ENV'] || '';
|
|
if (filePath) {
|
|
return issueFileCommand('ENV', prepareKeyValueMessage(name, val));
|
|
}
|
|
issueCommand('set-env', { name }, convertedVal);
|
|
}
|
|
/**
|
|
* Registers a secret which will get masked from logs
|
|
*
|
|
* @param secret - Value of the secret to be masked
|
|
* @remarks
|
|
* This function instructs the Actions runner to mask the specified value in any
|
|
* logs produced during the workflow run. Once registered, the secret value will
|
|
* be replaced with asterisks (***) whenever it appears in console output, logs,
|
|
* or error messages.
|
|
*
|
|
* This is useful for protecting sensitive information such as:
|
|
* - API keys
|
|
* - Access tokens
|
|
* - Authentication credentials
|
|
* - URL parameters containing signatures (SAS tokens)
|
|
*
|
|
* Note that masking only affects future logs; any previous appearances of the
|
|
* secret in logs before calling this function will remain unmasked.
|
|
*
|
|
* @example
|
|
* ```typescript
|
|
* // Register an API token as a secret
|
|
* const apiToken = "abc123xyz456";
|
|
* setSecret(apiToken);
|
|
*
|
|
* // Now any logs containing this value will show *** instead
|
|
* console.log(`Using token: ${apiToken}`); // Outputs: "Using token: ***"
|
|
* ```
|
|
*/
|
|
function core_setSecret(secret) {
|
|
command_issueCommand('add-mask', {}, secret);
|
|
}
|
|
/**
|
|
* Prepends inputPath to the PATH (for this action and future actions)
|
|
* @param inputPath
|
|
*/
|
|
function addPath(inputPath) {
|
|
const filePath = process.env['GITHUB_PATH'] || '';
|
|
if (filePath) {
|
|
issueFileCommand('PATH', inputPath);
|
|
}
|
|
else {
|
|
issueCommand('add-path', {}, inputPath);
|
|
}
|
|
process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
|
|
}
|
|
/**
|
|
* Gets the value of an input.
|
|
* Unless trimWhitespace is set to false in InputOptions, the value is also trimmed.
|
|
* Returns an empty string if the value is not defined.
|
|
*
|
|
* @param name name of the input to get
|
|
* @param options optional. See InputOptions.
|
|
* @returns string
|
|
*/
|
|
function getInput(name, options) {
|
|
const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
|
|
if (options && options.required && !val) {
|
|
throw new Error(`Input required and not supplied: ${name}`);
|
|
}
|
|
if (options && options.trimWhitespace === false) {
|
|
return val;
|
|
}
|
|
return val.trim();
|
|
}
|
|
/**
|
|
* Gets the values of an multiline input. Each value is also trimmed.
|
|
*
|
|
* @param name name of the input to get
|
|
* @param options optional. See InputOptions.
|
|
* @returns string[]
|
|
*
|
|
*/
|
|
function getMultilineInput(name, options) {
|
|
const inputs = getInput(name, options)
|
|
.split('\n')
|
|
.filter(x => x !== '');
|
|
if (options && options.trimWhitespace === false) {
|
|
return inputs;
|
|
}
|
|
return inputs.map(input => input.trim());
|
|
}
|
|
/**
|
|
* Gets the input value of the boolean type in the YAML 1.2 "core schema" specification.
|
|
* Support boolean input list: `true | True | TRUE | false | False | FALSE` .
|
|
* The return value is also in boolean type.
|
|
* ref: https://yaml.org/spec/1.2/spec.html#id2804923
|
|
*
|
|
* @param name name of the input to get
|
|
* @param options optional. See InputOptions.
|
|
* @returns boolean
|
|
*/
|
|
function getBooleanInput(name, options) {
|
|
const trueValue = ['true', 'True', 'TRUE'];
|
|
const falseValue = ['false', 'False', 'FALSE'];
|
|
const val = getInput(name, options);
|
|
if (trueValue.includes(val))
|
|
return true;
|
|
if (falseValue.includes(val))
|
|
return false;
|
|
throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` +
|
|
`Support boolean input list: \`true | True | TRUE | false | False | FALSE\``);
|
|
}
|
|
/**
|
|
* Sets the value of an output.
|
|
*
|
|
* @param name name of the output to set
|
|
* @param value value to store. Non-string values will be converted to a string via JSON.stringify
|
|
*/
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
function setOutput(name, value) {
|
|
const filePath = process.env['GITHUB_OUTPUT'] || '';
|
|
if (filePath) {
|
|
return file_command_issueFileCommand('OUTPUT', file_command_prepareKeyValueMessage(name, value));
|
|
}
|
|
process.stdout.write(external_os_namespaceObject.EOL);
|
|
command_issueCommand('set-output', { name }, utils_toCommandValue(value));
|
|
}
|
|
/**
|
|
* Enables or disables the echoing of commands into stdout for the rest of the step.
|
|
* Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
|
|
*
|
|
*/
|
|
function setCommandEcho(enabled) {
|
|
issue('echo', enabled ? 'on' : 'off');
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
// Results
|
|
//-----------------------------------------------------------------------
|
|
/**
|
|
* Sets the action status to failed.
|
|
* When the action exits it will be with an exit code of 1
|
|
* @param message add error issue message
|
|
*/
|
|
function setFailed(message) {
|
|
process.exitCode = ExitCode.Failure;
|
|
error(message);
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
// Logging Commands
|
|
//-----------------------------------------------------------------------
|
|
/**
|
|
* Gets whether Actions Step Debug is on or not
|
|
*/
|
|
function isDebug() {
|
|
return process.env['RUNNER_DEBUG'] === '1';
|
|
}
|
|
/**
|
|
* Writes debug message to user log
|
|
* @param message debug message
|
|
*/
|
|
function core_debug(message) {
|
|
command_issueCommand('debug', {}, message);
|
|
}
|
|
/**
|
|
* Adds an error issue
|
|
* @param message error issue message. Errors will be converted to string via toString()
|
|
* @param properties optional properties to add to the annotation.
|
|
*/
|
|
function error(message, properties = {}) {
|
|
command_issueCommand('error', utils_toCommandProperties(properties), message instanceof Error ? message.toString() : message);
|
|
}
|
|
/**
|
|
* Adds a warning issue
|
|
* @param message warning issue message. Errors will be converted to string via toString()
|
|
* @param properties optional properties to add to the annotation.
|
|
*/
|
|
function warning(message, properties = {}) {
|
|
command_issueCommand('warning', utils_toCommandProperties(properties), message instanceof Error ? message.toString() : message);
|
|
}
|
|
/**
|
|
* Adds a notice issue
|
|
* @param message notice issue message. Errors will be converted to string via toString()
|
|
* @param properties optional properties to add to the annotation.
|
|
*/
|
|
function notice(message, properties = {}) {
|
|
issueCommand('notice', toCommandProperties(properties), message instanceof Error ? message.toString() : message);
|
|
}
|
|
/**
|
|
* Writes info to log with console.log.
|
|
* @param message info message
|
|
*/
|
|
function info(message) {
|
|
process.stdout.write(message + external_os_namespaceObject.EOL);
|
|
}
|
|
/**
|
|
* Begin an output group.
|
|
*
|
|
* Output until the next `groupEnd` will be foldable in this group
|
|
*
|
|
* @param name The name of the output group
|
|
*/
|
|
function startGroup(name) {
|
|
command_issue('group', name);
|
|
}
|
|
/**
|
|
* End an output group.
|
|
*/
|
|
function endGroup() {
|
|
command_issue('endgroup');
|
|
}
|
|
/**
|
|
* Wrap an asynchronous function call in a group.
|
|
*
|
|
* Returns the same type as the function itself.
|
|
*
|
|
* @param name The name of the group
|
|
* @param fn The function to wrap in the group
|
|
*/
|
|
function group(name, fn) {
|
|
return core_awaiter(this, void 0, void 0, function* () {
|
|
startGroup(name);
|
|
let result;
|
|
try {
|
|
result = yield fn();
|
|
}
|
|
finally {
|
|
endGroup();
|
|
}
|
|
return result;
|
|
});
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
// Wrapper action state
|
|
//-----------------------------------------------------------------------
|
|
/**
|
|
* Saves state for current action, the state can only be retrieved by this action's post job execution.
|
|
*
|
|
* @param name name of the state to store
|
|
* @param value value to store. Non-string values will be converted to a string via JSON.stringify
|
|
*/
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
function saveState(name, value) {
|
|
const filePath = process.env['GITHUB_STATE'] || '';
|
|
if (filePath) {
|
|
return file_command_issueFileCommand('STATE', file_command_prepareKeyValueMessage(name, value));
|
|
}
|
|
command_issueCommand('save-state', { name }, utils_toCommandValue(value));
|
|
}
|
|
/**
|
|
* Gets the value of an state set by this action's main execution.
|
|
*
|
|
* @param name name of the state to get
|
|
* @returns string
|
|
*/
|
|
function getState(name) {
|
|
return process.env[`STATE_${name}`] || '';
|
|
}
|
|
function getIDToken(aud) {
|
|
return core_awaiter(this, void 0, void 0, function* () {
|
|
return yield OidcClient.getIDToken(aud);
|
|
});
|
|
}
|
|
/**
|
|
* Summary exports
|
|
*/
|
|
|
|
/**
|
|
* @deprecated use core.summary
|
|
*/
|
|
|
|
/**
|
|
* Path exports
|
|
*/
|
|
|
|
/**
|
|
* Platform utilities exports
|
|
*/
|
|
|
|
//# sourceMappingURL=core.js.map
|
|
;// CONCATENATED MODULE: ./src/fs-helper.ts
|
|
|
|
function directoryExistsSync(path, required) {
|
|
if (!path) {
|
|
throw new Error("Arg 'path' must not be empty");
|
|
}
|
|
let stats;
|
|
try {
|
|
stats = external_fs_namespaceObject.statSync(path);
|
|
}
|
|
catch (error) {
|
|
if (error?.code === 'ENOENT') {
|
|
if (!required) {
|
|
return false;
|
|
}
|
|
throw new Error(`Directory '${path}' does not exist`);
|
|
}
|
|
throw new Error(`Encountered an error when checking whether path '${path}' exists: ${error?.message ?? error}`);
|
|
}
|
|
if (stats.isDirectory()) {
|
|
return true;
|
|
}
|
|
else if (!required) {
|
|
return false;
|
|
}
|
|
throw new Error(`Directory '${path}' does not exist`);
|
|
}
|
|
function existsSync(path) {
|
|
if (!path) {
|
|
throw new Error("Arg 'path' must not be empty");
|
|
}
|
|
try {
|
|
fs.statSync(path);
|
|
}
|
|
catch (error) {
|
|
if (error?.code === 'ENOENT') {
|
|
return false;
|
|
}
|
|
throw new Error(`Encountered an error when checking whether path '${path}' exists: ${error?.message ?? error}`);
|
|
}
|
|
return true;
|
|
}
|
|
function fileExistsSync(path) {
|
|
if (!path) {
|
|
throw new Error("Arg 'path' must not be empty");
|
|
}
|
|
let stats;
|
|
try {
|
|
stats = external_fs_namespaceObject.statSync(path);
|
|
}
|
|
catch (error) {
|
|
if (error?.code === 'ENOENT') {
|
|
return false;
|
|
}
|
|
throw new Error(`Encountered an error when checking whether path '${path}' exists: ${error?.message ?? error}`);
|
|
}
|
|
if (!stats.isDirectory()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/regexp-helper.ts
|
|
function regexp_helper_escape(value) {
|
|
return value.replace(/[^a-zA-Z0-9_]/g, x => {
|
|
return `\\${x}`;
|
|
});
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/state-helper.ts
|
|
|
|
/**
|
|
* Indicates whether the POST action is running
|
|
*/
|
|
const IsPost = !!getState('isPost');
|
|
/**
|
|
* The repository path for the POST action. The value is empty during the MAIN action.
|
|
*/
|
|
const RepositoryPath = getState('repositoryPath');
|
|
/**
|
|
* The set-safe-directory for the POST action. The value is set if input: 'safe-directory' is set during the MAIN action.
|
|
*/
|
|
const PostSetSafeDirectory = getState('setSafeDirectory') === 'true';
|
|
/**
|
|
* The SSH key path for the POST action. The value is empty during the MAIN action.
|
|
*/
|
|
const SshKeyPath = getState('sshKeyPath');
|
|
/**
|
|
* The SSH known hosts path for the POST action. The value is empty during the MAIN action.
|
|
*/
|
|
const SshKnownHostsPath = getState('sshKnownHostsPath');
|
|
/**
|
|
* Save the repository path so the POST action can retrieve the value.
|
|
*/
|
|
function setRepositoryPath(repositoryPath) {
|
|
saveState('repositoryPath', repositoryPath);
|
|
}
|
|
/**
|
|
* Save the SSH key path so the POST action can retrieve the value.
|
|
*/
|
|
function setSshKeyPath(sshKeyPath) {
|
|
saveState('sshKeyPath', sshKeyPath);
|
|
}
|
|
/**
|
|
* Save the SSH known hosts path so the POST action can retrieve the value.
|
|
*/
|
|
function setSshKnownHostsPath(sshKnownHostsPath) {
|
|
saveState('sshKnownHostsPath', sshKnownHostsPath);
|
|
}
|
|
/**
|
|
* Save the set-safe-directory input so the POST action can retrieve the value.
|
|
*/
|
|
function setSafeDirectory() {
|
|
saveState('setSafeDirectory', 'true');
|
|
}
|
|
// Publish a variable so that when the POST action runs, it can determine it should run the cleanup logic.
|
|
// This is necessary since we don't have a separate entry point.
|
|
if (!IsPost) {
|
|
saveState('isPost', 'true');
|
|
}
|
|
|
|
;// CONCATENATED MODULE: external "url"
|
|
const external_url_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("url");
|
|
;// CONCATENATED MODULE: ./src/url-helper.ts
|
|
|
|
|
|
function getFetchUrl(settings) {
|
|
external_assert_.ok(settings.repositoryOwner, 'settings.repositoryOwner must be defined');
|
|
external_assert_.ok(settings.repositoryName, 'settings.repositoryName must be defined');
|
|
const serviceUrl = getServerUrl(settings.githubServerUrl);
|
|
const encodedOwner = encodeURIComponent(settings.repositoryOwner);
|
|
const encodedName = encodeURIComponent(settings.repositoryName);
|
|
if (settings.sshKey) {
|
|
const user = settings.sshUser.length > 0 ? settings.sshUser : 'git';
|
|
return `${user}@${serviceUrl.hostname}:${encodedOwner}/${encodedName}.git`;
|
|
}
|
|
// "origin" is SCHEME://HOSTNAME[:PORT]
|
|
return `${serviceUrl.origin}/${encodedOwner}/${encodedName}`;
|
|
}
|
|
function getServerUrl(url) {
|
|
let resolvedUrl = process.env['GITHUB_SERVER_URL'] || 'https://github.com';
|
|
if (hasContent(url, WhitespaceMode.Trim)) {
|
|
resolvedUrl = url;
|
|
}
|
|
return new external_url_namespaceObject.URL(resolvedUrl);
|
|
}
|
|
function getServerApiUrl(url) {
|
|
if (hasContent(url, WhitespaceMode.Trim)) {
|
|
let serverUrl = getServerUrl(url);
|
|
if (isGhes(url)) {
|
|
serverUrl.pathname = 'api/v3';
|
|
}
|
|
else {
|
|
serverUrl.hostname = 'api.' + serverUrl.hostname;
|
|
}
|
|
return pruneSuffix(serverUrl.toString(), '/');
|
|
}
|
|
return process.env['GITHUB_API_URL'] || 'https://api.github.com';
|
|
}
|
|
function isGhes(url) {
|
|
const ghUrl = new external_url_namespaceObject.URL(url || process.env['GITHUB_SERVER_URL'] || 'https://github.com');
|
|
const hostname = ghUrl.hostname.trimEnd().toUpperCase();
|
|
const isGitHubHost = hostname === 'GITHUB.COM';
|
|
const isGitHubEnterpriseCloudHost = hostname.endsWith('.GHE.COM');
|
|
const isLocalHost = hostname.endsWith('.LOCALHOST');
|
|
return !isGitHubHost && !isGitHubEnterpriseCloudHost && !isLocalHost;
|
|
}
|
|
function pruneSuffix(text, suffix) {
|
|
if (hasContent(suffix, WhitespaceMode.Preserve) && text?.endsWith(suffix)) {
|
|
return text.substring(0, text.length - suffix.length);
|
|
}
|
|
return text;
|
|
}
|
|
var WhitespaceMode;
|
|
(function (WhitespaceMode) {
|
|
WhitespaceMode[WhitespaceMode["Trim"] = 0] = "Trim";
|
|
WhitespaceMode[WhitespaceMode["Preserve"] = 1] = "Preserve";
|
|
})(WhitespaceMode || (WhitespaceMode = {}));
|
|
function hasContent(text, whitespaceMode) {
|
|
let refinedText = text ?? '';
|
|
if (whitespaceMode == WhitespaceMode.Trim) {
|
|
refinedText = refinedText.trim();
|
|
}
|
|
return refinedText.length > 0;
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/git-auth-helper.ts
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const git_auth_helper_IS_WINDOWS = process.platform === 'win32';
|
|
const SSH_COMMAND_KEY = 'core.sshCommand';
|
|
function createAuthHelper(git, settings) {
|
|
return new GitAuthHelper(git, settings);
|
|
}
|
|
class GitAuthHelper {
|
|
git;
|
|
settings;
|
|
tokenConfigKey;
|
|
tokenConfigValue;
|
|
tokenPlaceholderConfigValue;
|
|
insteadOfKey;
|
|
insteadOfValues = [];
|
|
sshCommand = '';
|
|
sshKeyPath = '';
|
|
sshKnownHostsPath = '';
|
|
temporaryHomePath = '';
|
|
credentialsConfigPath = ''; // Path to separate credentials config file in RUNNER_TEMP
|
|
constructor(gitCommandManager, gitSourceSettings) {
|
|
this.git = gitCommandManager;
|
|
this.settings = gitSourceSettings || {};
|
|
// Token auth header
|
|
const serverUrl = getServerUrl(this.settings.githubServerUrl);
|
|
this.tokenConfigKey = `http.${serverUrl.origin}/.extraheader`; // "origin" is SCHEME://HOSTNAME[:PORT]
|
|
const basicCredential = Buffer.from(`x-access-token:${this.settings.authToken}`, 'utf8').toString('base64');
|
|
core_setSecret(basicCredential);
|
|
this.tokenPlaceholderConfigValue = `AUTHORIZATION: basic ***`;
|
|
this.tokenConfigValue = `AUTHORIZATION: basic ${basicCredential}`;
|
|
// Instead of SSH URL
|
|
this.insteadOfKey = `url.${serverUrl.origin}/.insteadOf`; // "origin" is SCHEME://HOSTNAME[:PORT]
|
|
this.insteadOfValues.push(`git@${serverUrl.hostname}:`);
|
|
if (this.settings.workflowOrganizationId) {
|
|
this.insteadOfValues.push(`org-${this.settings.workflowOrganizationId}@github.com:`);
|
|
}
|
|
}
|
|
async configureAuth() {
|
|
// Remove possible previous values
|
|
await this.removeAuth();
|
|
// Configure new values
|
|
await this.configureSsh();
|
|
await this.configureToken();
|
|
}
|
|
async configureTempGlobalConfig() {
|
|
// Already setup global config
|
|
if (this.temporaryHomePath?.length > 0) {
|
|
return external_path_namespaceObject.join(this.temporaryHomePath, '.gitconfig');
|
|
}
|
|
// Create a temp home directory
|
|
const runnerTemp = process.env['RUNNER_TEMP'] || '';
|
|
external_assert_.ok(runnerTemp, 'RUNNER_TEMP is not defined');
|
|
const uniqueId = (0,external_crypto_namespaceObject.randomUUID)();
|
|
this.temporaryHomePath = external_path_namespaceObject.join(runnerTemp, uniqueId);
|
|
await external_fs_namespaceObject.promises.mkdir(this.temporaryHomePath, { recursive: true });
|
|
// Copy the global git config
|
|
const gitConfigPath = external_path_namespaceObject.join(process.env['HOME'] || external_os_namespaceObject.homedir(), '.gitconfig');
|
|
const newGitConfigPath = external_path_namespaceObject.join(this.temporaryHomePath, '.gitconfig');
|
|
let configExists = false;
|
|
try {
|
|
await external_fs_namespaceObject.promises.stat(gitConfigPath);
|
|
configExists = true;
|
|
}
|
|
catch (err) {
|
|
if (err?.code !== 'ENOENT') {
|
|
throw err;
|
|
}
|
|
}
|
|
if (configExists) {
|
|
info(`Copying '${gitConfigPath}' to '${newGitConfigPath}'`);
|
|
await io_cp(gitConfigPath, newGitConfigPath);
|
|
}
|
|
else {
|
|
await external_fs_namespaceObject.promises.writeFile(newGitConfigPath, '');
|
|
}
|
|
// Override HOME
|
|
info(`Temporarily overriding HOME='${this.temporaryHomePath}' before making global git config changes`);
|
|
this.git.setEnvironmentVariable('HOME', this.temporaryHomePath);
|
|
return newGitConfigPath;
|
|
}
|
|
async configureGlobalAuth() {
|
|
// 'configureTempGlobalConfig' noops if already set, just returns the path
|
|
await this.configureTempGlobalConfig();
|
|
try {
|
|
// Configure the token
|
|
await this.configureToken(true);
|
|
// Configure HTTPS instead of SSH
|
|
await this.git.tryConfigUnset(this.insteadOfKey, true);
|
|
if (!this.settings.sshKey) {
|
|
for (const insteadOfValue of this.insteadOfValues) {
|
|
await this.git.config(this.insteadOfKey, insteadOfValue, true, // globalConfig?
|
|
true // add?
|
|
);
|
|
}
|
|
}
|
|
}
|
|
catch (err) {
|
|
// Unset in case somehow written to the real global config
|
|
info('Encountered an error when attempting to configure token. Attempting unconfigure.');
|
|
await this.git.tryConfigUnset(this.tokenConfigKey, true);
|
|
throw err;
|
|
}
|
|
}
|
|
async configureSubmoduleAuth() {
|
|
// Remove possible previous HTTPS instead of SSH
|
|
await this.removeSubmoduleGitConfig(this.insteadOfKey);
|
|
if (this.settings.persistCredentials) {
|
|
// Get the credentials config file path in RUNNER_TEMP
|
|
const credentialsConfigPath = this.getCredentialsConfigPath();
|
|
// Container credentials config path
|
|
const containerCredentialsPath = external_path_namespaceObject.posix.join('/github/runner_temp', external_path_namespaceObject.basename(credentialsConfigPath));
|
|
// Get submodule config file paths.
|
|
const configPaths = await this.git.getSubmoduleConfigPaths(this.settings.nestedSubmodules);
|
|
// For each submodule, configure includeIf entries pointing to the shared credentials file.
|
|
// Configure both host and container paths to support Docker container actions.
|
|
for (const configPath of configPaths) {
|
|
// Submodule Git directory
|
|
let submoduleGitDir = external_path_namespaceObject.dirname(configPath); // The config file is at .git/modules/submodule-name/config
|
|
submoduleGitDir = submoduleGitDir.replace(/\\/g, '/'); // Use forward slashes, even on Windows
|
|
// Configure host includeIf
|
|
await this.git.config(`includeIf.gitdir:${submoduleGitDir}.path`, credentialsConfigPath, false, // globalConfig?
|
|
false, // add?
|
|
configPath);
|
|
// Container submodule git directory
|
|
const githubWorkspace = process.env['GITHUB_WORKSPACE'];
|
|
external_assert_.ok(githubWorkspace, 'GITHUB_WORKSPACE is not defined');
|
|
let relativeSubmoduleGitDir = external_path_namespaceObject.relative(githubWorkspace, submoduleGitDir);
|
|
relativeSubmoduleGitDir = relativeSubmoduleGitDir.replace(/\\/g, '/'); // Use forward slashes, even on Windows
|
|
const containerSubmoduleGitDir = external_path_namespaceObject.posix.join('/github/workspace', relativeSubmoduleGitDir);
|
|
// Configure container includeIf
|
|
await this.git.config(`includeIf.gitdir:${containerSubmoduleGitDir}.path`, containerCredentialsPath, false, // globalConfig?
|
|
false, // add?
|
|
configPath);
|
|
}
|
|
if (this.settings.sshKey) {
|
|
// Configure core.sshCommand
|
|
await this.git.submoduleForeach(`git config --local '${SSH_COMMAND_KEY}' '${this.sshCommand}'`, this.settings.nestedSubmodules);
|
|
}
|
|
else {
|
|
// Configure HTTPS instead of SSH
|
|
for (const insteadOfValue of this.insteadOfValues) {
|
|
await this.git.submoduleForeach(`git config --local --add '${this.insteadOfKey}' '${insteadOfValue}'`, this.settings.nestedSubmodules);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
async removeAuth() {
|
|
await this.removeSsh();
|
|
await this.removeToken();
|
|
}
|
|
async removeGlobalConfig() {
|
|
if (this.temporaryHomePath?.length > 0) {
|
|
core_debug(`Unsetting HOME override`);
|
|
this.git.removeEnvironmentVariable('HOME');
|
|
await rmRF(this.temporaryHomePath);
|
|
}
|
|
}
|
|
/**
|
|
* Configures SSH authentication by writing the SSH key and known hosts,
|
|
* and setting up the GIT_SSH_COMMAND environment variable.
|
|
*/
|
|
async configureSsh() {
|
|
if (!this.settings.sshKey) {
|
|
return;
|
|
}
|
|
// Write key
|
|
const runnerTemp = process.env['RUNNER_TEMP'] || '';
|
|
external_assert_.ok(runnerTemp, 'RUNNER_TEMP is not defined');
|
|
const uniqueId = (0,external_crypto_namespaceObject.randomUUID)();
|
|
this.sshKeyPath = external_path_namespaceObject.join(runnerTemp, uniqueId);
|
|
setSshKeyPath(this.sshKeyPath);
|
|
await external_fs_namespaceObject.promises.mkdir(runnerTemp, { recursive: true });
|
|
await external_fs_namespaceObject.promises.writeFile(this.sshKeyPath, this.settings.sshKey.trim() + '\n', { mode: 0o600 });
|
|
// Remove inherited permissions on Windows
|
|
if (git_auth_helper_IS_WINDOWS) {
|
|
const icacls = await which('icacls.exe');
|
|
await exec_exec(`"${icacls}" "${this.sshKeyPath}" /grant:r "${process.env['USERDOMAIN']}\\${process.env['USERNAME']}:F"`);
|
|
await exec_exec(`"${icacls}" "${this.sshKeyPath}" /inheritance:r`);
|
|
}
|
|
// Write known hosts
|
|
const userKnownHostsPath = external_path_namespaceObject.join(external_os_namespaceObject.homedir(), '.ssh', 'known_hosts');
|
|
let userKnownHosts = '';
|
|
try {
|
|
userKnownHosts = (await external_fs_namespaceObject.promises.readFile(userKnownHostsPath)).toString();
|
|
}
|
|
catch (err) {
|
|
if (err?.code !== 'ENOENT') {
|
|
throw err;
|
|
}
|
|
}
|
|
let knownHosts = '';
|
|
if (userKnownHosts) {
|
|
knownHosts += `# Begin from ${userKnownHostsPath}\n${userKnownHosts}\n# End from ${userKnownHostsPath}\n`;
|
|
}
|
|
if (this.settings.sshKnownHosts) {
|
|
knownHosts += `# Begin from input known hosts\n${this.settings.sshKnownHosts}\n# end from input known hosts\n`;
|
|
}
|
|
knownHosts += `# Begin implicitly added github.com\ngithub.com ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCj7ndNxQowgcQnjshcLrqPEiiphnt+VTTvDP6mHBL9j1aNUkY4Ue1gvwnGLVlOhGeYrnZaMgRK6+PKCUXaDbC7qtbW8gIkhL7aGCsOr/C56SJMy/BCZfxd1nWzAOxSDPgVsmerOBYfNqltV9/hWCqBywINIR+5dIg6JTJ72pcEpEjcYgXkE2YEFXV1JHnsKgbLWNlhScqb2UmyRkQyytRLtL+38TGxkxCflmO+5Z8CSSNY7GidjMIZ7Q4zMjA2n1nGrlTDkzwDCsw+wqFPGQA179cnfGWOWRVruj16z6XyvxvjJwbz0wQZ75XK5tKSb7FNyeIEs4TT4jk+S4dhPeAUC5y+bDYirYgM4GC7uEnztnZyaVWQ7B381AK4Qdrwt51ZqExKbQpTUNn+EjqoTwvqNj4kqx5QUCI0ThS/YkOxJCXmPUWZbhjpCg56i+2aB6CmK2JGhn57K5mj0MNdBXA4/WnwH6XoPWJzK5Nyu2zB3nAZp+S5hpQs+p1vN1/wsjk=\n# End implicitly added github.com\n`;
|
|
this.sshKnownHostsPath = external_path_namespaceObject.join(runnerTemp, `${uniqueId}_known_hosts`);
|
|
setSshKnownHostsPath(this.sshKnownHostsPath);
|
|
await external_fs_namespaceObject.promises.writeFile(this.sshKnownHostsPath, knownHosts);
|
|
// Configure GIT_SSH_COMMAND
|
|
const sshPath = await which('ssh', true);
|
|
this.sshCommand = `"${sshPath}" -i "$RUNNER_TEMP/${external_path_namespaceObject.basename(this.sshKeyPath)}"`;
|
|
if (this.settings.sshStrict) {
|
|
this.sshCommand += ' -o StrictHostKeyChecking=yes -o CheckHostIP=no';
|
|
}
|
|
this.sshCommand += ` -o "UserKnownHostsFile=$RUNNER_TEMP/${external_path_namespaceObject.basename(this.sshKnownHostsPath)}"`;
|
|
info(`Temporarily overriding GIT_SSH_COMMAND=${this.sshCommand}`);
|
|
this.git.setEnvironmentVariable('GIT_SSH_COMMAND', this.sshCommand);
|
|
// Configure core.sshCommand
|
|
if (this.settings.persistCredentials) {
|
|
await this.git.config(SSH_COMMAND_KEY, this.sshCommand);
|
|
}
|
|
}
|
|
/**
|
|
* Configures token-based authentication by creating a credentials config file
|
|
* and setting up includeIf entries to reference it.
|
|
* @param globalConfig Whether to configure global config instead of local
|
|
*/
|
|
async configureToken(globalConfig) {
|
|
// Get the credentials config file path in RUNNER_TEMP
|
|
const credentialsConfigPath = this.getCredentialsConfigPath();
|
|
// Write placeholder to the separate credentials config file using git config.
|
|
// This approach avoids the credential being captured by process creation audit events,
|
|
// which are commonly logged. For more information, refer to
|
|
// https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/manage/component-updates/command-line-process-auditing
|
|
await this.git.config(this.tokenConfigKey, this.tokenPlaceholderConfigValue, false, // globalConfig?
|
|
false, // add?
|
|
credentialsConfigPath);
|
|
// Replace the placeholder in the credentials config file
|
|
let content = (await external_fs_namespaceObject.promises.readFile(credentialsConfigPath)).toString();
|
|
const placeholderIndex = content.indexOf(this.tokenPlaceholderConfigValue);
|
|
if (placeholderIndex < 0 ||
|
|
placeholderIndex != content.lastIndexOf(this.tokenPlaceholderConfigValue)) {
|
|
throw new Error(`Unable to replace auth placeholder in ${credentialsConfigPath}`);
|
|
}
|
|
external_assert_.ok(this.tokenConfigValue, 'tokenConfigValue is not defined');
|
|
content = content.replace(this.tokenPlaceholderConfigValue, this.tokenConfigValue);
|
|
await external_fs_namespaceObject.promises.writeFile(credentialsConfigPath, content);
|
|
// Add include or includeIf to reference the credentials config
|
|
if (globalConfig) {
|
|
// Global config file is temporary
|
|
await this.git.config('include.path', credentialsConfigPath, true // globalConfig?
|
|
);
|
|
}
|
|
else {
|
|
// Host git directory
|
|
let gitDir = external_path_namespaceObject.join(this.git.getWorkingDirectory(), '.git');
|
|
gitDir = gitDir.replace(/\\/g, '/'); // Use forward slashes, even on Windows
|
|
// Configure host includeIf
|
|
const hostIncludeKey = `includeIf.gitdir:${gitDir}.path`;
|
|
await this.git.config(hostIncludeKey, credentialsConfigPath);
|
|
// Configure host includeIf for worktrees
|
|
const hostWorktreeIncludeKey = `includeIf.gitdir:${gitDir}/worktrees/*.path`;
|
|
await this.git.config(hostWorktreeIncludeKey, credentialsConfigPath);
|
|
// Container git directory
|
|
const workingDirectory = this.git.getWorkingDirectory();
|
|
const githubWorkspace = process.env['GITHUB_WORKSPACE'];
|
|
external_assert_.ok(githubWorkspace, 'GITHUB_WORKSPACE is not defined');
|
|
let relativePath = external_path_namespaceObject.relative(githubWorkspace, workingDirectory);
|
|
relativePath = relativePath.replace(/\\/g, '/'); // Use forward slashes, even on Windows
|
|
const containerGitDir = external_path_namespaceObject.posix.join('/github/workspace', relativePath, '.git');
|
|
// Container credentials config path
|
|
const containerCredentialsPath = external_path_namespaceObject.posix.join('/github/runner_temp', external_path_namespaceObject.basename(credentialsConfigPath));
|
|
// Configure container includeIf
|
|
const containerIncludeKey = `includeIf.gitdir:${containerGitDir}.path`;
|
|
await this.git.config(containerIncludeKey, containerCredentialsPath);
|
|
// Configure container includeIf for worktrees
|
|
const containerWorktreeIncludeKey = `includeIf.gitdir:${containerGitDir}/worktrees/*.path`;
|
|
await this.git.config(containerWorktreeIncludeKey, containerCredentialsPath);
|
|
}
|
|
}
|
|
/**
|
|
* Gets or creates the path to the credentials config file in RUNNER_TEMP.
|
|
* @returns The absolute path to the credentials config file
|
|
*/
|
|
getCredentialsConfigPath() {
|
|
if (this.credentialsConfigPath) {
|
|
return this.credentialsConfigPath;
|
|
}
|
|
const runnerTemp = process.env['RUNNER_TEMP'] || '';
|
|
external_assert_.ok(runnerTemp, 'RUNNER_TEMP is not defined');
|
|
// Create a unique filename for this checkout instance
|
|
const configFileName = `git-credentials-${(0,external_crypto_namespaceObject.randomUUID)()}.config`;
|
|
this.credentialsConfigPath = external_path_namespaceObject.join(runnerTemp, configFileName);
|
|
core_debug(`Credentials config path: ${this.credentialsConfigPath}`);
|
|
return this.credentialsConfigPath;
|
|
}
|
|
/**
|
|
* Removes SSH authentication configuration by cleaning up SSH keys,
|
|
* known hosts files, and SSH command configurations.
|
|
*/
|
|
async removeSsh() {
|
|
// SSH key
|
|
const keyPath = this.sshKeyPath || SshKeyPath;
|
|
if (keyPath) {
|
|
try {
|
|
info(`Removing SSH key '${keyPath}'`);
|
|
await rmRF(keyPath);
|
|
}
|
|
catch (err) {
|
|
core_debug(`${err?.message ?? err}`);
|
|
warning(`Failed to remove SSH key '${keyPath}'`);
|
|
}
|
|
}
|
|
// SSH known hosts
|
|
const knownHostsPath = this.sshKnownHostsPath || SshKnownHostsPath;
|
|
if (knownHostsPath) {
|
|
try {
|
|
info(`Removing SSH known hosts '${knownHostsPath}'`);
|
|
await rmRF(knownHostsPath);
|
|
}
|
|
catch (err) {
|
|
core_debug(`${err?.message ?? err}`);
|
|
warning(`Failed to remove SSH known hosts '${knownHostsPath}'`);
|
|
}
|
|
}
|
|
// SSH command
|
|
info('Removing SSH command configuration');
|
|
await this.removeGitConfig(SSH_COMMAND_KEY);
|
|
await this.removeSubmoduleGitConfig(SSH_COMMAND_KEY);
|
|
}
|
|
/**
|
|
* Removes token-based authentication by cleaning up HTTP headers,
|
|
* includeIf entries, and credentials config files.
|
|
*/
|
|
async removeToken() {
|
|
// Remove HTTP extra header
|
|
info('Removing HTTP extra header');
|
|
await this.removeGitConfig(this.tokenConfigKey);
|
|
await this.removeSubmoduleGitConfig(this.tokenConfigKey);
|
|
// Collect credentials config paths that need to be removed
|
|
const credentialsPaths = new Set();
|
|
// Remove includeIf entries that point to git-credentials-*.config files
|
|
info('Removing includeIf entries pointing to credentials config files');
|
|
const mainCredentialsPaths = await this.removeIncludeIfCredentials();
|
|
mainCredentialsPaths.forEach(path => credentialsPaths.add(path));
|
|
// Remove submodule includeIf entries that point to git-credentials-*.config files
|
|
const submoduleConfigPaths = await this.git.getSubmoduleConfigPaths(true);
|
|
for (const configPath of submoduleConfigPaths) {
|
|
const submoduleCredentialsPaths = await this.removeIncludeIfCredentials(configPath);
|
|
submoduleCredentialsPaths.forEach(path => credentialsPaths.add(path));
|
|
}
|
|
// Remove credentials config files
|
|
for (const credentialsPath of credentialsPaths) {
|
|
// Only remove credentials config files if they are under RUNNER_TEMP
|
|
const runnerTemp = process.env['RUNNER_TEMP'];
|
|
external_assert_.ok(runnerTemp, 'RUNNER_TEMP is not defined');
|
|
if (credentialsPath.startsWith(runnerTemp)) {
|
|
try {
|
|
info(`Removing credentials config '${credentialsPath}'`);
|
|
await rmRF(credentialsPath);
|
|
}
|
|
catch (err) {
|
|
core_debug(`${err?.message ?? err}`);
|
|
warning(`Failed to remove credentials config '${credentialsPath}'`);
|
|
}
|
|
}
|
|
else {
|
|
core_debug(`Skipping removal of credentials config '${credentialsPath}' - not under RUNNER_TEMP`);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Removes a git config key from the local repository config.
|
|
* @param configKey The git config key to remove
|
|
*/
|
|
async removeGitConfig(configKey) {
|
|
if ((await this.git.configExists(configKey)) &&
|
|
!(await this.git.tryConfigUnset(configKey))) {
|
|
// Load the config contents
|
|
warning(`Failed to remove '${configKey}' from the git config`);
|
|
}
|
|
}
|
|
/**
|
|
* Removes a git config key from all submodule configs.
|
|
* @param configKey The git config key to remove
|
|
*/
|
|
async removeSubmoduleGitConfig(configKey) {
|
|
const pattern = regexp_helper_escape(configKey);
|
|
await this.git.submoduleForeach(
|
|
// Wrap the pipeline in quotes to make sure it's handled properly by submoduleForeach, rather than just the first part of the pipeline.
|
|
`sh -c "git config --local --name-only --get-regexp '${pattern}' && git config --local --unset-all '${configKey}' || :"`, true);
|
|
}
|
|
/**
|
|
* Removes includeIf entries that point to git-credentials-*.config files.
|
|
* @param configPath Optional path to a specific git config file to operate on
|
|
* @returns Array of unique credentials config file paths that were found and removed
|
|
*/
|
|
async removeIncludeIfCredentials(configPath) {
|
|
const credentialsPaths = new Set();
|
|
try {
|
|
// Get all includeIf.gitdir keys
|
|
const keys = await this.git.tryGetConfigKeys('^includeIf\\.gitdir:', false, // globalConfig?
|
|
configPath);
|
|
for (const key of keys) {
|
|
// Get all values for this key
|
|
const values = await this.git.tryGetConfigValues(key, false, // globalConfig?
|
|
configPath);
|
|
if (values.length > 0) {
|
|
// Remove only values that match git-credentials-<uuid>.config pattern
|
|
for (const value of values) {
|
|
if (this.testCredentialsConfigPath(value)) {
|
|
credentialsPaths.add(value);
|
|
await this.git.tryConfigUnsetValue(key, value, false, configPath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (err) {
|
|
// Ignore errors - this is cleanup code
|
|
if (configPath) {
|
|
core_debug(`Error during includeIf cleanup for ${configPath}: ${err}`);
|
|
}
|
|
else {
|
|
core_debug(`Error during includeIf cleanup: ${err}`);
|
|
}
|
|
}
|
|
return Array.from(credentialsPaths);
|
|
}
|
|
/**
|
|
* Tests if a path matches the git-credentials-*.config pattern.
|
|
* @param path The path to test
|
|
* @returns True if the path matches the credentials config pattern
|
|
*/
|
|
testCredentialsConfigPath(path) {
|
|
return /git-credentials-[0-9a-f-]+\.config$/i.test(path);
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/retry-helper.ts
|
|
|
|
const defaultMaxAttempts = 3;
|
|
const defaultMinSeconds = 10;
|
|
const defaultMaxSeconds = 20;
|
|
class retry_helper_RetryHelper {
|
|
maxAttempts;
|
|
minSeconds;
|
|
maxSeconds;
|
|
constructor(maxAttempts = defaultMaxAttempts, minSeconds = defaultMinSeconds, maxSeconds = defaultMaxSeconds) {
|
|
this.maxAttempts = maxAttempts;
|
|
this.minSeconds = Math.floor(minSeconds);
|
|
this.maxSeconds = Math.floor(maxSeconds);
|
|
if (this.minSeconds > this.maxSeconds) {
|
|
throw new Error('min seconds should be less than or equal to max seconds');
|
|
}
|
|
}
|
|
async execute(action) {
|
|
let attempt = 1;
|
|
while (attempt < this.maxAttempts) {
|
|
// Try
|
|
try {
|
|
return await action();
|
|
}
|
|
catch (err) {
|
|
info(err?.message);
|
|
}
|
|
// Sleep
|
|
const seconds = this.getSleepAmount();
|
|
info(`Waiting ${seconds} seconds before trying again`);
|
|
await this.sleep(seconds);
|
|
attempt++;
|
|
}
|
|
// Last attempt
|
|
return await action();
|
|
}
|
|
getSleepAmount() {
|
|
return (Math.floor(Math.random() * (this.maxSeconds - this.minSeconds + 1)) +
|
|
this.minSeconds);
|
|
}
|
|
async sleep(seconds) {
|
|
return new Promise(resolve => setTimeout(resolve, seconds * 1000));
|
|
}
|
|
}
|
|
async function execute(action) {
|
|
const retryHelper = new retry_helper_RetryHelper();
|
|
return await retryHelper.execute(action);
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/git-version.ts
|
|
class GitVersion {
|
|
major = NaN;
|
|
minor = NaN;
|
|
patch = NaN;
|
|
/**
|
|
* Used for comparing the version of git and git-lfs against the minimum required version
|
|
* @param version the version string, e.g. 1.2 or 1.2.3
|
|
*/
|
|
constructor(version) {
|
|
if (version) {
|
|
const match = version.match(/^(\d+)\.(\d+)(\.(\d+))?$/);
|
|
if (match) {
|
|
this.major = Number(match[1]);
|
|
this.minor = Number(match[2]);
|
|
if (match[4]) {
|
|
this.patch = Number(match[4]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Compares the instance against a minimum required version
|
|
* @param minimum Minimum version
|
|
*/
|
|
checkMinimum(minimum) {
|
|
if (!minimum.isValid()) {
|
|
throw new Error('Arg minimum is not a valid version');
|
|
}
|
|
// Major is insufficient
|
|
if (this.major < minimum.major) {
|
|
return false;
|
|
}
|
|
// Major is equal
|
|
if (this.major === minimum.major) {
|
|
// Minor is insufficient
|
|
if (this.minor < minimum.minor) {
|
|
return false;
|
|
}
|
|
// Minor is equal
|
|
if (this.minor === minimum.minor) {
|
|
// Patch is insufficient
|
|
if (this.patch && this.patch < (minimum.patch || 0)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Indicates whether the instance was constructed from a valid version string
|
|
*/
|
|
isValid() {
|
|
return !isNaN(this.major);
|
|
}
|
|
/**
|
|
* Returns the version as a string, e.g. 1.2 or 1.2.3
|
|
*/
|
|
toString() {
|
|
let result = '';
|
|
if (this.isValid()) {
|
|
result = `${this.major}.${this.minor}`;
|
|
if (!isNaN(this.patch)) {
|
|
result += `.${this.patch}`;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/git-command-manager.ts
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Auth header not supported before 2.9
|
|
// Wire protocol v2 not supported before 2.18
|
|
// sparse-checkout not [well-]supported before 2.28 (see https://github.com/actions/checkout/issues/1386)
|
|
const MinimumGitVersion = new GitVersion('2.18');
|
|
const MinimumGitSparseCheckoutVersion = new GitVersion('2.28');
|
|
async function createCommandManager(workingDirectory, lfs, doSparseCheckout) {
|
|
return await GitCommandManager.createCommandManager(workingDirectory, lfs, doSparseCheckout);
|
|
}
|
|
class GitCommandManager {
|
|
gitEnv = {
|
|
GIT_TERMINAL_PROMPT: '0', // Disable git prompt
|
|
GCM_INTERACTIVE: 'Never' // Disable prompting for git credential manager
|
|
};
|
|
gitPath = '';
|
|
lfs = false;
|
|
doSparseCheckout = false;
|
|
workingDirectory = '';
|
|
gitVersion = new GitVersion();
|
|
// Private constructor; use createCommandManager()
|
|
constructor() { }
|
|
async branchDelete(remote, branch) {
|
|
const args = ['branch', '--delete', '--force'];
|
|
if (remote) {
|
|
args.push('--remote');
|
|
}
|
|
args.push(branch);
|
|
await this.execGit(args);
|
|
}
|
|
async branchExists(remote, pattern) {
|
|
const args = ['branch', '--list'];
|
|
if (remote) {
|
|
args.push('--remote');
|
|
}
|
|
args.push(pattern);
|
|
const output = await this.execGit(args);
|
|
return !!output.stdout.trim();
|
|
}
|
|
async branchList(remote) {
|
|
const result = [];
|
|
// Note, this implementation uses "rev-parse --symbolic-full-name" because the output from
|
|
// "branch --list" is more difficult when in a detached HEAD state.
|
|
// TODO(https://github.com/actions/checkout/issues/786): this implementation uses
|
|
// "rev-parse --symbolic-full-name" because there is a bug
|
|
// in Git 2.18 that causes "rev-parse --symbolic" to output symbolic full names. When
|
|
// 2.18 is no longer supported, we can switch back to --symbolic.
|
|
const args = ['rev-parse', '--symbolic-full-name'];
|
|
if (remote) {
|
|
args.push('--remotes=origin');
|
|
}
|
|
else {
|
|
args.push('--branches');
|
|
}
|
|
const stderr = [];
|
|
const errline = [];
|
|
const stdout = [];
|
|
const stdline = [];
|
|
const listeners = {
|
|
stderr: (data) => {
|
|
stderr.push(data.toString());
|
|
},
|
|
errline: (data) => {
|
|
errline.push(data.toString());
|
|
},
|
|
stdout: (data) => {
|
|
stdout.push(data.toString());
|
|
},
|
|
stdline: (data) => {
|
|
stdline.push(data.toString());
|
|
}
|
|
};
|
|
// Suppress the output in order to avoid flooding annotations with innocuous errors.
|
|
await this.execGit(args, false, true, listeners);
|
|
core_debug(`stderr callback is: ${stderr}`);
|
|
core_debug(`errline callback is: ${errline}`);
|
|
core_debug(`stdout callback is: ${stdout}`);
|
|
core_debug(`stdline callback is: ${stdline}`);
|
|
for (let branch of stdline) {
|
|
branch = branch.trim();
|
|
if (!branch) {
|
|
continue;
|
|
}
|
|
if (branch.startsWith('refs/heads/')) {
|
|
branch = branch.substring('refs/heads/'.length);
|
|
}
|
|
else if (branch.startsWith('refs/remotes/')) {
|
|
branch = branch.substring('refs/remotes/'.length);
|
|
}
|
|
result.push(branch);
|
|
}
|
|
return result;
|
|
}
|
|
async disableSparseCheckout() {
|
|
await this.execGit(['sparse-checkout', 'disable']);
|
|
// Disabling 'sparse-checkout` leaves behind an undesirable side-effect in config (even in a pristine environment).
|
|
await this.tryConfigUnset('extensions.worktreeConfig', false);
|
|
}
|
|
async sparseCheckout(sparseCheckout) {
|
|
await this.execGit(['sparse-checkout', 'set', ...sparseCheckout]);
|
|
}
|
|
async sparseCheckoutNonConeMode(sparseCheckout) {
|
|
await this.execGit(['config', 'core.sparseCheckout', 'true']);
|
|
const output = await this.execGit([
|
|
'rev-parse',
|
|
'--git-path',
|
|
'info/sparse-checkout'
|
|
]);
|
|
const sparseCheckoutPath = external_path_namespaceObject.join(this.workingDirectory, output.stdout.trimRight());
|
|
await external_fs_namespaceObject.promises.appendFile(sparseCheckoutPath, `\n${sparseCheckout.join('\n')}\n`);
|
|
}
|
|
async checkout(ref, startPoint) {
|
|
const args = ['checkout', '--progress', '--force'];
|
|
if (startPoint) {
|
|
args.push('-B', ref, startPoint);
|
|
}
|
|
else {
|
|
args.push(ref);
|
|
}
|
|
await this.execGit(args);
|
|
}
|
|
async checkoutDetach() {
|
|
const args = ['checkout', '--detach'];
|
|
await this.execGit(args);
|
|
}
|
|
async config(configKey, configValue, globalConfig, add, configFile) {
|
|
const args = ['config'];
|
|
if (configFile) {
|
|
args.push('--file', configFile);
|
|
}
|
|
else {
|
|
args.push(globalConfig ? '--global' : '--local');
|
|
}
|
|
if (add) {
|
|
args.push('--add');
|
|
}
|
|
args.push(...[configKey, configValue]);
|
|
await this.execGit(args);
|
|
}
|
|
async configExists(configKey, globalConfig) {
|
|
const pattern = regexp_helper_escape(configKey);
|
|
const output = await this.execGit([
|
|
'config',
|
|
globalConfig ? '--global' : '--local',
|
|
'--name-only',
|
|
'--get-regexp',
|
|
pattern
|
|
], true);
|
|
return output.exitCode === 0;
|
|
}
|
|
async fetch(refSpec, options) {
|
|
const args = ['-c', 'protocol.version=2', 'fetch'];
|
|
// Always use --no-tags for explicit control over tag fetching
|
|
// Tags are fetched explicitly via refspec when needed
|
|
args.push('--no-tags');
|
|
args.push('--prune', '--no-recurse-submodules');
|
|
if (options.showProgress) {
|
|
args.push('--progress');
|
|
}
|
|
if (options.filter) {
|
|
args.push(`--filter=${options.filter}`);
|
|
}
|
|
if (options.fetchDepth && options.fetchDepth > 0) {
|
|
args.push(`--depth=${options.fetchDepth}`);
|
|
}
|
|
else if (fileExistsSync(external_path_namespaceObject.join(this.workingDirectory, '.git', 'shallow'))) {
|
|
args.push('--unshallow');
|
|
}
|
|
args.push('origin');
|
|
for (const arg of refSpec) {
|
|
args.push(arg);
|
|
}
|
|
const that = this;
|
|
await execute(async () => {
|
|
await that.execGit(args);
|
|
});
|
|
}
|
|
async getDefaultBranch(repositoryUrl) {
|
|
let output;
|
|
await execute(async () => {
|
|
output = await this.execGit([
|
|
'ls-remote',
|
|
'--quiet',
|
|
'--exit-code',
|
|
'--symref',
|
|
repositoryUrl,
|
|
'HEAD'
|
|
]);
|
|
});
|
|
if (output) {
|
|
// Satisfy compiler, will always be set
|
|
for (let line of output.stdout.trim().split('\n')) {
|
|
line = line.trim();
|
|
if (line.startsWith('ref:') || line.endsWith('HEAD')) {
|
|
return line
|
|
.substr('ref:'.length, line.length - 'ref:'.length - 'HEAD'.length)
|
|
.trim();
|
|
}
|
|
}
|
|
}
|
|
throw new Error('Unexpected output when retrieving default branch');
|
|
}
|
|
async getSubmoduleConfigPaths(recursive) {
|
|
// Get submodule config file paths.
|
|
// Use `--show-origin` to get the config file path for each submodule.
|
|
const output = await this.submoduleForeach(`git config --local --show-origin --name-only --get-regexp remote.origin.url`, recursive);
|
|
// Extract config file paths from the output (lines starting with "file:").
|
|
const configPaths = output.match(/(?<=(^|\n)file:)[^\t]+(?=\tremote\.origin\.url)/g) || [];
|
|
return configPaths;
|
|
}
|
|
getWorkingDirectory() {
|
|
return this.workingDirectory;
|
|
}
|
|
async init(objectFormat) {
|
|
const args = ['init'];
|
|
if (objectFormat === 'sha256') {
|
|
args.push('--object-format=sha256');
|
|
}
|
|
args.push(this.workingDirectory);
|
|
await this.execGit(args);
|
|
}
|
|
async isDetached() {
|
|
// Note, "branch --show-current" would be simpler but isn't available until Git 2.22
|
|
const output = await this.execGit(['rev-parse', '--symbolic-full-name', '--verify', '--quiet', 'HEAD'], true);
|
|
return !output.stdout.trim().startsWith('refs/heads/');
|
|
}
|
|
async lfsFetch(ref) {
|
|
const args = ['lfs', 'fetch', 'origin', ref];
|
|
const that = this;
|
|
await execute(async () => {
|
|
await that.execGit(args);
|
|
});
|
|
}
|
|
async lfsInstall() {
|
|
await this.execGit(['lfs', 'install', '--local']);
|
|
}
|
|
async log1(format) {
|
|
const args = format ? ['log', '-1', format] : ['log', '-1'];
|
|
const silent = format ? false : true;
|
|
const output = await this.execGit(args, false, silent);
|
|
return output.stdout;
|
|
}
|
|
async remoteAdd(remoteName, remoteUrl) {
|
|
await this.execGit(['remote', 'add', remoteName, remoteUrl]);
|
|
}
|
|
removeEnvironmentVariable(name) {
|
|
delete this.gitEnv[name];
|
|
}
|
|
/**
|
|
* Resolves a ref to a SHA. For a branch or lightweight tag, the commit SHA is returned.
|
|
* For an annotated tag, the tag SHA is returned.
|
|
* @param {string} ref For example: 'refs/heads/main' or '/refs/tags/v1'
|
|
* @returns {Promise<string>}
|
|
*/
|
|
async revParse(ref) {
|
|
const output = await this.execGit(['rev-parse', ref]);
|
|
return output.stdout.trim();
|
|
}
|
|
setEnvironmentVariable(name, value) {
|
|
this.gitEnv[name] = value;
|
|
}
|
|
async shaExists(sha) {
|
|
const args = ['rev-parse', '--verify', '--quiet', `${sha}^{object}`];
|
|
const output = await this.execGit(args, true);
|
|
return output.exitCode === 0;
|
|
}
|
|
async submoduleForeach(command, recursive) {
|
|
const args = ['submodule', 'foreach'];
|
|
if (recursive) {
|
|
args.push('--recursive');
|
|
}
|
|
args.push(command);
|
|
const output = await this.execGit(args);
|
|
return output.stdout;
|
|
}
|
|
async submoduleSync(recursive) {
|
|
const args = ['submodule', 'sync'];
|
|
if (recursive) {
|
|
args.push('--recursive');
|
|
}
|
|
await this.execGit(args);
|
|
}
|
|
async submoduleUpdate(fetchDepth, recursive) {
|
|
const args = ['-c', 'protocol.version=2'];
|
|
args.push('submodule', 'update', '--init', '--force');
|
|
if (fetchDepth > 0) {
|
|
args.push(`--depth=${fetchDepth}`);
|
|
}
|
|
if (recursive) {
|
|
args.push('--recursive');
|
|
}
|
|
await this.execGit(args);
|
|
}
|
|
async submoduleStatus() {
|
|
const output = await this.execGit(['submodule', 'status'], true);
|
|
core_debug(output.stdout);
|
|
return output.exitCode === 0;
|
|
}
|
|
async tagExists(pattern) {
|
|
const output = await this.execGit(['tag', '--list', pattern]);
|
|
return !!output.stdout.trim();
|
|
}
|
|
async tryClean() {
|
|
const output = await this.execGit(['clean', '-ffdx'], true);
|
|
return output.exitCode === 0;
|
|
}
|
|
async tryConfigUnset(configKey, globalConfig) {
|
|
const output = await this.execGit([
|
|
'config',
|
|
globalConfig ? '--global' : '--local',
|
|
'--unset-all',
|
|
configKey
|
|
], true);
|
|
return output.exitCode === 0;
|
|
}
|
|
async tryConfigUnsetValue(configKey, configValue, globalConfig, configFile) {
|
|
const args = ['config'];
|
|
if (configFile) {
|
|
args.push('--file', configFile);
|
|
}
|
|
else {
|
|
args.push(globalConfig ? '--global' : '--local');
|
|
}
|
|
args.push('--unset', configKey, configValue);
|
|
const output = await this.execGit(args, true);
|
|
return output.exitCode === 0;
|
|
}
|
|
async tryDisableAutomaticGarbageCollection() {
|
|
const output = await this.execGit(['config', '--local', 'gc.auto', '0'], true);
|
|
return output.exitCode === 0;
|
|
}
|
|
async tryGetFetchUrl() {
|
|
const output = await this.execGit(['config', '--local', '--get', 'remote.origin.url'], true);
|
|
if (output.exitCode !== 0) {
|
|
return '';
|
|
}
|
|
const stdout = output.stdout.trim();
|
|
if (stdout.includes('\n')) {
|
|
return '';
|
|
}
|
|
return stdout;
|
|
}
|
|
async tryGetConfigValues(configKey, globalConfig, configFile) {
|
|
const args = ['config'];
|
|
if (configFile) {
|
|
args.push('--file', configFile);
|
|
}
|
|
else {
|
|
args.push(globalConfig ? '--global' : '--local');
|
|
}
|
|
args.push('--get-all', configKey);
|
|
const output = await this.execGit(args, true);
|
|
if (output.exitCode !== 0) {
|
|
return [];
|
|
}
|
|
return output.stdout
|
|
.trim()
|
|
.split('\n')
|
|
.filter(value => value.trim());
|
|
}
|
|
async tryGetConfigKeys(pattern, globalConfig, configFile) {
|
|
const args = ['config'];
|
|
if (configFile) {
|
|
args.push('--file', configFile);
|
|
}
|
|
else {
|
|
args.push(globalConfig ? '--global' : '--local');
|
|
}
|
|
args.push('--name-only', '--get-regexp', pattern);
|
|
const output = await this.execGit(args, true);
|
|
if (output.exitCode !== 0) {
|
|
return [];
|
|
}
|
|
return output.stdout
|
|
.trim()
|
|
.split('\n')
|
|
.filter(key => key.trim());
|
|
}
|
|
async tryReset() {
|
|
const output = await this.execGit(['reset', '--hard', 'HEAD'], true);
|
|
return output.exitCode === 0;
|
|
}
|
|
async version() {
|
|
return this.gitVersion;
|
|
}
|
|
static async createCommandManager(workingDirectory, lfs, doSparseCheckout) {
|
|
const result = new GitCommandManager();
|
|
await result.initializeCommandManager(workingDirectory, lfs, doSparseCheckout);
|
|
return result;
|
|
}
|
|
async execGit(args, allowAllExitCodes = false, silent = false, customListeners = {}) {
|
|
directoryExistsSync(this.workingDirectory, true);
|
|
const result = new GitOutput();
|
|
const env = {};
|
|
for (const key of Object.keys(process.env)) {
|
|
env[key] = process.env[key];
|
|
}
|
|
for (const key of Object.keys(this.gitEnv)) {
|
|
env[key] = this.gitEnv[key];
|
|
}
|
|
const defaultListener = {
|
|
stdout: (data) => {
|
|
stdout.push(data.toString());
|
|
}
|
|
};
|
|
const mergedListeners = { ...defaultListener, ...customListeners };
|
|
const stdout = [];
|
|
const options = {
|
|
cwd: this.workingDirectory,
|
|
env,
|
|
silent,
|
|
ignoreReturnCode: allowAllExitCodes,
|
|
listeners: mergedListeners
|
|
};
|
|
result.exitCode = await exec_exec(`"${this.gitPath}"`, args, options);
|
|
result.stdout = stdout.join('');
|
|
core_debug(result.exitCode.toString());
|
|
core_debug(result.stdout);
|
|
return result;
|
|
}
|
|
async initializeCommandManager(workingDirectory, lfs, doSparseCheckout) {
|
|
this.workingDirectory = workingDirectory;
|
|
// Git-lfs will try to pull down assets if any of the local/user/system setting exist.
|
|
// If the user didn't enable `LFS` in their pipeline definition, disable LFS fetch/checkout.
|
|
this.lfs = lfs;
|
|
if (!this.lfs) {
|
|
this.gitEnv['GIT_LFS_SKIP_SMUDGE'] = '1';
|
|
}
|
|
this.gitPath = await which('git', true);
|
|
// Git version
|
|
core_debug('Getting git version');
|
|
this.gitVersion = new GitVersion();
|
|
let gitOutput = await this.execGit(['version']);
|
|
let stdout = gitOutput.stdout.trim();
|
|
if (!stdout.includes('\n')) {
|
|
const match = stdout.match(/\d+\.\d+(\.\d+)?/);
|
|
if (match) {
|
|
this.gitVersion = new GitVersion(match[0]);
|
|
}
|
|
}
|
|
if (!this.gitVersion.isValid()) {
|
|
throw new Error('Unable to determine git version');
|
|
}
|
|
// Minimum git version
|
|
if (!this.gitVersion.checkMinimum(MinimumGitVersion)) {
|
|
throw new Error(`Minimum required git version is ${MinimumGitVersion}. Your git ('${this.gitPath}') is ${this.gitVersion}`);
|
|
}
|
|
if (this.lfs) {
|
|
// Git-lfs version
|
|
core_debug('Getting git-lfs version');
|
|
let gitLfsVersion = new GitVersion();
|
|
const gitLfsPath = await which('git-lfs', true);
|
|
gitOutput = await this.execGit(['lfs', 'version']);
|
|
stdout = gitOutput.stdout.trim();
|
|
if (!stdout.includes('\n')) {
|
|
const match = stdout.match(/\d+\.\d+(\.\d+)?/);
|
|
if (match) {
|
|
gitLfsVersion = new GitVersion(match[0]);
|
|
}
|
|
}
|
|
if (!gitLfsVersion.isValid()) {
|
|
throw new Error('Unable to determine git-lfs version');
|
|
}
|
|
// Minimum git-lfs version
|
|
// Note:
|
|
// - Auth header not supported before 2.1
|
|
const minimumGitLfsVersion = new GitVersion('2.1');
|
|
if (!gitLfsVersion.checkMinimum(minimumGitLfsVersion)) {
|
|
throw new Error(`Minimum required git-lfs version is ${minimumGitLfsVersion}. Your git-lfs ('${gitLfsPath}') is ${gitLfsVersion}`);
|
|
}
|
|
}
|
|
this.doSparseCheckout = doSparseCheckout;
|
|
if (this.doSparseCheckout) {
|
|
if (!this.gitVersion.checkMinimum(MinimumGitSparseCheckoutVersion)) {
|
|
throw new Error(`Minimum Git version required for sparse checkout is ${MinimumGitSparseCheckoutVersion}. Your git ('${this.gitPath}') is ${this.gitVersion}`);
|
|
}
|
|
}
|
|
// Set the user agent
|
|
let gitHttpUserAgent = `git/${this.gitVersion} (github-actions-checkout)`;
|
|
// Append orchestration ID if set
|
|
const orchId = process.env['ACTIONS_ORCHESTRATION_ID'];
|
|
if (orchId) {
|
|
// Sanitize the orchestration ID to ensure it contains only valid characters
|
|
// Valid characters: 0-9, a-z, _, -, .
|
|
const sanitizedId = orchId.replace(/[^a-z0-9_.-]/gi, '_');
|
|
if (sanitizedId) {
|
|
gitHttpUserAgent = `${gitHttpUserAgent} actions_orchestration_id/${sanitizedId}`;
|
|
}
|
|
}
|
|
core_debug(`Set git useragent to: ${gitHttpUserAgent}`);
|
|
this.gitEnv['GIT_HTTP_USER_AGENT'] = gitHttpUserAgent;
|
|
}
|
|
}
|
|
class GitOutput {
|
|
stdout = '';
|
|
exitCode = 0;
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/git-directory-helper.ts
|
|
|
|
|
|
|
|
|
|
|
|
|
|
async function prepareExistingDirectory(git, repositoryPath, repositoryUrl, clean, ref) {
|
|
external_assert_.ok(repositoryPath, 'Expected repositoryPath to be defined');
|
|
external_assert_.ok(repositoryUrl, 'Expected repositoryUrl to be defined');
|
|
// Indicates whether to delete the directory contents
|
|
let remove = false;
|
|
// Check whether using git or REST API
|
|
if (!git) {
|
|
remove = true;
|
|
}
|
|
// Fetch URL does not match
|
|
else if (!directoryExistsSync(external_path_namespaceObject.join(repositoryPath, '.git')) ||
|
|
repositoryUrl !== (await git.tryGetFetchUrl())) {
|
|
remove = true;
|
|
}
|
|
else {
|
|
// Delete any index.lock and shallow.lock left by a previously canceled run or crashed git process
|
|
const lockPaths = [
|
|
external_path_namespaceObject.join(repositoryPath, '.git', 'index.lock'),
|
|
external_path_namespaceObject.join(repositoryPath, '.git', 'shallow.lock')
|
|
];
|
|
for (const lockPath of lockPaths) {
|
|
try {
|
|
await rmRF(lockPath);
|
|
}
|
|
catch (error) {
|
|
core_debug(`Unable to delete '${lockPath}'. ${error?.message ?? error}`);
|
|
}
|
|
}
|
|
try {
|
|
startGroup('Removing previously created refs, to avoid conflicts');
|
|
// Checkout detached HEAD
|
|
if (!(await git.isDetached())) {
|
|
await git.checkoutDetach();
|
|
}
|
|
// Remove all refs/heads/*
|
|
let branches = await git.branchList(false);
|
|
for (const branch of branches) {
|
|
await git.branchDelete(false, branch);
|
|
}
|
|
// Remove any conflicting refs/remotes/origin/*
|
|
// Example 1: Consider ref is refs/heads/foo and previously fetched refs/remotes/origin/foo/bar
|
|
// Example 2: Consider ref is refs/heads/foo/bar and previously fetched refs/remotes/origin/foo
|
|
if (ref) {
|
|
ref = ref.startsWith('refs/') ? ref : `refs/heads/${ref}`;
|
|
if (ref.startsWith('refs/heads/')) {
|
|
const upperName1 = ref.toUpperCase().substr('REFS/HEADS/'.length);
|
|
const upperName1Slash = `${upperName1}/`;
|
|
branches = await git.branchList(true);
|
|
for (const branch of branches) {
|
|
const upperName2 = branch.substr('origin/'.length).toUpperCase();
|
|
const upperName2Slash = `${upperName2}/`;
|
|
if (upperName1.startsWith(upperName2Slash) ||
|
|
upperName2.startsWith(upperName1Slash)) {
|
|
await git.branchDelete(true, branch);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
endGroup();
|
|
// Check for submodules and delete any existing files if submodules are present
|
|
if (!(await git.submoduleStatus())) {
|
|
remove = true;
|
|
info('Bad Submodules found, removing existing files');
|
|
}
|
|
// Clean
|
|
if (clean) {
|
|
startGroup('Cleaning the repository');
|
|
if (!(await git.tryClean())) {
|
|
core_debug(`The clean command failed. This might be caused by: 1) path too long, 2) permission issue, or 3) file in use. For further investigation, manually run 'git clean -ffdx' on the directory '${repositoryPath}'.`);
|
|
remove = true;
|
|
}
|
|
else if (!(await git.tryReset())) {
|
|
remove = true;
|
|
}
|
|
endGroup();
|
|
if (remove) {
|
|
warning(`Unable to clean or reset the repository. The repository will be recreated instead.`);
|
|
}
|
|
}
|
|
}
|
|
catch (error) {
|
|
warning(`Unable to prepare the existing repository. The repository will be recreated instead.`);
|
|
remove = true;
|
|
}
|
|
}
|
|
if (remove) {
|
|
// Delete the contents of the directory. Don't delete the directory itself
|
|
// since it might be the current working directory.
|
|
info(`Deleting the contents of '${repositoryPath}'`);
|
|
for (const file of await external_fs_namespaceObject.promises.readdir(repositoryPath)) {
|
|
await rmRF(external_path_namespaceObject.join(repositoryPath, file));
|
|
}
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/github/lib/context.js
|
|
|
|
|
|
class Context {
|
|
/**
|
|
* Hydrate the context from the environment
|
|
*/
|
|
constructor() {
|
|
var _a, _b, _c;
|
|
this.payload = {};
|
|
if (process.env.GITHUB_EVENT_PATH) {
|
|
if ((0,external_fs_namespaceObject.existsSync)(process.env.GITHUB_EVENT_PATH)) {
|
|
this.payload = JSON.parse((0,external_fs_namespaceObject.readFileSync)(process.env.GITHUB_EVENT_PATH, { encoding: 'utf8' }));
|
|
}
|
|
else {
|
|
const path = process.env.GITHUB_EVENT_PATH;
|
|
process.stdout.write(`GITHUB_EVENT_PATH ${path} does not exist${external_os_namespaceObject.EOL}`);
|
|
}
|
|
}
|
|
this.eventName = process.env.GITHUB_EVENT_NAME;
|
|
this.sha = process.env.GITHUB_SHA;
|
|
this.ref = process.env.GITHUB_REF;
|
|
this.workflow = process.env.GITHUB_WORKFLOW;
|
|
this.action = process.env.GITHUB_ACTION;
|
|
this.actor = process.env.GITHUB_ACTOR;
|
|
this.job = process.env.GITHUB_JOB;
|
|
this.runAttempt = parseInt(process.env.GITHUB_RUN_ATTEMPT, 10);
|
|
this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER, 10);
|
|
this.runId = parseInt(process.env.GITHUB_RUN_ID, 10);
|
|
this.apiUrl = (_a = process.env.GITHUB_API_URL) !== null && _a !== void 0 ? _a : `https://api.github.com`;
|
|
this.serverUrl = (_b = process.env.GITHUB_SERVER_URL) !== null && _b !== void 0 ? _b : `https://github.com`;
|
|
this.graphqlUrl =
|
|
(_c = process.env.GITHUB_GRAPHQL_URL) !== null && _c !== void 0 ? _c : `https://api.github.com/graphql`;
|
|
}
|
|
get issue() {
|
|
const payload = this.payload;
|
|
return Object.assign(Object.assign({}, this.repo), { number: (payload.issue || payload.pull_request || payload).number });
|
|
}
|
|
get repo() {
|
|
if (process.env.GITHUB_REPOSITORY) {
|
|
const [owner, repo] = process.env.GITHUB_REPOSITORY.split('/');
|
|
return { owner, repo };
|
|
}
|
|
if (this.payload.repository) {
|
|
return {
|
|
owner: this.payload.repository.owner.login,
|
|
repo: this.payload.repository.name
|
|
};
|
|
}
|
|
throw new Error("context.repo requires a GITHUB_REPOSITORY environment variable like 'owner/repo'");
|
|
}
|
|
}
|
|
//# sourceMappingURL=context.js.map
|
|
// EXTERNAL MODULE: ./node_modules/@actions/github/node_modules/@actions/http-client/lib/index.js
|
|
var lib = __nccwpck_require__(9659);
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/github/lib/internal/utils.js
|
|
var utils_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
|
|
function getAuthString(token, options) {
|
|
if (!token && !options.auth) {
|
|
throw new Error('Parameter token or opts.auth is required');
|
|
}
|
|
else if (token && options.auth) {
|
|
throw new Error('Parameters token and opts.auth may not both be specified');
|
|
}
|
|
return typeof options.auth === 'string' ? options.auth : `token ${token}`;
|
|
}
|
|
function getProxyAgent(destinationUrl) {
|
|
const hc = new lib.HttpClient();
|
|
return hc.getAgent(destinationUrl);
|
|
}
|
|
function getProxyAgentDispatcher(destinationUrl) {
|
|
const hc = new lib.HttpClient();
|
|
return hc.getAgentDispatcher(destinationUrl);
|
|
}
|
|
function getProxyFetch(destinationUrl) {
|
|
const httpDispatcher = getProxyAgentDispatcher(destinationUrl);
|
|
const proxyFetch = (url, opts) => utils_awaiter(this, void 0, void 0, function* () {
|
|
return (0,undici.fetch)(url, Object.assign(Object.assign({}, opts), { dispatcher: httpDispatcher }));
|
|
});
|
|
return proxyFetch;
|
|
}
|
|
function getApiBaseUrl() {
|
|
return process.env['GITHUB_API_URL'] || 'https://api.github.com';
|
|
}
|
|
function getUserAgentWithOrchestrationId(baseUserAgent) {
|
|
var _a;
|
|
const orchId = (_a = process.env['ACTIONS_ORCHESTRATION_ID']) === null || _a === void 0 ? void 0 : _a.trim();
|
|
if (orchId) {
|
|
const sanitizedId = orchId.replace(/[^a-z0-9_.-]/gi, '_');
|
|
const tag = `actions_orchestration_id/${sanitizedId}`;
|
|
if (baseUserAgent === null || baseUserAgent === void 0 ? void 0 : baseUserAgent.includes(tag))
|
|
return baseUserAgent;
|
|
const ua = baseUserAgent ? `${baseUserAgent} ` : '';
|
|
return `${ua}${tag}`;
|
|
}
|
|
return baseUserAgent;
|
|
}
|
|
//# sourceMappingURL=utils.js.map
|
|
;// CONCATENATED MODULE: ./node_modules/universal-user-agent/index.js
|
|
function getUserAgent() {
|
|
if (typeof navigator === "object" && "userAgent" in navigator) {
|
|
return navigator.userAgent;
|
|
}
|
|
|
|
if (typeof process === "object" && process.version !== undefined) {
|
|
return `Node.js/${process.version.substr(1)} (${process.platform}; ${
|
|
process.arch
|
|
})`;
|
|
}
|
|
|
|
return "<environment undetectable>";
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/before-after-hook/lib/register.js
|
|
// @ts-check
|
|
|
|
function register(state, name, method, options) {
|
|
if (typeof method !== "function") {
|
|
throw new Error("method for before hook must be a function");
|
|
}
|
|
|
|
if (!options) {
|
|
options = {};
|
|
}
|
|
|
|
if (Array.isArray(name)) {
|
|
return name.reverse().reduce((callback, name) => {
|
|
return register.bind(null, state, name, callback, options);
|
|
}, method)();
|
|
}
|
|
|
|
return Promise.resolve().then(() => {
|
|
if (!state.registry[name]) {
|
|
return method(options);
|
|
}
|
|
|
|
return state.registry[name].reduce((method, registered) => {
|
|
return registered.hook.bind(null, method, options);
|
|
}, method)();
|
|
});
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/before-after-hook/lib/add.js
|
|
// @ts-check
|
|
|
|
function addHook(state, kind, name, hook) {
|
|
const orig = hook;
|
|
if (!state.registry[name]) {
|
|
state.registry[name] = [];
|
|
}
|
|
|
|
if (kind === "before") {
|
|
hook = (method, options) => {
|
|
return Promise.resolve()
|
|
.then(orig.bind(null, options))
|
|
.then(method.bind(null, options));
|
|
};
|
|
}
|
|
|
|
if (kind === "after") {
|
|
hook = (method, options) => {
|
|
let result;
|
|
return Promise.resolve()
|
|
.then(method.bind(null, options))
|
|
.then((result_) => {
|
|
result = result_;
|
|
return orig(result, options);
|
|
})
|
|
.then(() => {
|
|
return result;
|
|
});
|
|
};
|
|
}
|
|
|
|
if (kind === "error") {
|
|
hook = (method, options) => {
|
|
return Promise.resolve()
|
|
.then(method.bind(null, options))
|
|
.catch((error) => {
|
|
return orig(error, options);
|
|
});
|
|
};
|
|
}
|
|
|
|
state.registry[name].push({
|
|
hook: hook,
|
|
orig: orig,
|
|
});
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/before-after-hook/lib/remove.js
|
|
// @ts-check
|
|
|
|
function removeHook(state, name, method) {
|
|
if (!state.registry[name]) {
|
|
return;
|
|
}
|
|
|
|
const index = state.registry[name]
|
|
.map((registered) => {
|
|
return registered.orig;
|
|
})
|
|
.indexOf(method);
|
|
|
|
if (index === -1) {
|
|
return;
|
|
}
|
|
|
|
state.registry[name].splice(index, 1);
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/before-after-hook/index.js
|
|
// @ts-check
|
|
|
|
|
|
|
|
|
|
|
|
// bind with array of arguments: https://stackoverflow.com/a/21792913
|
|
const bind = Function.bind;
|
|
const bindable = bind.bind(bind);
|
|
|
|
function bindApi(hook, state, name) {
|
|
const removeHookRef = bindable(removeHook, null).apply(
|
|
null,
|
|
name ? [state, name] : [state]
|
|
);
|
|
hook.api = { remove: removeHookRef };
|
|
hook.remove = removeHookRef;
|
|
["before", "error", "after", "wrap"].forEach((kind) => {
|
|
const args = name ? [state, kind, name] : [state, kind];
|
|
hook[kind] = hook.api[kind] = bindable(addHook, null).apply(null, args);
|
|
});
|
|
}
|
|
|
|
function Singular() {
|
|
const singularHookName = Symbol("Singular");
|
|
const singularHookState = {
|
|
registry: {},
|
|
};
|
|
const singularHook = register.bind(null, singularHookState, singularHookName);
|
|
bindApi(singularHook, singularHookState, singularHookName);
|
|
return singularHook;
|
|
}
|
|
|
|
function Collection() {
|
|
const state = {
|
|
registry: {},
|
|
};
|
|
|
|
const hook = register.bind(null, state);
|
|
bindApi(hook, state);
|
|
|
|
return hook;
|
|
}
|
|
|
|
/* harmony default export */ const before_after_hook = ({ Singular, Collection });
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@octokit/endpoint/dist-bundle/index.js
|
|
// pkg/dist-src/defaults.js
|
|
|
|
|
|
// pkg/dist-src/version.js
|
|
var VERSION = "0.0.0-development";
|
|
|
|
// pkg/dist-src/defaults.js
|
|
var userAgent = `octokit-endpoint.js/${VERSION} ${getUserAgent()}`;
|
|
var DEFAULTS = {
|
|
method: "GET",
|
|
baseUrl: "https://api.github.com",
|
|
headers: {
|
|
accept: "application/vnd.github.v3+json",
|
|
"user-agent": userAgent
|
|
},
|
|
mediaType: {
|
|
format: ""
|
|
}
|
|
};
|
|
|
|
// pkg/dist-src/util/lowercase-keys.js
|
|
function dist_bundle_lowercaseKeys(object) {
|
|
if (!object) {
|
|
return {};
|
|
}
|
|
return Object.keys(object).reduce((newObj, key) => {
|
|
newObj[key.toLowerCase()] = object[key];
|
|
return newObj;
|
|
}, {});
|
|
}
|
|
|
|
// pkg/dist-src/util/is-plain-object.js
|
|
function isPlainObject(value) {
|
|
if (typeof value !== "object" || value === null) return false;
|
|
if (Object.prototype.toString.call(value) !== "[object Object]") return false;
|
|
const proto = Object.getPrototypeOf(value);
|
|
if (proto === null) return true;
|
|
const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
|
|
return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
|
|
}
|
|
|
|
// pkg/dist-src/util/merge-deep.js
|
|
function mergeDeep(defaults, options) {
|
|
const result = Object.assign({}, defaults);
|
|
Object.keys(options).forEach((key) => {
|
|
if (isPlainObject(options[key])) {
|
|
if (!(key in defaults)) Object.assign(result, { [key]: options[key] });
|
|
else result[key] = mergeDeep(defaults[key], options[key]);
|
|
} else {
|
|
Object.assign(result, { [key]: options[key] });
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
// pkg/dist-src/util/remove-undefined-properties.js
|
|
function removeUndefinedProperties(obj) {
|
|
for (const key in obj) {
|
|
if (obj[key] === void 0) {
|
|
delete obj[key];
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
// pkg/dist-src/merge.js
|
|
function merge(defaults, route, options) {
|
|
if (typeof route === "string") {
|
|
let [method, url] = route.split(" ");
|
|
options = Object.assign(url ? { method, url } : { url: method }, options);
|
|
} else {
|
|
options = Object.assign({}, route);
|
|
}
|
|
options.headers = dist_bundle_lowercaseKeys(options.headers);
|
|
removeUndefinedProperties(options);
|
|
removeUndefinedProperties(options.headers);
|
|
const mergedOptions = mergeDeep(defaults || {}, options);
|
|
if (options.url === "/graphql") {
|
|
if (defaults && defaults.mediaType.previews?.length) {
|
|
mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(
|
|
(preview) => !mergedOptions.mediaType.previews.includes(preview)
|
|
).concat(mergedOptions.mediaType.previews);
|
|
}
|
|
mergedOptions.mediaType.previews = (mergedOptions.mediaType.previews || []).map((preview) => preview.replace(/-preview/, ""));
|
|
}
|
|
return mergedOptions;
|
|
}
|
|
|
|
// pkg/dist-src/util/add-query-parameters.js
|
|
function addQueryParameters(url, parameters) {
|
|
const separator = /\?/.test(url) ? "&" : "?";
|
|
const names = Object.keys(parameters);
|
|
if (names.length === 0) {
|
|
return url;
|
|
}
|
|
return url + separator + names.map((name) => {
|
|
if (name === "q") {
|
|
return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+");
|
|
}
|
|
return `${name}=${encodeURIComponent(parameters[name])}`;
|
|
}).join("&");
|
|
}
|
|
|
|
// pkg/dist-src/util/extract-url-variable-names.js
|
|
var urlVariableRegex = /\{[^{}}]+\}/g;
|
|
function removeNonChars(variableName) {
|
|
return variableName.replace(/(?:^\W+)|(?:(?<!\W)\W+$)/g, "").split(/,/);
|
|
}
|
|
function extractUrlVariableNames(url) {
|
|
const matches = url.match(urlVariableRegex);
|
|
if (!matches) {
|
|
return [];
|
|
}
|
|
return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
|
|
}
|
|
|
|
// pkg/dist-src/util/omit.js
|
|
function omit(object, keysToOmit) {
|
|
const result = { __proto__: null };
|
|
for (const key of Object.keys(object)) {
|
|
if (keysToOmit.indexOf(key) === -1) {
|
|
result[key] = object[key];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// pkg/dist-src/util/url-template.js
|
|
function encodeReserved(str) {
|
|
return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) {
|
|
if (!/%[0-9A-Fa-f]/.test(part)) {
|
|
part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
|
|
}
|
|
return part;
|
|
}).join("");
|
|
}
|
|
function encodeUnreserved(str) {
|
|
return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
|
|
return "%" + c.charCodeAt(0).toString(16).toUpperCase();
|
|
});
|
|
}
|
|
function encodeValue(operator, value, key) {
|
|
value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
|
|
if (key) {
|
|
return encodeUnreserved(key) + "=" + value;
|
|
} else {
|
|
return value;
|
|
}
|
|
}
|
|
function isDefined(value) {
|
|
return value !== void 0 && value !== null;
|
|
}
|
|
function isKeyOperator(operator) {
|
|
return operator === ";" || operator === "&" || operator === "?";
|
|
}
|
|
function getValues(context, operator, key, modifier) {
|
|
var value = context[key], result = [];
|
|
if (isDefined(value) && value !== "") {
|
|
if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
|
|
value = value.toString();
|
|
if (modifier && modifier !== "*") {
|
|
value = value.substring(0, parseInt(modifier, 10));
|
|
}
|
|
result.push(
|
|
encodeValue(operator, value, isKeyOperator(operator) ? key : "")
|
|
);
|
|
} else {
|
|
if (modifier === "*") {
|
|
if (Array.isArray(value)) {
|
|
value.filter(isDefined).forEach(function(value2) {
|
|
result.push(
|
|
encodeValue(operator, value2, isKeyOperator(operator) ? key : "")
|
|
);
|
|
});
|
|
} else {
|
|
Object.keys(value).forEach(function(k) {
|
|
if (isDefined(value[k])) {
|
|
result.push(encodeValue(operator, value[k], k));
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
const tmp = [];
|
|
if (Array.isArray(value)) {
|
|
value.filter(isDefined).forEach(function(value2) {
|
|
tmp.push(encodeValue(operator, value2));
|
|
});
|
|
} else {
|
|
Object.keys(value).forEach(function(k) {
|
|
if (isDefined(value[k])) {
|
|
tmp.push(encodeUnreserved(k));
|
|
tmp.push(encodeValue(operator, value[k].toString()));
|
|
}
|
|
});
|
|
}
|
|
if (isKeyOperator(operator)) {
|
|
result.push(encodeUnreserved(key) + "=" + tmp.join(","));
|
|
} else if (tmp.length !== 0) {
|
|
result.push(tmp.join(","));
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (operator === ";") {
|
|
if (isDefined(value)) {
|
|
result.push(encodeUnreserved(key));
|
|
}
|
|
} else if (value === "" && (operator === "&" || operator === "?")) {
|
|
result.push(encodeUnreserved(key) + "=");
|
|
} else if (value === "") {
|
|
result.push("");
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function parseUrl(template) {
|
|
return {
|
|
expand: expand.bind(null, template)
|
|
};
|
|
}
|
|
function expand(template, context) {
|
|
var operators = ["+", "#", ".", "/", ";", "?", "&"];
|
|
template = template.replace(
|
|
/\{([^\{\}]+)\}|([^\{\}]+)/g,
|
|
function(_, expression, literal) {
|
|
if (expression) {
|
|
let operator = "";
|
|
const values = [];
|
|
if (operators.indexOf(expression.charAt(0)) !== -1) {
|
|
operator = expression.charAt(0);
|
|
expression = expression.substr(1);
|
|
}
|
|
expression.split(/,/g).forEach(function(variable) {
|
|
var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
|
|
values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
|
|
});
|
|
if (operator && operator !== "+") {
|
|
var separator = ",";
|
|
if (operator === "?") {
|
|
separator = "&";
|
|
} else if (operator !== "#") {
|
|
separator = operator;
|
|
}
|
|
return (values.length !== 0 ? operator : "") + values.join(separator);
|
|
} else {
|
|
return values.join(",");
|
|
}
|
|
} else {
|
|
return encodeReserved(literal);
|
|
}
|
|
}
|
|
);
|
|
if (template === "/") {
|
|
return template;
|
|
} else {
|
|
return template.replace(/\/$/, "");
|
|
}
|
|
}
|
|
|
|
// pkg/dist-src/parse.js
|
|
function parse(options) {
|
|
let method = options.method.toUpperCase();
|
|
let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}");
|
|
let headers = Object.assign({}, options.headers);
|
|
let body;
|
|
let parameters = omit(options, [
|
|
"method",
|
|
"baseUrl",
|
|
"url",
|
|
"headers",
|
|
"request",
|
|
"mediaType"
|
|
]);
|
|
const urlVariableNames = extractUrlVariableNames(url);
|
|
url = parseUrl(url).expand(parameters);
|
|
if (!/^http/.test(url)) {
|
|
url = options.baseUrl + url;
|
|
}
|
|
const omittedParameters = Object.keys(options).filter((option) => urlVariableNames.includes(option)).concat("baseUrl");
|
|
const remainingParameters = omit(parameters, omittedParameters);
|
|
const isBinaryRequest = /application\/octet-stream/i.test(headers.accept);
|
|
if (!isBinaryRequest) {
|
|
if (options.mediaType.format) {
|
|
headers.accept = headers.accept.split(/,/).map(
|
|
(format) => format.replace(
|
|
/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/,
|
|
`application/vnd$1$2.${options.mediaType.format}`
|
|
)
|
|
).join(",");
|
|
}
|
|
if (url.endsWith("/graphql")) {
|
|
if (options.mediaType.previews?.length) {
|
|
const previewsFromAcceptHeader = headers.accept.match(/(?<![\w-])[\w-]+(?=-preview)/g) || [];
|
|
headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map((preview) => {
|
|
const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json";
|
|
return `application/vnd.github.${preview}-preview${format}`;
|
|
}).join(",");
|
|
}
|
|
}
|
|
}
|
|
if (["GET", "HEAD"].includes(method)) {
|
|
url = addQueryParameters(url, remainingParameters);
|
|
} else {
|
|
if ("data" in remainingParameters) {
|
|
body = remainingParameters.data;
|
|
} else {
|
|
if (Object.keys(remainingParameters).length) {
|
|
body = remainingParameters;
|
|
}
|
|
}
|
|
}
|
|
if (!headers["content-type"] && typeof body !== "undefined") {
|
|
headers["content-type"] = "application/json; charset=utf-8";
|
|
}
|
|
if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
|
|
body = "";
|
|
}
|
|
return Object.assign(
|
|
{ method, url, headers },
|
|
typeof body !== "undefined" ? { body } : null,
|
|
options.request ? { request: options.request } : null
|
|
);
|
|
}
|
|
|
|
// pkg/dist-src/endpoint-with-defaults.js
|
|
function endpointWithDefaults(defaults, route, options) {
|
|
return parse(merge(defaults, route, options));
|
|
}
|
|
|
|
// pkg/dist-src/with-defaults.js
|
|
function withDefaults(oldDefaults, newDefaults) {
|
|
const DEFAULTS2 = merge(oldDefaults, newDefaults);
|
|
const endpoint2 = endpointWithDefaults.bind(null, DEFAULTS2);
|
|
return Object.assign(endpoint2, {
|
|
DEFAULTS: DEFAULTS2,
|
|
defaults: withDefaults.bind(null, DEFAULTS2),
|
|
merge: merge.bind(null, DEFAULTS2),
|
|
parse
|
|
});
|
|
}
|
|
|
|
// pkg/dist-src/index.js
|
|
var endpoint = withDefaults(null, DEFAULTS);
|
|
|
|
|
|
// EXTERNAL MODULE: ./node_modules/content-type/dist/index.js
|
|
var dist = __nccwpck_require__(4649);
|
|
;// CONCATENATED MODULE: ./node_modules/json-with-bigint/json-with-bigint.js
|
|
const intRegex = /^-?\d+$/;
|
|
const noiseValue = /^-?\d+n+$/; // Noise - strings that match the custom format before being converted to it
|
|
const originalStringify = JSON.stringify;
|
|
const originalParse = JSON.parse;
|
|
const customFormat = /^-?\d+n$/;
|
|
|
|
const bigIntsStringify = /([\[:])?"(-?\d+)n"($|([\\n]|\s)*(\s|[\\n])*[,\}\]])/g;
|
|
const noiseStringify =
|
|
/([\[:])?("-?\d+n+)n("$|"([\\n]|\s)*(\s|[\\n])*[,\}\]])/g;
|
|
|
|
/**
|
|
* @typedef {(this: any, key: string | number | undefined, value: any) => any} Replacer
|
|
* @typedef {(key: string | number | undefined, value: any, context?: { source: string }) => any} Reviver
|
|
*/
|
|
|
|
/**
|
|
* Converts a JavaScript value to a JSON string.
|
|
*
|
|
* Supports serialization of BigInt values using two strategies:
|
|
* 1. Custom format "123n" → "123" (universal fallback)
|
|
* 2. Native JSON.rawJSON() (Node.js 22+, fastest) when available
|
|
*
|
|
* All other values are serialized exactly like native JSON.stringify().
|
|
*
|
|
* @param {*} value The value to convert to a JSON string.
|
|
* @param {Replacer | Array<string | number> | null} [replacer]
|
|
* A function that alters the behavior of the stringification process,
|
|
* or an array of strings/numbers to indicate properties to exclude.
|
|
* @param {string | number} [space]
|
|
* A string or number to specify indentation or pretty-printing.
|
|
* @returns {string} The JSON string representation.
|
|
*/
|
|
const JSONStringify = (value, replacer, space) => {
|
|
if ("rawJSON" in JSON) {
|
|
return originalStringify(
|
|
value,
|
|
(key, value) => {
|
|
if (typeof value === "bigint") return JSON.rawJSON(value.toString());
|
|
|
|
if (typeof replacer === "function") return replacer(key, value);
|
|
|
|
if (Array.isArray(replacer) && replacer.includes(key)) return value;
|
|
|
|
return value;
|
|
},
|
|
space,
|
|
);
|
|
}
|
|
|
|
if (!value) return originalStringify(value, replacer, space);
|
|
|
|
const convertedToCustomJSON = originalStringify(
|
|
value,
|
|
(key, value) => {
|
|
const isNoise = typeof value === "string" && noiseValue.test(value);
|
|
|
|
if (isNoise) return value.toString() + "n"; // Mark noise values with additional "n" to offset the deletion of one "n" during the processing
|
|
|
|
if (typeof value === "bigint") return value.toString() + "n";
|
|
|
|
if (typeof replacer === "function") return replacer(key, value);
|
|
|
|
if (Array.isArray(replacer) && replacer.includes(key)) return value;
|
|
|
|
return value;
|
|
},
|
|
space,
|
|
);
|
|
const processedJSON = convertedToCustomJSON.replace(
|
|
bigIntsStringify,
|
|
"$1$2$3",
|
|
); // Delete one "n" off the end of every BigInt value
|
|
const denoisedJSON = processedJSON.replace(noiseStringify, "$1$2$3"); // Remove one "n" off the end of every noisy string
|
|
|
|
return denoisedJSON;
|
|
};
|
|
|
|
const featureCache = new Map();
|
|
|
|
/**
|
|
* Detects if the current JSON.parse implementation supports the context.source feature.
|
|
*
|
|
* Uses toString() fingerprinting to cache results and automatically detect runtime
|
|
* replacements of JSON.parse (polyfills, mocks, etc.).
|
|
*
|
|
* @returns {boolean} true if context.source is supported, false otherwise.
|
|
*/
|
|
const isContextSourceSupported = () => {
|
|
const parseFingerprint = JSON.parse.toString();
|
|
|
|
if (featureCache.has(parseFingerprint)) {
|
|
return featureCache.get(parseFingerprint);
|
|
}
|
|
|
|
try {
|
|
const result = JSON.parse(
|
|
"1",
|
|
(_, __, context) => !!context?.source && context.source === "1",
|
|
);
|
|
featureCache.set(parseFingerprint, result);
|
|
|
|
return result;
|
|
} catch {
|
|
featureCache.set(parseFingerprint, false);
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Reviver function that converts custom-format BigInt strings back to BigInt values.
|
|
* Also handles "noise" strings that accidentally match the BigInt format.
|
|
*
|
|
* @param {string | number | undefined} key The object key.
|
|
* @param {*} value The value being parsed.
|
|
* @param {object} [context] Parse context (if supported by JSON.parse).
|
|
* @param {Reviver} [userReviver] User's custom reviver function.
|
|
* @returns {any} The transformed value.
|
|
*/
|
|
const convertMarkedBigIntsReviver = (key, value, context, userReviver) => {
|
|
const isCustomFormatBigInt =
|
|
typeof value === "string" && customFormat.test(value);
|
|
if (isCustomFormatBigInt) return BigInt(value.slice(0, -1));
|
|
|
|
const isNoiseValue = typeof value === "string" && noiseValue.test(value);
|
|
if (isNoiseValue) return value.slice(0, -1);
|
|
|
|
if (typeof userReviver !== "function") return value;
|
|
|
|
return userReviver(key, value, context);
|
|
};
|
|
|
|
/**
|
|
* Fast JSON.parse implementation (~2x faster than classic fallback).
|
|
* Uses JSON.parse's context.source feature to detect integers and convert
|
|
* large numbers directly to BigInt without string manipulation.
|
|
*
|
|
* Does not support legacy custom format from v1 of this library.
|
|
*
|
|
* @param {string} text JSON string to parse.
|
|
* @param {Reviver} [reviver] Transform function to apply to each value.
|
|
* @returns {any} Parsed JavaScript value.
|
|
*/
|
|
const JSONParseV2 = (text, reviver) => {
|
|
return JSON.parse(text, (key, value, context) => {
|
|
const isBigNumber =
|
|
typeof value === "number" &&
|
|
(value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER);
|
|
const isInt = context && intRegex.test(context.source);
|
|
const isBigInt = isBigNumber && isInt;
|
|
|
|
if (isBigInt) return BigInt(context.source);
|
|
|
|
if (typeof reviver !== "function") return value;
|
|
|
|
return reviver(key, value, context);
|
|
});
|
|
};
|
|
|
|
const MAX_INT = Number.MAX_SAFE_INTEGER.toString();
|
|
const MAX_DIGITS = MAX_INT.length;
|
|
const stringsOrLargeNumbers =
|
|
/"(?:\\.|[^"])*"|-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/g;
|
|
const noiseValueWithQuotes = /^"-?\d+n+"$/; // Noise - strings that match the custom format before being converted to it
|
|
|
|
/**
|
|
* Converts a JSON string into a JavaScript value.
|
|
*
|
|
* Supports parsing of large integers using two strategies:
|
|
* 1. Classic fallback: Marks large numbers with "123n" format, then converts to BigInt
|
|
* 2. Fast path (JSONParseV2): Uses context.source feature (~2x faster) when available
|
|
*
|
|
* All other JSON values are parsed exactly like native JSON.parse().
|
|
*
|
|
* @param {string} text A valid JSON string.
|
|
* @param {Reviver} [reviver]
|
|
* A function that transforms the results. This function is called for each member
|
|
* of the object. If a member contains nested objects, the nested objects are
|
|
* transformed before the parent object is.
|
|
* @returns {any} The parsed JavaScript value.
|
|
* @throws {SyntaxError} If text is not valid JSON.
|
|
*/
|
|
const JSONParse = (text, reviver) => {
|
|
if (!text) return originalParse(text, reviver);
|
|
|
|
if (isContextSourceSupported()) return JSONParseV2(text, reviver); // Shortcut to a faster (2x) and simpler version
|
|
|
|
// Find and mark big numbers with "n"
|
|
const serializedData = text.replace(
|
|
stringsOrLargeNumbers,
|
|
(text, digits, fractional, exponential) => {
|
|
const isString = text[0] === '"';
|
|
const isNoise = isString && noiseValueWithQuotes.test(text);
|
|
|
|
if (isNoise) return text.substring(0, text.length - 1) + 'n"'; // Mark noise values with additional "n" to offset the deletion of one "n" during the processing
|
|
|
|
const isFractionalOrExponential = fractional || exponential;
|
|
const isLessThanMaxSafeInt =
|
|
digits &&
|
|
(digits.length < MAX_DIGITS ||
|
|
(digits.length === MAX_DIGITS && digits <= MAX_INT)); // With a fixed number of digits, we can correctly use lexicographical comparison to do a numeric comparison
|
|
|
|
if (isString || isFractionalOrExponential || isLessThanMaxSafeInt)
|
|
return text;
|
|
|
|
return '"' + text + 'n"';
|
|
},
|
|
);
|
|
|
|
return originalParse(serializedData, (key, value, context) =>
|
|
convertMarkedBigIntsReviver(key, value, context, reviver),
|
|
);
|
|
};
|
|
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@octokit/request-error/dist-src/index.js
|
|
class RequestError extends Error {
|
|
name;
|
|
/**
|
|
* http status code
|
|
*/
|
|
status;
|
|
/**
|
|
* Request options that lead to the error.
|
|
*/
|
|
request;
|
|
/**
|
|
* Response object if a response was received
|
|
*/
|
|
response;
|
|
constructor(message, statusCode, options) {
|
|
super(message, { cause: options.cause });
|
|
this.name = "HttpError";
|
|
this.status = Number.parseInt(statusCode);
|
|
if (Number.isNaN(this.status)) {
|
|
this.status = 0;
|
|
}
|
|
/* v8 ignore else -- @preserve -- Bug with vitest coverage where it sees an else branch that doesn't exist */
|
|
if ("response" in options) {
|
|
this.response = options.response;
|
|
}
|
|
const requestCopy = Object.assign({}, options.request);
|
|
if (options.request.headers.authorization) {
|
|
requestCopy.headers = Object.assign({}, options.request.headers, {
|
|
authorization: options.request.headers.authorization.replace(
|
|
/(?<! ) .*$/,
|
|
" [REDACTED]"
|
|
)
|
|
});
|
|
}
|
|
requestCopy.url = requestCopy.url.replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]").replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
|
|
this.request = requestCopy;
|
|
}
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@octokit/request/dist-bundle/index.js
|
|
// pkg/dist-src/index.js
|
|
|
|
|
|
// pkg/dist-src/defaults.js
|
|
|
|
|
|
// pkg/dist-src/version.js
|
|
var dist_bundle_VERSION = "10.0.10";
|
|
|
|
// pkg/dist-src/defaults.js
|
|
var defaults_default = {
|
|
headers: {
|
|
"user-agent": `octokit-request.js/${dist_bundle_VERSION} ${getUserAgent()}`
|
|
}
|
|
};
|
|
|
|
// pkg/dist-src/fetch-wrapper.js
|
|
|
|
|
|
|
|
// pkg/dist-src/is-plain-object.js
|
|
function dist_bundle_isPlainObject(value) {
|
|
if (typeof value !== "object" || value === null) return false;
|
|
if (Object.prototype.toString.call(value) !== "[object Object]") return false;
|
|
const proto = Object.getPrototypeOf(value);
|
|
if (proto === null) return true;
|
|
const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
|
|
return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
|
|
}
|
|
|
|
// pkg/dist-src/fetch-wrapper.js
|
|
|
|
var noop = () => "";
|
|
async function fetchWrapper(requestOptions) {
|
|
const fetch = requestOptions.request?.fetch || globalThis.fetch;
|
|
if (!fetch) {
|
|
throw new Error(
|
|
"fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing"
|
|
);
|
|
}
|
|
const log = requestOptions.request?.log || console;
|
|
const parseSuccessResponseBody = requestOptions.request?.parseSuccessResponseBody !== false;
|
|
const body = dist_bundle_isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body) ? JSONStringify(requestOptions.body) : requestOptions.body;
|
|
const requestHeaders = Object.fromEntries(
|
|
Object.entries(requestOptions.headers).map(([name, value]) => [
|
|
name,
|
|
String(value)
|
|
])
|
|
);
|
|
let fetchResponse;
|
|
try {
|
|
fetchResponse = await fetch(requestOptions.url, {
|
|
method: requestOptions.method,
|
|
body,
|
|
redirect: requestOptions.request?.redirect,
|
|
headers: requestHeaders,
|
|
signal: requestOptions.request?.signal,
|
|
// duplex must be set if request.body is ReadableStream or Async Iterables.
|
|
// See https://fetch.spec.whatwg.org/#dom-requestinit-duplex.
|
|
...requestOptions.body && { duplex: "half" }
|
|
});
|
|
} catch (error) {
|
|
let message = "Unknown Error";
|
|
if (error instanceof Error) {
|
|
if (error.name === "AbortError") {
|
|
error.status = 500;
|
|
throw error;
|
|
}
|
|
message = error.message;
|
|
if (error.name === "TypeError" && "cause" in error) {
|
|
if (error.cause instanceof Error) {
|
|
message = error.cause.message;
|
|
} else if (typeof error.cause === "string") {
|
|
message = error.cause;
|
|
}
|
|
}
|
|
}
|
|
const requestError = new RequestError(message, 500, {
|
|
request: requestOptions
|
|
});
|
|
requestError.cause = error;
|
|
throw requestError;
|
|
}
|
|
const status = fetchResponse.status;
|
|
const url = fetchResponse.url;
|
|
const responseHeaders = {};
|
|
for (const [key, value] of fetchResponse.headers) {
|
|
responseHeaders[key] = value;
|
|
}
|
|
const octokitResponse = {
|
|
url,
|
|
status,
|
|
headers: responseHeaders,
|
|
data: ""
|
|
};
|
|
if ("deprecation" in responseHeaders) {
|
|
const matches = responseHeaders.link && responseHeaders.link.match(/<([^<>]+)>; rel="deprecation"/);
|
|
const deprecationLink = matches && matches.pop();
|
|
log.warn(
|
|
`[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${responseHeaders.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`
|
|
);
|
|
}
|
|
if (status === 204 || status === 205) {
|
|
return octokitResponse;
|
|
}
|
|
if (requestOptions.method === "HEAD") {
|
|
if (status < 400) {
|
|
return octokitResponse;
|
|
}
|
|
throw new RequestError(fetchResponse.statusText, status, {
|
|
response: octokitResponse,
|
|
request: requestOptions
|
|
});
|
|
}
|
|
if (status === 304) {
|
|
octokitResponse.data = await getResponseData(fetchResponse);
|
|
throw new RequestError("Not modified", status, {
|
|
response: octokitResponse,
|
|
request: requestOptions
|
|
});
|
|
}
|
|
if (status >= 400) {
|
|
octokitResponse.data = await getResponseData(fetchResponse);
|
|
throw new RequestError(toErrorMessage(octokitResponse.data), status, {
|
|
response: octokitResponse,
|
|
request: requestOptions
|
|
});
|
|
}
|
|
octokitResponse.data = parseSuccessResponseBody ? await getResponseData(fetchResponse) : fetchResponse.body;
|
|
return octokitResponse;
|
|
}
|
|
async function getResponseData(response) {
|
|
const contentType = response.headers.get("content-type");
|
|
if (!contentType) {
|
|
return response.text().catch(noop);
|
|
}
|
|
const mimetype = (0,dist/* parse */.qg)(contentType);
|
|
if (isJSONResponse(mimetype)) {
|
|
let text = "";
|
|
try {
|
|
text = await response.text();
|
|
return JSONParse(text);
|
|
} catch (err) {
|
|
return text;
|
|
}
|
|
} else if (mimetype.type.startsWith("text/") || mimetype.parameters.charset?.toLowerCase() === "utf-8") {
|
|
return response.text().catch(noop);
|
|
} else {
|
|
return response.arrayBuffer().catch(
|
|
/* v8 ignore next -- @preserve */
|
|
() => new ArrayBuffer(0)
|
|
);
|
|
}
|
|
}
|
|
function isJSONResponse(mimetype) {
|
|
return mimetype.type === "application/json" || mimetype.type === "application/scim+json";
|
|
}
|
|
function toErrorMessage(data) {
|
|
if (typeof data === "string") {
|
|
return data;
|
|
}
|
|
if (data instanceof ArrayBuffer) {
|
|
return "Unknown error";
|
|
}
|
|
if ("message" in data) {
|
|
const suffix = "documentation_url" in data ? ` - ${data.documentation_url}` : "";
|
|
return Array.isArray(data.errors) ? `${data.message}: ${data.errors.map((v) => JSON.stringify(v)).join(", ")}${suffix}` : `${data.message}${suffix}`;
|
|
}
|
|
return `Unknown error: ${JSON.stringify(data)}`;
|
|
}
|
|
|
|
// pkg/dist-src/with-defaults.js
|
|
function dist_bundle_withDefaults(oldEndpoint, newDefaults) {
|
|
const endpoint2 = oldEndpoint.defaults(newDefaults);
|
|
const newApi = function(route, parameters) {
|
|
const endpointOptions = endpoint2.merge(route, parameters);
|
|
if (!endpointOptions.request || !endpointOptions.request.hook) {
|
|
return fetchWrapper(endpoint2.parse(endpointOptions));
|
|
}
|
|
const request2 = (route2, parameters2) => {
|
|
return fetchWrapper(
|
|
endpoint2.parse(endpoint2.merge(route2, parameters2))
|
|
);
|
|
};
|
|
Object.assign(request2, {
|
|
endpoint: endpoint2,
|
|
defaults: dist_bundle_withDefaults.bind(null, endpoint2)
|
|
});
|
|
return endpointOptions.request.hook(request2, endpointOptions);
|
|
};
|
|
return Object.assign(newApi, {
|
|
endpoint: endpoint2,
|
|
defaults: dist_bundle_withDefaults.bind(null, endpoint2)
|
|
});
|
|
}
|
|
|
|
// pkg/dist-src/index.js
|
|
var request = dist_bundle_withDefaults(endpoint, defaults_default);
|
|
|
|
/* v8 ignore next -- @preserve */
|
|
/* v8 ignore else -- @preserve */
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@octokit/graphql/dist-bundle/index.js
|
|
// pkg/dist-src/index.js
|
|
|
|
|
|
|
|
// pkg/dist-src/version.js
|
|
var graphql_dist_bundle_VERSION = "0.0.0-development";
|
|
|
|
// pkg/dist-src/with-defaults.js
|
|
|
|
|
|
// pkg/dist-src/graphql.js
|
|
|
|
|
|
// pkg/dist-src/error.js
|
|
function _buildMessageForResponseErrors(data) {
|
|
return `Request failed due to following response errors:
|
|
` + data.errors.map((e) => ` - ${e.message}`).join("\n");
|
|
}
|
|
var GraphqlResponseError = class extends Error {
|
|
constructor(request2, headers, response) {
|
|
super(_buildMessageForResponseErrors(response));
|
|
this.request = request2;
|
|
this.headers = headers;
|
|
this.response = response;
|
|
this.errors = response.errors;
|
|
this.data = response.data;
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
}
|
|
}
|
|
name = "GraphqlResponseError";
|
|
errors;
|
|
data;
|
|
};
|
|
|
|
// pkg/dist-src/graphql.js
|
|
var NON_VARIABLE_OPTIONS = [
|
|
"method",
|
|
"baseUrl",
|
|
"url",
|
|
"headers",
|
|
"request",
|
|
"query",
|
|
"mediaType",
|
|
"operationName"
|
|
];
|
|
var FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"];
|
|
var GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/;
|
|
function graphql(request2, query, options) {
|
|
if (options) {
|
|
if (typeof query === "string" && "query" in options) {
|
|
return Promise.reject(
|
|
new Error(`[@octokit/graphql] "query" cannot be used as variable name`)
|
|
);
|
|
}
|
|
for (const key in options) {
|
|
if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key)) continue;
|
|
return Promise.reject(
|
|
new Error(
|
|
`[@octokit/graphql] "${key}" cannot be used as variable name`
|
|
)
|
|
);
|
|
}
|
|
}
|
|
const parsedOptions = typeof query === "string" ? Object.assign({ query }, options) : query;
|
|
const requestOptions = Object.keys(
|
|
parsedOptions
|
|
).reduce((result, key) => {
|
|
if (NON_VARIABLE_OPTIONS.includes(key)) {
|
|
result[key] = parsedOptions[key];
|
|
return result;
|
|
}
|
|
if (!result.variables) {
|
|
result.variables = {};
|
|
}
|
|
result.variables[key] = parsedOptions[key];
|
|
return result;
|
|
}, {});
|
|
const baseUrl = parsedOptions.baseUrl || request2.endpoint.DEFAULTS.baseUrl;
|
|
if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) {
|
|
requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql");
|
|
}
|
|
return request2(requestOptions).then((response) => {
|
|
if (response.data.errors) {
|
|
const headers = {};
|
|
for (const key of Object.keys(response.headers)) {
|
|
headers[key] = response.headers[key];
|
|
}
|
|
throw new GraphqlResponseError(
|
|
requestOptions,
|
|
headers,
|
|
response.data
|
|
);
|
|
}
|
|
return response.data.data;
|
|
});
|
|
}
|
|
|
|
// pkg/dist-src/with-defaults.js
|
|
function graphql_dist_bundle_withDefaults(request2, newDefaults) {
|
|
const newRequest = request2.defaults(newDefaults);
|
|
const newApi = (query, options) => {
|
|
return graphql(newRequest, query, options);
|
|
};
|
|
return Object.assign(newApi, {
|
|
defaults: graphql_dist_bundle_withDefaults.bind(null, newRequest),
|
|
endpoint: newRequest.endpoint
|
|
});
|
|
}
|
|
|
|
// pkg/dist-src/index.js
|
|
var graphql2 = graphql_dist_bundle_withDefaults(request, {
|
|
headers: {
|
|
"user-agent": `octokit-graphql.js/${graphql_dist_bundle_VERSION} ${getUserAgent()}`
|
|
},
|
|
method: "POST",
|
|
url: "/graphql"
|
|
});
|
|
function withCustomRequest(customRequest) {
|
|
return graphql_dist_bundle_withDefaults(customRequest, {
|
|
method: "POST",
|
|
url: "/graphql"
|
|
});
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@octokit/auth-token/dist-bundle/index.js
|
|
// pkg/dist-src/is-jwt.js
|
|
var b64url = "(?:[a-zA-Z0-9_-]+)";
|
|
var sep = "\\.";
|
|
var jwtRE = new RegExp(`^${b64url}${sep}${b64url}${sep}${b64url}$`);
|
|
var isJWT = jwtRE.test.bind(jwtRE);
|
|
|
|
// pkg/dist-src/auth.js
|
|
async function auth(token) {
|
|
const isApp = isJWT(token);
|
|
const isInstallation = token.startsWith("v1.") || token.startsWith("ghs_");
|
|
const isUserToServer = token.startsWith("ghu_");
|
|
const tokenType = isApp ? "app" : isInstallation ? "installation" : isUserToServer ? "user-to-server" : "oauth";
|
|
return {
|
|
type: "token",
|
|
token,
|
|
tokenType
|
|
};
|
|
}
|
|
|
|
// pkg/dist-src/with-authorization-prefix.js
|
|
function withAuthorizationPrefix(token) {
|
|
if (token.split(/\./).length === 3) {
|
|
return `bearer ${token}`;
|
|
}
|
|
return `token ${token}`;
|
|
}
|
|
|
|
// pkg/dist-src/hook.js
|
|
async function hook(token, request, route, parameters) {
|
|
const endpoint = request.endpoint.merge(
|
|
route,
|
|
parameters
|
|
);
|
|
endpoint.headers.authorization = withAuthorizationPrefix(token);
|
|
return request(endpoint);
|
|
}
|
|
|
|
// pkg/dist-src/index.js
|
|
var createTokenAuth = function createTokenAuth2(token) {
|
|
if (!token) {
|
|
throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
|
|
}
|
|
if (typeof token !== "string") {
|
|
throw new Error(
|
|
"[@octokit/auth-token] Token passed to createTokenAuth is not a string"
|
|
);
|
|
}
|
|
token = token.replace(/^(token|bearer) +/i, "");
|
|
return Object.assign(auth.bind(null, token), {
|
|
hook: hook.bind(null, token)
|
|
});
|
|
};
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@octokit/core/dist-src/version.js
|
|
const version_VERSION = "7.0.6";
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@octokit/core/dist-src/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const dist_src_noop = () => {
|
|
};
|
|
const consoleWarn = console.warn.bind(console);
|
|
const consoleError = console.error.bind(console);
|
|
function createLogger(logger = {}) {
|
|
if (typeof logger.debug !== "function") {
|
|
logger.debug = dist_src_noop;
|
|
}
|
|
if (typeof logger.info !== "function") {
|
|
logger.info = dist_src_noop;
|
|
}
|
|
if (typeof logger.warn !== "function") {
|
|
logger.warn = consoleWarn;
|
|
}
|
|
if (typeof logger.error !== "function") {
|
|
logger.error = consoleError;
|
|
}
|
|
return logger;
|
|
}
|
|
const userAgentTrail = `octokit-core.js/${version_VERSION} ${getUserAgent()}`;
|
|
class Octokit {
|
|
static VERSION = version_VERSION;
|
|
static defaults(defaults) {
|
|
const OctokitWithDefaults = class extends this {
|
|
constructor(...args) {
|
|
const options = args[0] || {};
|
|
if (typeof defaults === "function") {
|
|
super(defaults(options));
|
|
return;
|
|
}
|
|
super(
|
|
Object.assign(
|
|
{},
|
|
defaults,
|
|
options,
|
|
options.userAgent && defaults.userAgent ? {
|
|
userAgent: `${options.userAgent} ${defaults.userAgent}`
|
|
} : null
|
|
)
|
|
);
|
|
}
|
|
};
|
|
return OctokitWithDefaults;
|
|
}
|
|
static plugins = [];
|
|
/**
|
|
* Attach a plugin (or many) to your Octokit instance.
|
|
*
|
|
* @example
|
|
* const API = Octokit.plugin(plugin1, plugin2, plugin3, ...)
|
|
*/
|
|
static plugin(...newPlugins) {
|
|
const currentPlugins = this.plugins;
|
|
const NewOctokit = class extends this {
|
|
static plugins = currentPlugins.concat(
|
|
newPlugins.filter((plugin) => !currentPlugins.includes(plugin))
|
|
);
|
|
};
|
|
return NewOctokit;
|
|
}
|
|
constructor(options = {}) {
|
|
const hook = new before_after_hook.Collection();
|
|
const requestDefaults = {
|
|
baseUrl: request.endpoint.DEFAULTS.baseUrl,
|
|
headers: {},
|
|
request: Object.assign({}, options.request, {
|
|
// @ts-ignore internal usage only, no need to type
|
|
hook: hook.bind(null, "request")
|
|
}),
|
|
mediaType: {
|
|
previews: [],
|
|
format: ""
|
|
}
|
|
};
|
|
requestDefaults.headers["user-agent"] = options.userAgent ? `${options.userAgent} ${userAgentTrail}` : userAgentTrail;
|
|
if (options.baseUrl) {
|
|
requestDefaults.baseUrl = options.baseUrl;
|
|
}
|
|
if (options.previews) {
|
|
requestDefaults.mediaType.previews = options.previews;
|
|
}
|
|
if (options.timeZone) {
|
|
requestDefaults.headers["time-zone"] = options.timeZone;
|
|
}
|
|
this.request = request.defaults(requestDefaults);
|
|
this.graphql = withCustomRequest(this.request).defaults(requestDefaults);
|
|
this.log = createLogger(options.log);
|
|
this.hook = hook;
|
|
if (!options.authStrategy) {
|
|
if (!options.auth) {
|
|
this.auth = async () => ({
|
|
type: "unauthenticated"
|
|
});
|
|
} else {
|
|
const auth = createTokenAuth(options.auth);
|
|
hook.wrap("request", auth.hook);
|
|
this.auth = auth;
|
|
}
|
|
} else {
|
|
const { authStrategy, ...otherOptions } = options;
|
|
const auth = authStrategy(
|
|
Object.assign(
|
|
{
|
|
request: this.request,
|
|
log: this.log,
|
|
// we pass the current octokit instance as well as its constructor options
|
|
// to allow for authentication strategies that return a new octokit instance
|
|
// that shares the same internal state as the current one. The original
|
|
// requirement for this was the "event-octokit" authentication strategy
|
|
// of https://github.com/probot/octokit-auth-probot.
|
|
octokit: this,
|
|
octokitOptions: otherOptions
|
|
},
|
|
options.auth
|
|
)
|
|
);
|
|
hook.wrap("request", auth.hook);
|
|
this.auth = auth;
|
|
}
|
|
const classConstructor = this.constructor;
|
|
for (let i = 0; i < classConstructor.plugins.length; ++i) {
|
|
Object.assign(this, classConstructor.plugins[i](this, options));
|
|
}
|
|
}
|
|
// assigned during constructor
|
|
request;
|
|
graphql;
|
|
log;
|
|
hook;
|
|
// TODO: type `octokit.auth` based on passed options.authStrategy
|
|
auth;
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/version.js
|
|
const dist_src_version_VERSION = "17.0.0";
|
|
|
|
//# sourceMappingURL=version.js.map
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/generated/endpoints.js
|
|
const Endpoints = {
|
|
actions: {
|
|
addCustomLabelsToSelfHostedRunnerForOrg: [
|
|
"POST /orgs/{org}/actions/runners/{runner_id}/labels"
|
|
],
|
|
addCustomLabelsToSelfHostedRunnerForRepo: [
|
|
"POST /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"
|
|
],
|
|
addRepoAccessToSelfHostedRunnerGroupInOrg: [
|
|
"PUT /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories/{repository_id}"
|
|
],
|
|
addSelectedRepoToOrgSecret: [
|
|
"PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"
|
|
],
|
|
addSelectedRepoToOrgVariable: [
|
|
"PUT /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"
|
|
],
|
|
approveWorkflowRun: [
|
|
"POST /repos/{owner}/{repo}/actions/runs/{run_id}/approve"
|
|
],
|
|
cancelWorkflowRun: [
|
|
"POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"
|
|
],
|
|
createEnvironmentVariable: [
|
|
"POST /repos/{owner}/{repo}/environments/{environment_name}/variables"
|
|
],
|
|
createHostedRunnerForOrg: ["POST /orgs/{org}/actions/hosted-runners"],
|
|
createOrUpdateEnvironmentSecret: [
|
|
"PUT /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"
|
|
],
|
|
createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"],
|
|
createOrUpdateRepoSecret: [
|
|
"PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"
|
|
],
|
|
createOrgVariable: ["POST /orgs/{org}/actions/variables"],
|
|
createRegistrationTokenForOrg: [
|
|
"POST /orgs/{org}/actions/runners/registration-token"
|
|
],
|
|
createRegistrationTokenForRepo: [
|
|
"POST /repos/{owner}/{repo}/actions/runners/registration-token"
|
|
],
|
|
createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"],
|
|
createRemoveTokenForRepo: [
|
|
"POST /repos/{owner}/{repo}/actions/runners/remove-token"
|
|
],
|
|
createRepoVariable: ["POST /repos/{owner}/{repo}/actions/variables"],
|
|
createWorkflowDispatch: [
|
|
"POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"
|
|
],
|
|
deleteActionsCacheById: [
|
|
"DELETE /repos/{owner}/{repo}/actions/caches/{cache_id}"
|
|
],
|
|
deleteActionsCacheByKey: [
|
|
"DELETE /repos/{owner}/{repo}/actions/caches{?key,ref}"
|
|
],
|
|
deleteArtifact: [
|
|
"DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"
|
|
],
|
|
deleteCustomImageFromOrg: [
|
|
"DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}"
|
|
],
|
|
deleteCustomImageVersionFromOrg: [
|
|
"DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}"
|
|
],
|
|
deleteEnvironmentSecret: [
|
|
"DELETE /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"
|
|
],
|
|
deleteEnvironmentVariable: [
|
|
"DELETE /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"
|
|
],
|
|
deleteHostedRunnerForOrg: [
|
|
"DELETE /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"
|
|
],
|
|
deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"],
|
|
deleteOrgVariable: ["DELETE /orgs/{org}/actions/variables/{name}"],
|
|
deleteRepoSecret: [
|
|
"DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"
|
|
],
|
|
deleteRepoVariable: [
|
|
"DELETE /repos/{owner}/{repo}/actions/variables/{name}"
|
|
],
|
|
deleteSelfHostedRunnerFromOrg: [
|
|
"DELETE /orgs/{org}/actions/runners/{runner_id}"
|
|
],
|
|
deleteSelfHostedRunnerFromRepo: [
|
|
"DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"
|
|
],
|
|
deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"],
|
|
deleteWorkflowRunLogs: [
|
|
"DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"
|
|
],
|
|
disableSelectedRepositoryGithubActionsOrganization: [
|
|
"DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}"
|
|
],
|
|
disableWorkflow: [
|
|
"PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable"
|
|
],
|
|
downloadArtifact: [
|
|
"GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"
|
|
],
|
|
downloadJobLogsForWorkflowRun: [
|
|
"GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"
|
|
],
|
|
downloadWorkflowRunAttemptLogs: [
|
|
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/logs"
|
|
],
|
|
downloadWorkflowRunLogs: [
|
|
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"
|
|
],
|
|
enableSelectedRepositoryGithubActionsOrganization: [
|
|
"PUT /orgs/{org}/actions/permissions/repositories/{repository_id}"
|
|
],
|
|
enableWorkflow: [
|
|
"PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable"
|
|
],
|
|
forceCancelWorkflowRun: [
|
|
"POST /repos/{owner}/{repo}/actions/runs/{run_id}/force-cancel"
|
|
],
|
|
generateRunnerJitconfigForOrg: [
|
|
"POST /orgs/{org}/actions/runners/generate-jitconfig"
|
|
],
|
|
generateRunnerJitconfigForRepo: [
|
|
"POST /repos/{owner}/{repo}/actions/runners/generate-jitconfig"
|
|
],
|
|
getActionsCacheList: ["GET /repos/{owner}/{repo}/actions/caches"],
|
|
getActionsCacheUsage: ["GET /repos/{owner}/{repo}/actions/cache/usage"],
|
|
getActionsCacheUsageByRepoForOrg: [
|
|
"GET /orgs/{org}/actions/cache/usage-by-repository"
|
|
],
|
|
getActionsCacheUsageForOrg: ["GET /orgs/{org}/actions/cache/usage"],
|
|
getAllowedActionsOrganization: [
|
|
"GET /orgs/{org}/actions/permissions/selected-actions"
|
|
],
|
|
getAllowedActionsRepository: [
|
|
"GET /repos/{owner}/{repo}/actions/permissions/selected-actions"
|
|
],
|
|
getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],
|
|
getCustomImageForOrg: [
|
|
"GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}"
|
|
],
|
|
getCustomImageVersionForOrg: [
|
|
"GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}"
|
|
],
|
|
getCustomOidcSubClaimForRepo: [
|
|
"GET /repos/{owner}/{repo}/actions/oidc/customization/sub"
|
|
],
|
|
getEnvironmentPublicKey: [
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/public-key"
|
|
],
|
|
getEnvironmentSecret: [
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"
|
|
],
|
|
getEnvironmentVariable: [
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"
|
|
],
|
|
getGithubActionsDefaultWorkflowPermissionsOrganization: [
|
|
"GET /orgs/{org}/actions/permissions/workflow"
|
|
],
|
|
getGithubActionsDefaultWorkflowPermissionsRepository: [
|
|
"GET /repos/{owner}/{repo}/actions/permissions/workflow"
|
|
],
|
|
getGithubActionsPermissionsOrganization: [
|
|
"GET /orgs/{org}/actions/permissions"
|
|
],
|
|
getGithubActionsPermissionsRepository: [
|
|
"GET /repos/{owner}/{repo}/actions/permissions"
|
|
],
|
|
getHostedRunnerForOrg: [
|
|
"GET /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"
|
|
],
|
|
getHostedRunnersGithubOwnedImagesForOrg: [
|
|
"GET /orgs/{org}/actions/hosted-runners/images/github-owned"
|
|
],
|
|
getHostedRunnersLimitsForOrg: [
|
|
"GET /orgs/{org}/actions/hosted-runners/limits"
|
|
],
|
|
getHostedRunnersMachineSpecsForOrg: [
|
|
"GET /orgs/{org}/actions/hosted-runners/machine-sizes"
|
|
],
|
|
getHostedRunnersPartnerImagesForOrg: [
|
|
"GET /orgs/{org}/actions/hosted-runners/images/partner"
|
|
],
|
|
getHostedRunnersPlatformsForOrg: [
|
|
"GET /orgs/{org}/actions/hosted-runners/platforms"
|
|
],
|
|
getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"],
|
|
getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"],
|
|
getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"],
|
|
getOrgVariable: ["GET /orgs/{org}/actions/variables/{name}"],
|
|
getPendingDeploymentsForRun: [
|
|
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"
|
|
],
|
|
getRepoPermissions: [
|
|
"GET /repos/{owner}/{repo}/actions/permissions",
|
|
{},
|
|
{ renamed: ["actions", "getGithubActionsPermissionsRepository"] }
|
|
],
|
|
getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"],
|
|
getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"],
|
|
getRepoVariable: ["GET /repos/{owner}/{repo}/actions/variables/{name}"],
|
|
getReviewsForRun: [
|
|
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/approvals"
|
|
],
|
|
getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"],
|
|
getSelfHostedRunnerForRepo: [
|
|
"GET /repos/{owner}/{repo}/actions/runners/{runner_id}"
|
|
],
|
|
getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"],
|
|
getWorkflowAccessToRepository: [
|
|
"GET /repos/{owner}/{repo}/actions/permissions/access"
|
|
],
|
|
getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"],
|
|
getWorkflowRunAttempt: [
|
|
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}"
|
|
],
|
|
getWorkflowRunUsage: [
|
|
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"
|
|
],
|
|
getWorkflowUsage: [
|
|
"GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"
|
|
],
|
|
listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"],
|
|
listCustomImageVersionsForOrg: [
|
|
"GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions"
|
|
],
|
|
listCustomImagesForOrg: [
|
|
"GET /orgs/{org}/actions/hosted-runners/images/custom"
|
|
],
|
|
listEnvironmentSecrets: [
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/secrets"
|
|
],
|
|
listEnvironmentVariables: [
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/variables"
|
|
],
|
|
listGithubHostedRunnersInGroupForOrg: [
|
|
"GET /orgs/{org}/actions/runner-groups/{runner_group_id}/hosted-runners"
|
|
],
|
|
listHostedRunnersForOrg: ["GET /orgs/{org}/actions/hosted-runners"],
|
|
listJobsForWorkflowRun: [
|
|
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"
|
|
],
|
|
listJobsForWorkflowRunAttempt: [
|
|
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs"
|
|
],
|
|
listLabelsForSelfHostedRunnerForOrg: [
|
|
"GET /orgs/{org}/actions/runners/{runner_id}/labels"
|
|
],
|
|
listLabelsForSelfHostedRunnerForRepo: [
|
|
"GET /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"
|
|
],
|
|
listOrgSecrets: ["GET /orgs/{org}/actions/secrets"],
|
|
listOrgVariables: ["GET /orgs/{org}/actions/variables"],
|
|
listRepoOrganizationSecrets: [
|
|
"GET /repos/{owner}/{repo}/actions/organization-secrets"
|
|
],
|
|
listRepoOrganizationVariables: [
|
|
"GET /repos/{owner}/{repo}/actions/organization-variables"
|
|
],
|
|
listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"],
|
|
listRepoVariables: ["GET /repos/{owner}/{repo}/actions/variables"],
|
|
listRepoWorkflows: ["GET /repos/{owner}/{repo}/actions/workflows"],
|
|
listRunnerApplicationsForOrg: ["GET /orgs/{org}/actions/runners/downloads"],
|
|
listRunnerApplicationsForRepo: [
|
|
"GET /repos/{owner}/{repo}/actions/runners/downloads"
|
|
],
|
|
listSelectedReposForOrgSecret: [
|
|
"GET /orgs/{org}/actions/secrets/{secret_name}/repositories"
|
|
],
|
|
listSelectedReposForOrgVariable: [
|
|
"GET /orgs/{org}/actions/variables/{name}/repositories"
|
|
],
|
|
listSelectedRepositoriesEnabledGithubActionsOrganization: [
|
|
"GET /orgs/{org}/actions/permissions/repositories"
|
|
],
|
|
listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"],
|
|
listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"],
|
|
listWorkflowRunArtifacts: [
|
|
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"
|
|
],
|
|
listWorkflowRuns: [
|
|
"GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"
|
|
],
|
|
listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"],
|
|
reRunJobForWorkflowRun: [
|
|
"POST /repos/{owner}/{repo}/actions/jobs/{job_id}/rerun"
|
|
],
|
|
reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"],
|
|
reRunWorkflowFailedJobs: [
|
|
"POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun-failed-jobs"
|
|
],
|
|
removeAllCustomLabelsFromSelfHostedRunnerForOrg: [
|
|
"DELETE /orgs/{org}/actions/runners/{runner_id}/labels"
|
|
],
|
|
removeAllCustomLabelsFromSelfHostedRunnerForRepo: [
|
|
"DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"
|
|
],
|
|
removeCustomLabelFromSelfHostedRunnerForOrg: [
|
|
"DELETE /orgs/{org}/actions/runners/{runner_id}/labels/{name}"
|
|
],
|
|
removeCustomLabelFromSelfHostedRunnerForRepo: [
|
|
"DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels/{name}"
|
|
],
|
|
removeSelectedRepoFromOrgSecret: [
|
|
"DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"
|
|
],
|
|
removeSelectedRepoFromOrgVariable: [
|
|
"DELETE /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"
|
|
],
|
|
reviewCustomGatesForRun: [
|
|
"POST /repos/{owner}/{repo}/actions/runs/{run_id}/deployment_protection_rule"
|
|
],
|
|
reviewPendingDeploymentsForRun: [
|
|
"POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"
|
|
],
|
|
setAllowedActionsOrganization: [
|
|
"PUT /orgs/{org}/actions/permissions/selected-actions"
|
|
],
|
|
setAllowedActionsRepository: [
|
|
"PUT /repos/{owner}/{repo}/actions/permissions/selected-actions"
|
|
],
|
|
setCustomLabelsForSelfHostedRunnerForOrg: [
|
|
"PUT /orgs/{org}/actions/runners/{runner_id}/labels"
|
|
],
|
|
setCustomLabelsForSelfHostedRunnerForRepo: [
|
|
"PUT /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"
|
|
],
|
|
setCustomOidcSubClaimForRepo: [
|
|
"PUT /repos/{owner}/{repo}/actions/oidc/customization/sub"
|
|
],
|
|
setGithubActionsDefaultWorkflowPermissionsOrganization: [
|
|
"PUT /orgs/{org}/actions/permissions/workflow"
|
|
],
|
|
setGithubActionsDefaultWorkflowPermissionsRepository: [
|
|
"PUT /repos/{owner}/{repo}/actions/permissions/workflow"
|
|
],
|
|
setGithubActionsPermissionsOrganization: [
|
|
"PUT /orgs/{org}/actions/permissions"
|
|
],
|
|
setGithubActionsPermissionsRepository: [
|
|
"PUT /repos/{owner}/{repo}/actions/permissions"
|
|
],
|
|
setSelectedReposForOrgSecret: [
|
|
"PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"
|
|
],
|
|
setSelectedReposForOrgVariable: [
|
|
"PUT /orgs/{org}/actions/variables/{name}/repositories"
|
|
],
|
|
setSelectedRepositoriesEnabledGithubActionsOrganization: [
|
|
"PUT /orgs/{org}/actions/permissions/repositories"
|
|
],
|
|
setWorkflowAccessToRepository: [
|
|
"PUT /repos/{owner}/{repo}/actions/permissions/access"
|
|
],
|
|
updateEnvironmentVariable: [
|
|
"PATCH /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"
|
|
],
|
|
updateHostedRunnerForOrg: [
|
|
"PATCH /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"
|
|
],
|
|
updateOrgVariable: ["PATCH /orgs/{org}/actions/variables/{name}"],
|
|
updateRepoVariable: [
|
|
"PATCH /repos/{owner}/{repo}/actions/variables/{name}"
|
|
]
|
|
},
|
|
activity: {
|
|
checkRepoIsStarredByAuthenticatedUser: ["GET /user/starred/{owner}/{repo}"],
|
|
deleteRepoSubscription: ["DELETE /repos/{owner}/{repo}/subscription"],
|
|
deleteThreadSubscription: [
|
|
"DELETE /notifications/threads/{thread_id}/subscription"
|
|
],
|
|
getFeeds: ["GET /feeds"],
|
|
getRepoSubscription: ["GET /repos/{owner}/{repo}/subscription"],
|
|
getThread: ["GET /notifications/threads/{thread_id}"],
|
|
getThreadSubscriptionForAuthenticatedUser: [
|
|
"GET /notifications/threads/{thread_id}/subscription"
|
|
],
|
|
listEventsForAuthenticatedUser: ["GET /users/{username}/events"],
|
|
listNotificationsForAuthenticatedUser: ["GET /notifications"],
|
|
listOrgEventsForAuthenticatedUser: [
|
|
"GET /users/{username}/events/orgs/{org}"
|
|
],
|
|
listPublicEvents: ["GET /events"],
|
|
listPublicEventsForRepoNetwork: ["GET /networks/{owner}/{repo}/events"],
|
|
listPublicEventsForUser: ["GET /users/{username}/events/public"],
|
|
listPublicOrgEvents: ["GET /orgs/{org}/events"],
|
|
listReceivedEventsForUser: ["GET /users/{username}/received_events"],
|
|
listReceivedPublicEventsForUser: [
|
|
"GET /users/{username}/received_events/public"
|
|
],
|
|
listRepoEvents: ["GET /repos/{owner}/{repo}/events"],
|
|
listRepoNotificationsForAuthenticatedUser: [
|
|
"GET /repos/{owner}/{repo}/notifications"
|
|
],
|
|
listReposStarredByAuthenticatedUser: ["GET /user/starred"],
|
|
listReposStarredByUser: ["GET /users/{username}/starred"],
|
|
listReposWatchedByUser: ["GET /users/{username}/subscriptions"],
|
|
listStargazersForRepo: ["GET /repos/{owner}/{repo}/stargazers"],
|
|
listWatchedReposForAuthenticatedUser: ["GET /user/subscriptions"],
|
|
listWatchersForRepo: ["GET /repos/{owner}/{repo}/subscribers"],
|
|
markNotificationsAsRead: ["PUT /notifications"],
|
|
markRepoNotificationsAsRead: ["PUT /repos/{owner}/{repo}/notifications"],
|
|
markThreadAsDone: ["DELETE /notifications/threads/{thread_id}"],
|
|
markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"],
|
|
setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"],
|
|
setThreadSubscription: [
|
|
"PUT /notifications/threads/{thread_id}/subscription"
|
|
],
|
|
starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"],
|
|
unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"]
|
|
},
|
|
apps: {
|
|
addRepoToInstallation: [
|
|
"PUT /user/installations/{installation_id}/repositories/{repository_id}",
|
|
{},
|
|
{ renamed: ["apps", "addRepoToInstallationForAuthenticatedUser"] }
|
|
],
|
|
addRepoToInstallationForAuthenticatedUser: [
|
|
"PUT /user/installations/{installation_id}/repositories/{repository_id}"
|
|
],
|
|
checkToken: ["POST /applications/{client_id}/token"],
|
|
createFromManifest: ["POST /app-manifests/{code}/conversions"],
|
|
createInstallationAccessToken: [
|
|
"POST /app/installations/{installation_id}/access_tokens"
|
|
],
|
|
deleteAuthorization: ["DELETE /applications/{client_id}/grant"],
|
|
deleteInstallation: ["DELETE /app/installations/{installation_id}"],
|
|
deleteToken: ["DELETE /applications/{client_id}/token"],
|
|
getAuthenticated: ["GET /app"],
|
|
getBySlug: ["GET /apps/{app_slug}"],
|
|
getInstallation: ["GET /app/installations/{installation_id}"],
|
|
getOrgInstallation: ["GET /orgs/{org}/installation"],
|
|
getRepoInstallation: ["GET /repos/{owner}/{repo}/installation"],
|
|
getSubscriptionPlanForAccount: [
|
|
"GET /marketplace_listing/accounts/{account_id}"
|
|
],
|
|
getSubscriptionPlanForAccountStubbed: [
|
|
"GET /marketplace_listing/stubbed/accounts/{account_id}"
|
|
],
|
|
getUserInstallation: ["GET /users/{username}/installation"],
|
|
getWebhookConfigForApp: ["GET /app/hook/config"],
|
|
getWebhookDelivery: ["GET /app/hook/deliveries/{delivery_id}"],
|
|
listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"],
|
|
listAccountsForPlanStubbed: [
|
|
"GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"
|
|
],
|
|
listInstallationReposForAuthenticatedUser: [
|
|
"GET /user/installations/{installation_id}/repositories"
|
|
],
|
|
listInstallationRequestsForAuthenticatedApp: [
|
|
"GET /app/installation-requests"
|
|
],
|
|
listInstallations: ["GET /app/installations"],
|
|
listInstallationsForAuthenticatedUser: ["GET /user/installations"],
|
|
listPlans: ["GET /marketplace_listing/plans"],
|
|
listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"],
|
|
listReposAccessibleToInstallation: ["GET /installation/repositories"],
|
|
listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"],
|
|
listSubscriptionsForAuthenticatedUserStubbed: [
|
|
"GET /user/marketplace_purchases/stubbed"
|
|
],
|
|
listWebhookDeliveries: ["GET /app/hook/deliveries"],
|
|
redeliverWebhookDelivery: [
|
|
"POST /app/hook/deliveries/{delivery_id}/attempts"
|
|
],
|
|
removeRepoFromInstallation: [
|
|
"DELETE /user/installations/{installation_id}/repositories/{repository_id}",
|
|
{},
|
|
{ renamed: ["apps", "removeRepoFromInstallationForAuthenticatedUser"] }
|
|
],
|
|
removeRepoFromInstallationForAuthenticatedUser: [
|
|
"DELETE /user/installations/{installation_id}/repositories/{repository_id}"
|
|
],
|
|
resetToken: ["PATCH /applications/{client_id}/token"],
|
|
revokeInstallationAccessToken: ["DELETE /installation/token"],
|
|
scopeToken: ["POST /applications/{client_id}/token/scoped"],
|
|
suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"],
|
|
unsuspendInstallation: [
|
|
"DELETE /app/installations/{installation_id}/suspended"
|
|
],
|
|
updateWebhookConfigForApp: ["PATCH /app/hook/config"]
|
|
},
|
|
billing: {
|
|
getGithubActionsBillingOrg: ["GET /orgs/{org}/settings/billing/actions"],
|
|
getGithubActionsBillingUser: [
|
|
"GET /users/{username}/settings/billing/actions"
|
|
],
|
|
getGithubBillingPremiumRequestUsageReportOrg: [
|
|
"GET /organizations/{org}/settings/billing/premium_request/usage"
|
|
],
|
|
getGithubBillingPremiumRequestUsageReportUser: [
|
|
"GET /users/{username}/settings/billing/premium_request/usage"
|
|
],
|
|
getGithubBillingUsageReportOrg: [
|
|
"GET /organizations/{org}/settings/billing/usage"
|
|
],
|
|
getGithubBillingUsageReportUser: [
|
|
"GET /users/{username}/settings/billing/usage"
|
|
],
|
|
getGithubPackagesBillingOrg: ["GET /orgs/{org}/settings/billing/packages"],
|
|
getGithubPackagesBillingUser: [
|
|
"GET /users/{username}/settings/billing/packages"
|
|
],
|
|
getSharedStorageBillingOrg: [
|
|
"GET /orgs/{org}/settings/billing/shared-storage"
|
|
],
|
|
getSharedStorageBillingUser: [
|
|
"GET /users/{username}/settings/billing/shared-storage"
|
|
]
|
|
},
|
|
campaigns: {
|
|
createCampaign: ["POST /orgs/{org}/campaigns"],
|
|
deleteCampaign: ["DELETE /orgs/{org}/campaigns/{campaign_number}"],
|
|
getCampaignSummary: ["GET /orgs/{org}/campaigns/{campaign_number}"],
|
|
listOrgCampaigns: ["GET /orgs/{org}/campaigns"],
|
|
updateCampaign: ["PATCH /orgs/{org}/campaigns/{campaign_number}"]
|
|
},
|
|
checks: {
|
|
create: ["POST /repos/{owner}/{repo}/check-runs"],
|
|
createSuite: ["POST /repos/{owner}/{repo}/check-suites"],
|
|
get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"],
|
|
getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"],
|
|
listAnnotations: [
|
|
"GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations"
|
|
],
|
|
listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"],
|
|
listForSuite: [
|
|
"GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs"
|
|
],
|
|
listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"],
|
|
rerequestRun: [
|
|
"POST /repos/{owner}/{repo}/check-runs/{check_run_id}/rerequest"
|
|
],
|
|
rerequestSuite: [
|
|
"POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest"
|
|
],
|
|
setSuitesPreferences: [
|
|
"PATCH /repos/{owner}/{repo}/check-suites/preferences"
|
|
],
|
|
update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"]
|
|
},
|
|
codeScanning: {
|
|
commitAutofix: [
|
|
"POST /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix/commits"
|
|
],
|
|
createAutofix: [
|
|
"POST /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix"
|
|
],
|
|
createVariantAnalysis: [
|
|
"POST /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses"
|
|
],
|
|
deleteAnalysis: [
|
|
"DELETE /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}{?confirm_delete}"
|
|
],
|
|
deleteCodeqlDatabase: [
|
|
"DELETE /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}"
|
|
],
|
|
getAlert: [
|
|
"GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}",
|
|
{},
|
|
{ renamedParameters: { alert_id: "alert_number" } }
|
|
],
|
|
getAnalysis: [
|
|
"GET /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}"
|
|
],
|
|
getAutofix: [
|
|
"GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix"
|
|
],
|
|
getCodeqlDatabase: [
|
|
"GET /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}"
|
|
],
|
|
getDefaultSetup: ["GET /repos/{owner}/{repo}/code-scanning/default-setup"],
|
|
getSarif: ["GET /repos/{owner}/{repo}/code-scanning/sarifs/{sarif_id}"],
|
|
getVariantAnalysis: [
|
|
"GET /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses/{codeql_variant_analysis_id}"
|
|
],
|
|
getVariantAnalysisRepoTask: [
|
|
"GET /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses/{codeql_variant_analysis_id}/repos/{repo_owner}/{repo_name}"
|
|
],
|
|
listAlertInstances: [
|
|
"GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances"
|
|
],
|
|
listAlertsForOrg: ["GET /orgs/{org}/code-scanning/alerts"],
|
|
listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"],
|
|
listAlertsInstances: [
|
|
"GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances",
|
|
{},
|
|
{ renamed: ["codeScanning", "listAlertInstances"] }
|
|
],
|
|
listCodeqlDatabases: [
|
|
"GET /repos/{owner}/{repo}/code-scanning/codeql/databases"
|
|
],
|
|
listRecentAnalyses: ["GET /repos/{owner}/{repo}/code-scanning/analyses"],
|
|
updateAlert: [
|
|
"PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}"
|
|
],
|
|
updateDefaultSetup: [
|
|
"PATCH /repos/{owner}/{repo}/code-scanning/default-setup"
|
|
],
|
|
uploadSarif: ["POST /repos/{owner}/{repo}/code-scanning/sarifs"]
|
|
},
|
|
codeSecurity: {
|
|
attachConfiguration: [
|
|
"POST /orgs/{org}/code-security/configurations/{configuration_id}/attach"
|
|
],
|
|
attachEnterpriseConfiguration: [
|
|
"POST /enterprises/{enterprise}/code-security/configurations/{configuration_id}/attach"
|
|
],
|
|
createConfiguration: ["POST /orgs/{org}/code-security/configurations"],
|
|
createConfigurationForEnterprise: [
|
|
"POST /enterprises/{enterprise}/code-security/configurations"
|
|
],
|
|
deleteConfiguration: [
|
|
"DELETE /orgs/{org}/code-security/configurations/{configuration_id}"
|
|
],
|
|
deleteConfigurationForEnterprise: [
|
|
"DELETE /enterprises/{enterprise}/code-security/configurations/{configuration_id}"
|
|
],
|
|
detachConfiguration: [
|
|
"DELETE /orgs/{org}/code-security/configurations/detach"
|
|
],
|
|
getConfiguration: [
|
|
"GET /orgs/{org}/code-security/configurations/{configuration_id}"
|
|
],
|
|
getConfigurationForRepository: [
|
|
"GET /repos/{owner}/{repo}/code-security-configuration"
|
|
],
|
|
getConfigurationsForEnterprise: [
|
|
"GET /enterprises/{enterprise}/code-security/configurations"
|
|
],
|
|
getConfigurationsForOrg: ["GET /orgs/{org}/code-security/configurations"],
|
|
getDefaultConfigurations: [
|
|
"GET /orgs/{org}/code-security/configurations/defaults"
|
|
],
|
|
getDefaultConfigurationsForEnterprise: [
|
|
"GET /enterprises/{enterprise}/code-security/configurations/defaults"
|
|
],
|
|
getRepositoriesForConfiguration: [
|
|
"GET /orgs/{org}/code-security/configurations/{configuration_id}/repositories"
|
|
],
|
|
getRepositoriesForEnterpriseConfiguration: [
|
|
"GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}/repositories"
|
|
],
|
|
getSingleConfigurationForEnterprise: [
|
|
"GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}"
|
|
],
|
|
setConfigurationAsDefault: [
|
|
"PUT /orgs/{org}/code-security/configurations/{configuration_id}/defaults"
|
|
],
|
|
setConfigurationAsDefaultForEnterprise: [
|
|
"PUT /enterprises/{enterprise}/code-security/configurations/{configuration_id}/defaults"
|
|
],
|
|
updateConfiguration: [
|
|
"PATCH /orgs/{org}/code-security/configurations/{configuration_id}"
|
|
],
|
|
updateEnterpriseConfiguration: [
|
|
"PATCH /enterprises/{enterprise}/code-security/configurations/{configuration_id}"
|
|
]
|
|
},
|
|
codesOfConduct: {
|
|
getAllCodesOfConduct: ["GET /codes_of_conduct"],
|
|
getConductCode: ["GET /codes_of_conduct/{key}"]
|
|
},
|
|
codespaces: {
|
|
addRepositoryForSecretForAuthenticatedUser: [
|
|
"PUT /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"
|
|
],
|
|
addSelectedRepoToOrgSecret: [
|
|
"PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"
|
|
],
|
|
checkPermissionsForDevcontainer: [
|
|
"GET /repos/{owner}/{repo}/codespaces/permissions_check"
|
|
],
|
|
codespaceMachinesForAuthenticatedUser: [
|
|
"GET /user/codespaces/{codespace_name}/machines"
|
|
],
|
|
createForAuthenticatedUser: ["POST /user/codespaces"],
|
|
createOrUpdateOrgSecret: [
|
|
"PUT /orgs/{org}/codespaces/secrets/{secret_name}"
|
|
],
|
|
createOrUpdateRepoSecret: [
|
|
"PUT /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"
|
|
],
|
|
createOrUpdateSecretForAuthenticatedUser: [
|
|
"PUT /user/codespaces/secrets/{secret_name}"
|
|
],
|
|
createWithPrForAuthenticatedUser: [
|
|
"POST /repos/{owner}/{repo}/pulls/{pull_number}/codespaces"
|
|
],
|
|
createWithRepoForAuthenticatedUser: [
|
|
"POST /repos/{owner}/{repo}/codespaces"
|
|
],
|
|
deleteForAuthenticatedUser: ["DELETE /user/codespaces/{codespace_name}"],
|
|
deleteFromOrganization: [
|
|
"DELETE /orgs/{org}/members/{username}/codespaces/{codespace_name}"
|
|
],
|
|
deleteOrgSecret: ["DELETE /orgs/{org}/codespaces/secrets/{secret_name}"],
|
|
deleteRepoSecret: [
|
|
"DELETE /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"
|
|
],
|
|
deleteSecretForAuthenticatedUser: [
|
|
"DELETE /user/codespaces/secrets/{secret_name}"
|
|
],
|
|
exportForAuthenticatedUser: [
|
|
"POST /user/codespaces/{codespace_name}/exports"
|
|
],
|
|
getCodespacesForUserInOrg: [
|
|
"GET /orgs/{org}/members/{username}/codespaces"
|
|
],
|
|
getExportDetailsForAuthenticatedUser: [
|
|
"GET /user/codespaces/{codespace_name}/exports/{export_id}"
|
|
],
|
|
getForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}"],
|
|
getOrgPublicKey: ["GET /orgs/{org}/codespaces/secrets/public-key"],
|
|
getOrgSecret: ["GET /orgs/{org}/codespaces/secrets/{secret_name}"],
|
|
getPublicKeyForAuthenticatedUser: [
|
|
"GET /user/codespaces/secrets/public-key"
|
|
],
|
|
getRepoPublicKey: [
|
|
"GET /repos/{owner}/{repo}/codespaces/secrets/public-key"
|
|
],
|
|
getRepoSecret: [
|
|
"GET /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"
|
|
],
|
|
getSecretForAuthenticatedUser: [
|
|
"GET /user/codespaces/secrets/{secret_name}"
|
|
],
|
|
listDevcontainersInRepositoryForAuthenticatedUser: [
|
|
"GET /repos/{owner}/{repo}/codespaces/devcontainers"
|
|
],
|
|
listForAuthenticatedUser: ["GET /user/codespaces"],
|
|
listInOrganization: [
|
|
"GET /orgs/{org}/codespaces",
|
|
{},
|
|
{ renamedParameters: { org_id: "org" } }
|
|
],
|
|
listInRepositoryForAuthenticatedUser: [
|
|
"GET /repos/{owner}/{repo}/codespaces"
|
|
],
|
|
listOrgSecrets: ["GET /orgs/{org}/codespaces/secrets"],
|
|
listRepoSecrets: ["GET /repos/{owner}/{repo}/codespaces/secrets"],
|
|
listRepositoriesForSecretForAuthenticatedUser: [
|
|
"GET /user/codespaces/secrets/{secret_name}/repositories"
|
|
],
|
|
listSecretsForAuthenticatedUser: ["GET /user/codespaces/secrets"],
|
|
listSelectedReposForOrgSecret: [
|
|
"GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories"
|
|
],
|
|
preFlightWithRepoForAuthenticatedUser: [
|
|
"GET /repos/{owner}/{repo}/codespaces/new"
|
|
],
|
|
publishForAuthenticatedUser: [
|
|
"POST /user/codespaces/{codespace_name}/publish"
|
|
],
|
|
removeRepositoryForSecretForAuthenticatedUser: [
|
|
"DELETE /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"
|
|
],
|
|
removeSelectedRepoFromOrgSecret: [
|
|
"DELETE /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"
|
|
],
|
|
repoMachinesForAuthenticatedUser: [
|
|
"GET /repos/{owner}/{repo}/codespaces/machines"
|
|
],
|
|
setRepositoriesForSecretForAuthenticatedUser: [
|
|
"PUT /user/codespaces/secrets/{secret_name}/repositories"
|
|
],
|
|
setSelectedReposForOrgSecret: [
|
|
"PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories"
|
|
],
|
|
startForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/start"],
|
|
stopForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/stop"],
|
|
stopInOrganization: [
|
|
"POST /orgs/{org}/members/{username}/codespaces/{codespace_name}/stop"
|
|
],
|
|
updateForAuthenticatedUser: ["PATCH /user/codespaces/{codespace_name}"]
|
|
},
|
|
copilot: {
|
|
addCopilotSeatsForTeams: [
|
|
"POST /orgs/{org}/copilot/billing/selected_teams"
|
|
],
|
|
addCopilotSeatsForUsers: [
|
|
"POST /orgs/{org}/copilot/billing/selected_users"
|
|
],
|
|
cancelCopilotSeatAssignmentForTeams: [
|
|
"DELETE /orgs/{org}/copilot/billing/selected_teams"
|
|
],
|
|
cancelCopilotSeatAssignmentForUsers: [
|
|
"DELETE /orgs/{org}/copilot/billing/selected_users"
|
|
],
|
|
copilotMetricsForOrganization: ["GET /orgs/{org}/copilot/metrics"],
|
|
copilotMetricsForTeam: ["GET /orgs/{org}/team/{team_slug}/copilot/metrics"],
|
|
getCopilotOrganizationDetails: ["GET /orgs/{org}/copilot/billing"],
|
|
getCopilotSeatDetailsForUser: [
|
|
"GET /orgs/{org}/members/{username}/copilot"
|
|
],
|
|
listCopilotSeats: ["GET /orgs/{org}/copilot/billing/seats"]
|
|
},
|
|
credentials: { revoke: ["POST /credentials/revoke"] },
|
|
dependabot: {
|
|
addSelectedRepoToOrgSecret: [
|
|
"PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"
|
|
],
|
|
createOrUpdateOrgSecret: [
|
|
"PUT /orgs/{org}/dependabot/secrets/{secret_name}"
|
|
],
|
|
createOrUpdateRepoSecret: [
|
|
"PUT /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"
|
|
],
|
|
deleteOrgSecret: ["DELETE /orgs/{org}/dependabot/secrets/{secret_name}"],
|
|
deleteRepoSecret: [
|
|
"DELETE /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"
|
|
],
|
|
getAlert: ["GET /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"],
|
|
getOrgPublicKey: ["GET /orgs/{org}/dependabot/secrets/public-key"],
|
|
getOrgSecret: ["GET /orgs/{org}/dependabot/secrets/{secret_name}"],
|
|
getRepoPublicKey: [
|
|
"GET /repos/{owner}/{repo}/dependabot/secrets/public-key"
|
|
],
|
|
getRepoSecret: [
|
|
"GET /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"
|
|
],
|
|
listAlertsForEnterprise: [
|
|
"GET /enterprises/{enterprise}/dependabot/alerts"
|
|
],
|
|
listAlertsForOrg: ["GET /orgs/{org}/dependabot/alerts"],
|
|
listAlertsForRepo: ["GET /repos/{owner}/{repo}/dependabot/alerts"],
|
|
listOrgSecrets: ["GET /orgs/{org}/dependabot/secrets"],
|
|
listRepoSecrets: ["GET /repos/{owner}/{repo}/dependabot/secrets"],
|
|
listSelectedReposForOrgSecret: [
|
|
"GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories"
|
|
],
|
|
removeSelectedRepoFromOrgSecret: [
|
|
"DELETE /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"
|
|
],
|
|
repositoryAccessForOrg: [
|
|
"GET /organizations/{org}/dependabot/repository-access"
|
|
],
|
|
setRepositoryAccessDefaultLevel: [
|
|
"PUT /organizations/{org}/dependabot/repository-access/default-level"
|
|
],
|
|
setSelectedReposForOrgSecret: [
|
|
"PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories"
|
|
],
|
|
updateAlert: [
|
|
"PATCH /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"
|
|
],
|
|
updateRepositoryAccessForOrg: [
|
|
"PATCH /organizations/{org}/dependabot/repository-access"
|
|
]
|
|
},
|
|
dependencyGraph: {
|
|
createRepositorySnapshot: [
|
|
"POST /repos/{owner}/{repo}/dependency-graph/snapshots"
|
|
],
|
|
diffRange: [
|
|
"GET /repos/{owner}/{repo}/dependency-graph/compare/{basehead}"
|
|
],
|
|
exportSbom: ["GET /repos/{owner}/{repo}/dependency-graph/sbom"]
|
|
},
|
|
emojis: { get: ["GET /emojis"] },
|
|
enterpriseTeamMemberships: {
|
|
add: [
|
|
"PUT /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"
|
|
],
|
|
bulkAdd: [
|
|
"POST /enterprises/{enterprise}/teams/{enterprise-team}/memberships/add"
|
|
],
|
|
bulkRemove: [
|
|
"POST /enterprises/{enterprise}/teams/{enterprise-team}/memberships/remove"
|
|
],
|
|
get: [
|
|
"GET /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"
|
|
],
|
|
list: ["GET /enterprises/{enterprise}/teams/{enterprise-team}/memberships"],
|
|
remove: [
|
|
"DELETE /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"
|
|
]
|
|
},
|
|
enterpriseTeamOrganizations: {
|
|
add: [
|
|
"PUT /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"
|
|
],
|
|
bulkAdd: [
|
|
"POST /enterprises/{enterprise}/teams/{enterprise-team}/organizations/add"
|
|
],
|
|
bulkRemove: [
|
|
"POST /enterprises/{enterprise}/teams/{enterprise-team}/organizations/remove"
|
|
],
|
|
delete: [
|
|
"DELETE /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"
|
|
],
|
|
getAssignment: [
|
|
"GET /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"
|
|
],
|
|
getAssignments: [
|
|
"GET /enterprises/{enterprise}/teams/{enterprise-team}/organizations"
|
|
]
|
|
},
|
|
enterpriseTeams: {
|
|
create: ["POST /enterprises/{enterprise}/teams"],
|
|
delete: ["DELETE /enterprises/{enterprise}/teams/{team_slug}"],
|
|
get: ["GET /enterprises/{enterprise}/teams/{team_slug}"],
|
|
list: ["GET /enterprises/{enterprise}/teams"],
|
|
update: ["PATCH /enterprises/{enterprise}/teams/{team_slug}"]
|
|
},
|
|
gists: {
|
|
checkIsStarred: ["GET /gists/{gist_id}/star"],
|
|
create: ["POST /gists"],
|
|
createComment: ["POST /gists/{gist_id}/comments"],
|
|
delete: ["DELETE /gists/{gist_id}"],
|
|
deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"],
|
|
fork: ["POST /gists/{gist_id}/forks"],
|
|
get: ["GET /gists/{gist_id}"],
|
|
getComment: ["GET /gists/{gist_id}/comments/{comment_id}"],
|
|
getRevision: ["GET /gists/{gist_id}/{sha}"],
|
|
list: ["GET /gists"],
|
|
listComments: ["GET /gists/{gist_id}/comments"],
|
|
listCommits: ["GET /gists/{gist_id}/commits"],
|
|
listForUser: ["GET /users/{username}/gists"],
|
|
listForks: ["GET /gists/{gist_id}/forks"],
|
|
listPublic: ["GET /gists/public"],
|
|
listStarred: ["GET /gists/starred"],
|
|
star: ["PUT /gists/{gist_id}/star"],
|
|
unstar: ["DELETE /gists/{gist_id}/star"],
|
|
update: ["PATCH /gists/{gist_id}"],
|
|
updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"]
|
|
},
|
|
git: {
|
|
createBlob: ["POST /repos/{owner}/{repo}/git/blobs"],
|
|
createCommit: ["POST /repos/{owner}/{repo}/git/commits"],
|
|
createRef: ["POST /repos/{owner}/{repo}/git/refs"],
|
|
createTag: ["POST /repos/{owner}/{repo}/git/tags"],
|
|
createTree: ["POST /repos/{owner}/{repo}/git/trees"],
|
|
deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"],
|
|
getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"],
|
|
getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"],
|
|
getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"],
|
|
getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"],
|
|
getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"],
|
|
listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"],
|
|
updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"]
|
|
},
|
|
gitignore: {
|
|
getAllTemplates: ["GET /gitignore/templates"],
|
|
getTemplate: ["GET /gitignore/templates/{name}"]
|
|
},
|
|
hostedCompute: {
|
|
createNetworkConfigurationForOrg: [
|
|
"POST /orgs/{org}/settings/network-configurations"
|
|
],
|
|
deleteNetworkConfigurationFromOrg: [
|
|
"DELETE /orgs/{org}/settings/network-configurations/{network_configuration_id}"
|
|
],
|
|
getNetworkConfigurationForOrg: [
|
|
"GET /orgs/{org}/settings/network-configurations/{network_configuration_id}"
|
|
],
|
|
getNetworkSettingsForOrg: [
|
|
"GET /orgs/{org}/settings/network-settings/{network_settings_id}"
|
|
],
|
|
listNetworkConfigurationsForOrg: [
|
|
"GET /orgs/{org}/settings/network-configurations"
|
|
],
|
|
updateNetworkConfigurationForOrg: [
|
|
"PATCH /orgs/{org}/settings/network-configurations/{network_configuration_id}"
|
|
]
|
|
},
|
|
interactions: {
|
|
getRestrictionsForAuthenticatedUser: ["GET /user/interaction-limits"],
|
|
getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits"],
|
|
getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits"],
|
|
getRestrictionsForYourPublicRepos: [
|
|
"GET /user/interaction-limits",
|
|
{},
|
|
{ renamed: ["interactions", "getRestrictionsForAuthenticatedUser"] }
|
|
],
|
|
removeRestrictionsForAuthenticatedUser: ["DELETE /user/interaction-limits"],
|
|
removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits"],
|
|
removeRestrictionsForRepo: [
|
|
"DELETE /repos/{owner}/{repo}/interaction-limits"
|
|
],
|
|
removeRestrictionsForYourPublicRepos: [
|
|
"DELETE /user/interaction-limits",
|
|
{},
|
|
{ renamed: ["interactions", "removeRestrictionsForAuthenticatedUser"] }
|
|
],
|
|
setRestrictionsForAuthenticatedUser: ["PUT /user/interaction-limits"],
|
|
setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits"],
|
|
setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits"],
|
|
setRestrictionsForYourPublicRepos: [
|
|
"PUT /user/interaction-limits",
|
|
{},
|
|
{ renamed: ["interactions", "setRestrictionsForAuthenticatedUser"] }
|
|
]
|
|
},
|
|
issues: {
|
|
addAssignees: [
|
|
"POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"
|
|
],
|
|
addBlockedByDependency: [
|
|
"POST /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by"
|
|
],
|
|
addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"],
|
|
addSubIssue: [
|
|
"POST /repos/{owner}/{repo}/issues/{issue_number}/sub_issues"
|
|
],
|
|
checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"],
|
|
checkUserCanBeAssignedToIssue: [
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/assignees/{assignee}"
|
|
],
|
|
create: ["POST /repos/{owner}/{repo}/issues"],
|
|
createComment: [
|
|
"POST /repos/{owner}/{repo}/issues/{issue_number}/comments"
|
|
],
|
|
createLabel: ["POST /repos/{owner}/{repo}/labels"],
|
|
createMilestone: ["POST /repos/{owner}/{repo}/milestones"],
|
|
deleteComment: [
|
|
"DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"
|
|
],
|
|
deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"],
|
|
deleteMilestone: [
|
|
"DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"
|
|
],
|
|
get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"],
|
|
getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"],
|
|
getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"],
|
|
getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"],
|
|
getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"],
|
|
getParent: ["GET /repos/{owner}/{repo}/issues/{issue_number}/parent"],
|
|
list: ["GET /issues"],
|
|
listAssignees: ["GET /repos/{owner}/{repo}/assignees"],
|
|
listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"],
|
|
listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"],
|
|
listDependenciesBlockedBy: [
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by"
|
|
],
|
|
listDependenciesBlocking: [
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocking"
|
|
],
|
|
listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"],
|
|
listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"],
|
|
listEventsForTimeline: [
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/timeline"
|
|
],
|
|
listForAuthenticatedUser: ["GET /user/issues"],
|
|
listForOrg: ["GET /orgs/{org}/issues"],
|
|
listForRepo: ["GET /repos/{owner}/{repo}/issues"],
|
|
listLabelsForMilestone: [
|
|
"GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"
|
|
],
|
|
listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"],
|
|
listLabelsOnIssue: [
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/labels"
|
|
],
|
|
listMilestones: ["GET /repos/{owner}/{repo}/milestones"],
|
|
listSubIssues: [
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/sub_issues"
|
|
],
|
|
lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"],
|
|
removeAllLabels: [
|
|
"DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"
|
|
],
|
|
removeAssignees: [
|
|
"DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"
|
|
],
|
|
removeDependencyBlockedBy: [
|
|
"DELETE /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by/{issue_id}"
|
|
],
|
|
removeLabel: [
|
|
"DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"
|
|
],
|
|
removeSubIssue: [
|
|
"DELETE /repos/{owner}/{repo}/issues/{issue_number}/sub_issue"
|
|
],
|
|
reprioritizeSubIssue: [
|
|
"PATCH /repos/{owner}/{repo}/issues/{issue_number}/sub_issues/priority"
|
|
],
|
|
setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"],
|
|
unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"],
|
|
update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"],
|
|
updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"],
|
|
updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"],
|
|
updateMilestone: [
|
|
"PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"
|
|
]
|
|
},
|
|
licenses: {
|
|
get: ["GET /licenses/{license}"],
|
|
getAllCommonlyUsed: ["GET /licenses"],
|
|
getForRepo: ["GET /repos/{owner}/{repo}/license"]
|
|
},
|
|
markdown: {
|
|
render: ["POST /markdown"],
|
|
renderRaw: [
|
|
"POST /markdown/raw",
|
|
{ headers: { "content-type": "text/plain; charset=utf-8" } }
|
|
]
|
|
},
|
|
meta: {
|
|
get: ["GET /meta"],
|
|
getAllVersions: ["GET /versions"],
|
|
getOctocat: ["GET /octocat"],
|
|
getZen: ["GET /zen"],
|
|
root: ["GET /"]
|
|
},
|
|
migrations: {
|
|
deleteArchiveForAuthenticatedUser: [
|
|
"DELETE /user/migrations/{migration_id}/archive"
|
|
],
|
|
deleteArchiveForOrg: [
|
|
"DELETE /orgs/{org}/migrations/{migration_id}/archive"
|
|
],
|
|
downloadArchiveForOrg: [
|
|
"GET /orgs/{org}/migrations/{migration_id}/archive"
|
|
],
|
|
getArchiveForAuthenticatedUser: [
|
|
"GET /user/migrations/{migration_id}/archive"
|
|
],
|
|
getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}"],
|
|
getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}"],
|
|
listForAuthenticatedUser: ["GET /user/migrations"],
|
|
listForOrg: ["GET /orgs/{org}/migrations"],
|
|
listReposForAuthenticatedUser: [
|
|
"GET /user/migrations/{migration_id}/repositories"
|
|
],
|
|
listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories"],
|
|
listReposForUser: [
|
|
"GET /user/migrations/{migration_id}/repositories",
|
|
{},
|
|
{ renamed: ["migrations", "listReposForAuthenticatedUser"] }
|
|
],
|
|
startForAuthenticatedUser: ["POST /user/migrations"],
|
|
startForOrg: ["POST /orgs/{org}/migrations"],
|
|
unlockRepoForAuthenticatedUser: [
|
|
"DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock"
|
|
],
|
|
unlockRepoForOrg: [
|
|
"DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock"
|
|
]
|
|
},
|
|
oidc: {
|
|
getOidcCustomSubTemplateForOrg: [
|
|
"GET /orgs/{org}/actions/oidc/customization/sub"
|
|
],
|
|
updateOidcCustomSubTemplateForOrg: [
|
|
"PUT /orgs/{org}/actions/oidc/customization/sub"
|
|
]
|
|
},
|
|
orgs: {
|
|
addSecurityManagerTeam: [
|
|
"PUT /orgs/{org}/security-managers/teams/{team_slug}",
|
|
{},
|
|
{
|
|
deprecated: "octokit.rest.orgs.addSecurityManagerTeam() is deprecated, see https://docs.github.com/rest/orgs/security-managers#add-a-security-manager-team"
|
|
}
|
|
],
|
|
assignTeamToOrgRole: [
|
|
"PUT /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}"
|
|
],
|
|
assignUserToOrgRole: [
|
|
"PUT /orgs/{org}/organization-roles/users/{username}/{role_id}"
|
|
],
|
|
blockUser: ["PUT /orgs/{org}/blocks/{username}"],
|
|
cancelInvitation: ["DELETE /orgs/{org}/invitations/{invitation_id}"],
|
|
checkBlockedUser: ["GET /orgs/{org}/blocks/{username}"],
|
|
checkMembershipForUser: ["GET /orgs/{org}/members/{username}"],
|
|
checkPublicMembershipForUser: ["GET /orgs/{org}/public_members/{username}"],
|
|
convertMemberToOutsideCollaborator: [
|
|
"PUT /orgs/{org}/outside_collaborators/{username}"
|
|
],
|
|
createArtifactStorageRecord: [
|
|
"POST /orgs/{org}/artifacts/metadata/storage-record"
|
|
],
|
|
createInvitation: ["POST /orgs/{org}/invitations"],
|
|
createIssueType: ["POST /orgs/{org}/issue-types"],
|
|
createWebhook: ["POST /orgs/{org}/hooks"],
|
|
customPropertiesForOrgsCreateOrUpdateOrganizationValues: [
|
|
"PATCH /organizations/{org}/org-properties/values"
|
|
],
|
|
customPropertiesForOrgsGetOrganizationValues: [
|
|
"GET /organizations/{org}/org-properties/values"
|
|
],
|
|
customPropertiesForReposCreateOrUpdateOrganizationDefinition: [
|
|
"PUT /orgs/{org}/properties/schema/{custom_property_name}"
|
|
],
|
|
customPropertiesForReposCreateOrUpdateOrganizationDefinitions: [
|
|
"PATCH /orgs/{org}/properties/schema"
|
|
],
|
|
customPropertiesForReposCreateOrUpdateOrganizationValues: [
|
|
"PATCH /orgs/{org}/properties/values"
|
|
],
|
|
customPropertiesForReposDeleteOrganizationDefinition: [
|
|
"DELETE /orgs/{org}/properties/schema/{custom_property_name}"
|
|
],
|
|
customPropertiesForReposGetOrganizationDefinition: [
|
|
"GET /orgs/{org}/properties/schema/{custom_property_name}"
|
|
],
|
|
customPropertiesForReposGetOrganizationDefinitions: [
|
|
"GET /orgs/{org}/properties/schema"
|
|
],
|
|
customPropertiesForReposGetOrganizationValues: [
|
|
"GET /orgs/{org}/properties/values"
|
|
],
|
|
delete: ["DELETE /orgs/{org}"],
|
|
deleteAttestationsBulk: ["POST /orgs/{org}/attestations/delete-request"],
|
|
deleteAttestationsById: [
|
|
"DELETE /orgs/{org}/attestations/{attestation_id}"
|
|
],
|
|
deleteAttestationsBySubjectDigest: [
|
|
"DELETE /orgs/{org}/attestations/digest/{subject_digest}"
|
|
],
|
|
deleteIssueType: ["DELETE /orgs/{org}/issue-types/{issue_type_id}"],
|
|
deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"],
|
|
disableSelectedRepositoryImmutableReleasesOrganization: [
|
|
"DELETE /orgs/{org}/settings/immutable-releases/repositories/{repository_id}"
|
|
],
|
|
enableSelectedRepositoryImmutableReleasesOrganization: [
|
|
"PUT /orgs/{org}/settings/immutable-releases/repositories/{repository_id}"
|
|
],
|
|
get: ["GET /orgs/{org}"],
|
|
getImmutableReleasesSettings: [
|
|
"GET /orgs/{org}/settings/immutable-releases"
|
|
],
|
|
getImmutableReleasesSettingsRepositories: [
|
|
"GET /orgs/{org}/settings/immutable-releases/repositories"
|
|
],
|
|
getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"],
|
|
getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"],
|
|
getOrgRole: ["GET /orgs/{org}/organization-roles/{role_id}"],
|
|
getOrgRulesetHistory: ["GET /orgs/{org}/rulesets/{ruleset_id}/history"],
|
|
getOrgRulesetVersion: [
|
|
"GET /orgs/{org}/rulesets/{ruleset_id}/history/{version_id}"
|
|
],
|
|
getWebhook: ["GET /orgs/{org}/hooks/{hook_id}"],
|
|
getWebhookConfigForOrg: ["GET /orgs/{org}/hooks/{hook_id}/config"],
|
|
getWebhookDelivery: [
|
|
"GET /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}"
|
|
],
|
|
list: ["GET /organizations"],
|
|
listAppInstallations: ["GET /orgs/{org}/installations"],
|
|
listArtifactStorageRecords: [
|
|
"GET /orgs/{org}/artifacts/{subject_digest}/metadata/storage-records"
|
|
],
|
|
listAttestationRepositories: ["GET /orgs/{org}/attestations/repositories"],
|
|
listAttestations: ["GET /orgs/{org}/attestations/{subject_digest}"],
|
|
listAttestationsBulk: [
|
|
"POST /orgs/{org}/attestations/bulk-list{?per_page,before,after}"
|
|
],
|
|
listBlockedUsers: ["GET /orgs/{org}/blocks"],
|
|
listFailedInvitations: ["GET /orgs/{org}/failed_invitations"],
|
|
listForAuthenticatedUser: ["GET /user/orgs"],
|
|
listForUser: ["GET /users/{username}/orgs"],
|
|
listInvitationTeams: ["GET /orgs/{org}/invitations/{invitation_id}/teams"],
|
|
listIssueTypes: ["GET /orgs/{org}/issue-types"],
|
|
listMembers: ["GET /orgs/{org}/members"],
|
|
listMembershipsForAuthenticatedUser: ["GET /user/memberships/orgs"],
|
|
listOrgRoleTeams: ["GET /orgs/{org}/organization-roles/{role_id}/teams"],
|
|
listOrgRoleUsers: ["GET /orgs/{org}/organization-roles/{role_id}/users"],
|
|
listOrgRoles: ["GET /orgs/{org}/organization-roles"],
|
|
listOrganizationFineGrainedPermissions: [
|
|
"GET /orgs/{org}/organization-fine-grained-permissions"
|
|
],
|
|
listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"],
|
|
listPatGrantRepositories: [
|
|
"GET /orgs/{org}/personal-access-tokens/{pat_id}/repositories"
|
|
],
|
|
listPatGrantRequestRepositories: [
|
|
"GET /orgs/{org}/personal-access-token-requests/{pat_request_id}/repositories"
|
|
],
|
|
listPatGrantRequests: ["GET /orgs/{org}/personal-access-token-requests"],
|
|
listPatGrants: ["GET /orgs/{org}/personal-access-tokens"],
|
|
listPendingInvitations: ["GET /orgs/{org}/invitations"],
|
|
listPublicMembers: ["GET /orgs/{org}/public_members"],
|
|
listSecurityManagerTeams: [
|
|
"GET /orgs/{org}/security-managers",
|
|
{},
|
|
{
|
|
deprecated: "octokit.rest.orgs.listSecurityManagerTeams() is deprecated, see https://docs.github.com/rest/orgs/security-managers#list-security-manager-teams"
|
|
}
|
|
],
|
|
listWebhookDeliveries: ["GET /orgs/{org}/hooks/{hook_id}/deliveries"],
|
|
listWebhooks: ["GET /orgs/{org}/hooks"],
|
|
pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"],
|
|
redeliverWebhookDelivery: [
|
|
"POST /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"
|
|
],
|
|
removeMember: ["DELETE /orgs/{org}/members/{username}"],
|
|
removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"],
|
|
removeOutsideCollaborator: [
|
|
"DELETE /orgs/{org}/outside_collaborators/{username}"
|
|
],
|
|
removePublicMembershipForAuthenticatedUser: [
|
|
"DELETE /orgs/{org}/public_members/{username}"
|
|
],
|
|
removeSecurityManagerTeam: [
|
|
"DELETE /orgs/{org}/security-managers/teams/{team_slug}",
|
|
{},
|
|
{
|
|
deprecated: "octokit.rest.orgs.removeSecurityManagerTeam() is deprecated, see https://docs.github.com/rest/orgs/security-managers#remove-a-security-manager-team"
|
|
}
|
|
],
|
|
reviewPatGrantRequest: [
|
|
"POST /orgs/{org}/personal-access-token-requests/{pat_request_id}"
|
|
],
|
|
reviewPatGrantRequestsInBulk: [
|
|
"POST /orgs/{org}/personal-access-token-requests"
|
|
],
|
|
revokeAllOrgRolesTeam: [
|
|
"DELETE /orgs/{org}/organization-roles/teams/{team_slug}"
|
|
],
|
|
revokeAllOrgRolesUser: [
|
|
"DELETE /orgs/{org}/organization-roles/users/{username}"
|
|
],
|
|
revokeOrgRoleTeam: [
|
|
"DELETE /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}"
|
|
],
|
|
revokeOrgRoleUser: [
|
|
"DELETE /orgs/{org}/organization-roles/users/{username}/{role_id}"
|
|
],
|
|
setImmutableReleasesSettings: [
|
|
"PUT /orgs/{org}/settings/immutable-releases"
|
|
],
|
|
setImmutableReleasesSettingsRepositories: [
|
|
"PUT /orgs/{org}/settings/immutable-releases/repositories"
|
|
],
|
|
setMembershipForUser: ["PUT /orgs/{org}/memberships/{username}"],
|
|
setPublicMembershipForAuthenticatedUser: [
|
|
"PUT /orgs/{org}/public_members/{username}"
|
|
],
|
|
unblockUser: ["DELETE /orgs/{org}/blocks/{username}"],
|
|
update: ["PATCH /orgs/{org}"],
|
|
updateIssueType: ["PUT /orgs/{org}/issue-types/{issue_type_id}"],
|
|
updateMembershipForAuthenticatedUser: [
|
|
"PATCH /user/memberships/orgs/{org}"
|
|
],
|
|
updatePatAccess: ["POST /orgs/{org}/personal-access-tokens/{pat_id}"],
|
|
updatePatAccesses: ["POST /orgs/{org}/personal-access-tokens"],
|
|
updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"],
|
|
updateWebhookConfigForOrg: ["PATCH /orgs/{org}/hooks/{hook_id}/config"]
|
|
},
|
|
packages: {
|
|
deletePackageForAuthenticatedUser: [
|
|
"DELETE /user/packages/{package_type}/{package_name}"
|
|
],
|
|
deletePackageForOrg: [
|
|
"DELETE /orgs/{org}/packages/{package_type}/{package_name}"
|
|
],
|
|
deletePackageForUser: [
|
|
"DELETE /users/{username}/packages/{package_type}/{package_name}"
|
|
],
|
|
deletePackageVersionForAuthenticatedUser: [
|
|
"DELETE /user/packages/{package_type}/{package_name}/versions/{package_version_id}"
|
|
],
|
|
deletePackageVersionForOrg: [
|
|
"DELETE /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"
|
|
],
|
|
deletePackageVersionForUser: [
|
|
"DELETE /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"
|
|
],
|
|
getAllPackageVersionsForAPackageOwnedByAnOrg: [
|
|
"GET /orgs/{org}/packages/{package_type}/{package_name}/versions",
|
|
{},
|
|
{ renamed: ["packages", "getAllPackageVersionsForPackageOwnedByOrg"] }
|
|
],
|
|
getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser: [
|
|
"GET /user/packages/{package_type}/{package_name}/versions",
|
|
{},
|
|
{
|
|
renamed: [
|
|
"packages",
|
|
"getAllPackageVersionsForPackageOwnedByAuthenticatedUser"
|
|
]
|
|
}
|
|
],
|
|
getAllPackageVersionsForPackageOwnedByAuthenticatedUser: [
|
|
"GET /user/packages/{package_type}/{package_name}/versions"
|
|
],
|
|
getAllPackageVersionsForPackageOwnedByOrg: [
|
|
"GET /orgs/{org}/packages/{package_type}/{package_name}/versions"
|
|
],
|
|
getAllPackageVersionsForPackageOwnedByUser: [
|
|
"GET /users/{username}/packages/{package_type}/{package_name}/versions"
|
|
],
|
|
getPackageForAuthenticatedUser: [
|
|
"GET /user/packages/{package_type}/{package_name}"
|
|
],
|
|
getPackageForOrganization: [
|
|
"GET /orgs/{org}/packages/{package_type}/{package_name}"
|
|
],
|
|
getPackageForUser: [
|
|
"GET /users/{username}/packages/{package_type}/{package_name}"
|
|
],
|
|
getPackageVersionForAuthenticatedUser: [
|
|
"GET /user/packages/{package_type}/{package_name}/versions/{package_version_id}"
|
|
],
|
|
getPackageVersionForOrganization: [
|
|
"GET /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"
|
|
],
|
|
getPackageVersionForUser: [
|
|
"GET /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"
|
|
],
|
|
listDockerMigrationConflictingPackagesForAuthenticatedUser: [
|
|
"GET /user/docker/conflicts"
|
|
],
|
|
listDockerMigrationConflictingPackagesForOrganization: [
|
|
"GET /orgs/{org}/docker/conflicts"
|
|
],
|
|
listDockerMigrationConflictingPackagesForUser: [
|
|
"GET /users/{username}/docker/conflicts"
|
|
],
|
|
listPackagesForAuthenticatedUser: ["GET /user/packages"],
|
|
listPackagesForOrganization: ["GET /orgs/{org}/packages"],
|
|
listPackagesForUser: ["GET /users/{username}/packages"],
|
|
restorePackageForAuthenticatedUser: [
|
|
"POST /user/packages/{package_type}/{package_name}/restore{?token}"
|
|
],
|
|
restorePackageForOrg: [
|
|
"POST /orgs/{org}/packages/{package_type}/{package_name}/restore{?token}"
|
|
],
|
|
restorePackageForUser: [
|
|
"POST /users/{username}/packages/{package_type}/{package_name}/restore{?token}"
|
|
],
|
|
restorePackageVersionForAuthenticatedUser: [
|
|
"POST /user/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"
|
|
],
|
|
restorePackageVersionForOrg: [
|
|
"POST /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"
|
|
],
|
|
restorePackageVersionForUser: [
|
|
"POST /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"
|
|
]
|
|
},
|
|
privateRegistries: {
|
|
createOrgPrivateRegistry: ["POST /orgs/{org}/private-registries"],
|
|
deleteOrgPrivateRegistry: [
|
|
"DELETE /orgs/{org}/private-registries/{secret_name}"
|
|
],
|
|
getOrgPrivateRegistry: ["GET /orgs/{org}/private-registries/{secret_name}"],
|
|
getOrgPublicKey: ["GET /orgs/{org}/private-registries/public-key"],
|
|
listOrgPrivateRegistries: ["GET /orgs/{org}/private-registries"],
|
|
updateOrgPrivateRegistry: [
|
|
"PATCH /orgs/{org}/private-registries/{secret_name}"
|
|
]
|
|
},
|
|
projects: {
|
|
addItemForOrg: ["POST /orgs/{org}/projectsV2/{project_number}/items"],
|
|
addItemForUser: [
|
|
"POST /users/{username}/projectsV2/{project_number}/items"
|
|
],
|
|
deleteItemForOrg: [
|
|
"DELETE /orgs/{org}/projectsV2/{project_number}/items/{item_id}"
|
|
],
|
|
deleteItemForUser: [
|
|
"DELETE /users/{username}/projectsV2/{project_number}/items/{item_id}"
|
|
],
|
|
getFieldForOrg: [
|
|
"GET /orgs/{org}/projectsV2/{project_number}/fields/{field_id}"
|
|
],
|
|
getFieldForUser: [
|
|
"GET /users/{username}/projectsV2/{project_number}/fields/{field_id}"
|
|
],
|
|
getForOrg: ["GET /orgs/{org}/projectsV2/{project_number}"],
|
|
getForUser: ["GET /users/{username}/projectsV2/{project_number}"],
|
|
getOrgItem: ["GET /orgs/{org}/projectsV2/{project_number}/items/{item_id}"],
|
|
getUserItem: [
|
|
"GET /users/{username}/projectsV2/{project_number}/items/{item_id}"
|
|
],
|
|
listFieldsForOrg: ["GET /orgs/{org}/projectsV2/{project_number}/fields"],
|
|
listFieldsForUser: [
|
|
"GET /users/{username}/projectsV2/{project_number}/fields"
|
|
],
|
|
listForOrg: ["GET /orgs/{org}/projectsV2"],
|
|
listForUser: ["GET /users/{username}/projectsV2"],
|
|
listItemsForOrg: ["GET /orgs/{org}/projectsV2/{project_number}/items"],
|
|
listItemsForUser: [
|
|
"GET /users/{username}/projectsV2/{project_number}/items"
|
|
],
|
|
updateItemForOrg: [
|
|
"PATCH /orgs/{org}/projectsV2/{project_number}/items/{item_id}"
|
|
],
|
|
updateItemForUser: [
|
|
"PATCH /users/{username}/projectsV2/{project_number}/items/{item_id}"
|
|
]
|
|
},
|
|
pulls: {
|
|
checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"],
|
|
create: ["POST /repos/{owner}/{repo}/pulls"],
|
|
createReplyForReviewComment: [
|
|
"POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"
|
|
],
|
|
createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],
|
|
createReviewComment: [
|
|
"POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"
|
|
],
|
|
deletePendingReview: [
|
|
"DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"
|
|
],
|
|
deleteReviewComment: [
|
|
"DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"
|
|
],
|
|
dismissReview: [
|
|
"PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"
|
|
],
|
|
get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"],
|
|
getReview: [
|
|
"GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"
|
|
],
|
|
getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"],
|
|
list: ["GET /repos/{owner}/{repo}/pulls"],
|
|
listCommentsForReview: [
|
|
"GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"
|
|
],
|
|
listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"],
|
|
listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"],
|
|
listRequestedReviewers: [
|
|
"GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"
|
|
],
|
|
listReviewComments: [
|
|
"GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"
|
|
],
|
|
listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"],
|
|
listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],
|
|
merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"],
|
|
removeRequestedReviewers: [
|
|
"DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"
|
|
],
|
|
requestReviewers: [
|
|
"POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"
|
|
],
|
|
submitReview: [
|
|
"POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"
|
|
],
|
|
update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"],
|
|
updateBranch: [
|
|
"PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch"
|
|
],
|
|
updateReview: [
|
|
"PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"
|
|
],
|
|
updateReviewComment: [
|
|
"PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"
|
|
]
|
|
},
|
|
rateLimit: { get: ["GET /rate_limit"] },
|
|
reactions: {
|
|
createForCommitComment: [
|
|
"POST /repos/{owner}/{repo}/comments/{comment_id}/reactions"
|
|
],
|
|
createForIssue: [
|
|
"POST /repos/{owner}/{repo}/issues/{issue_number}/reactions"
|
|
],
|
|
createForIssueComment: [
|
|
"POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"
|
|
],
|
|
createForPullRequestReviewComment: [
|
|
"POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"
|
|
],
|
|
createForRelease: [
|
|
"POST /repos/{owner}/{repo}/releases/{release_id}/reactions"
|
|
],
|
|
createForTeamDiscussionCommentInOrg: [
|
|
"POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"
|
|
],
|
|
createForTeamDiscussionInOrg: [
|
|
"POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"
|
|
],
|
|
deleteForCommitComment: [
|
|
"DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}"
|
|
],
|
|
deleteForIssue: [
|
|
"DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}"
|
|
],
|
|
deleteForIssueComment: [
|
|
"DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}"
|
|
],
|
|
deleteForPullRequestComment: [
|
|
"DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}"
|
|
],
|
|
deleteForRelease: [
|
|
"DELETE /repos/{owner}/{repo}/releases/{release_id}/reactions/{reaction_id}"
|
|
],
|
|
deleteForTeamDiscussion: [
|
|
"DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}"
|
|
],
|
|
deleteForTeamDiscussionComment: [
|
|
"DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}"
|
|
],
|
|
listForCommitComment: [
|
|
"GET /repos/{owner}/{repo}/comments/{comment_id}/reactions"
|
|
],
|
|
listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions"],
|
|
listForIssueComment: [
|
|
"GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"
|
|
],
|
|
listForPullRequestReviewComment: [
|
|
"GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"
|
|
],
|
|
listForRelease: [
|
|
"GET /repos/{owner}/{repo}/releases/{release_id}/reactions"
|
|
],
|
|
listForTeamDiscussionCommentInOrg: [
|
|
"GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"
|
|
],
|
|
listForTeamDiscussionInOrg: [
|
|
"GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"
|
|
]
|
|
},
|
|
repos: {
|
|
acceptInvitation: [
|
|
"PATCH /user/repository_invitations/{invitation_id}",
|
|
{},
|
|
{ renamed: ["repos", "acceptInvitationForAuthenticatedUser"] }
|
|
],
|
|
acceptInvitationForAuthenticatedUser: [
|
|
"PATCH /user/repository_invitations/{invitation_id}"
|
|
],
|
|
addAppAccessRestrictions: [
|
|
"POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",
|
|
{},
|
|
{ mapToData: "apps" }
|
|
],
|
|
addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"],
|
|
addStatusCheckContexts: [
|
|
"POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",
|
|
{},
|
|
{ mapToData: "contexts" }
|
|
],
|
|
addTeamAccessRestrictions: [
|
|
"POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",
|
|
{},
|
|
{ mapToData: "teams" }
|
|
],
|
|
addUserAccessRestrictions: [
|
|
"POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",
|
|
{},
|
|
{ mapToData: "users" }
|
|
],
|
|
cancelPagesDeployment: [
|
|
"POST /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}/cancel"
|
|
],
|
|
checkAutomatedSecurityFixes: [
|
|
"GET /repos/{owner}/{repo}/automated-security-fixes"
|
|
],
|
|
checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"],
|
|
checkImmutableReleases: ["GET /repos/{owner}/{repo}/immutable-releases"],
|
|
checkPrivateVulnerabilityReporting: [
|
|
"GET /repos/{owner}/{repo}/private-vulnerability-reporting"
|
|
],
|
|
checkVulnerabilityAlerts: [
|
|
"GET /repos/{owner}/{repo}/vulnerability-alerts"
|
|
],
|
|
codeownersErrors: ["GET /repos/{owner}/{repo}/codeowners/errors"],
|
|
compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"],
|
|
compareCommitsWithBasehead: [
|
|
"GET /repos/{owner}/{repo}/compare/{basehead}"
|
|
],
|
|
createAttestation: ["POST /repos/{owner}/{repo}/attestations"],
|
|
createAutolink: ["POST /repos/{owner}/{repo}/autolinks"],
|
|
createCommitComment: [
|
|
"POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"
|
|
],
|
|
createCommitSignatureProtection: [
|
|
"POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"
|
|
],
|
|
createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"],
|
|
createDeployKey: ["POST /repos/{owner}/{repo}/keys"],
|
|
createDeployment: ["POST /repos/{owner}/{repo}/deployments"],
|
|
createDeploymentBranchPolicy: [
|
|
"POST /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"
|
|
],
|
|
createDeploymentProtectionRule: [
|
|
"POST /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules"
|
|
],
|
|
createDeploymentStatus: [
|
|
"POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"
|
|
],
|
|
createDispatchEvent: ["POST /repos/{owner}/{repo}/dispatches"],
|
|
createForAuthenticatedUser: ["POST /user/repos"],
|
|
createFork: ["POST /repos/{owner}/{repo}/forks"],
|
|
createInOrg: ["POST /orgs/{org}/repos"],
|
|
createOrUpdateEnvironment: [
|
|
"PUT /repos/{owner}/{repo}/environments/{environment_name}"
|
|
],
|
|
createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"],
|
|
createOrgRuleset: ["POST /orgs/{org}/rulesets"],
|
|
createPagesDeployment: ["POST /repos/{owner}/{repo}/pages/deployments"],
|
|
createPagesSite: ["POST /repos/{owner}/{repo}/pages"],
|
|
createRelease: ["POST /repos/{owner}/{repo}/releases"],
|
|
createRepoRuleset: ["POST /repos/{owner}/{repo}/rulesets"],
|
|
createUsingTemplate: [
|
|
"POST /repos/{template_owner}/{template_repo}/generate"
|
|
],
|
|
createWebhook: ["POST /repos/{owner}/{repo}/hooks"],
|
|
customPropertiesForReposCreateOrUpdateRepositoryValues: [
|
|
"PATCH /repos/{owner}/{repo}/properties/values"
|
|
],
|
|
customPropertiesForReposGetRepositoryValues: [
|
|
"GET /repos/{owner}/{repo}/properties/values"
|
|
],
|
|
declineInvitation: [
|
|
"DELETE /user/repository_invitations/{invitation_id}",
|
|
{},
|
|
{ renamed: ["repos", "declineInvitationForAuthenticatedUser"] }
|
|
],
|
|
declineInvitationForAuthenticatedUser: [
|
|
"DELETE /user/repository_invitations/{invitation_id}"
|
|
],
|
|
delete: ["DELETE /repos/{owner}/{repo}"],
|
|
deleteAccessRestrictions: [
|
|
"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"
|
|
],
|
|
deleteAdminBranchProtection: [
|
|
"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"
|
|
],
|
|
deleteAnEnvironment: [
|
|
"DELETE /repos/{owner}/{repo}/environments/{environment_name}"
|
|
],
|
|
deleteAutolink: ["DELETE /repos/{owner}/{repo}/autolinks/{autolink_id}"],
|
|
deleteBranchProtection: [
|
|
"DELETE /repos/{owner}/{repo}/branches/{branch}/protection"
|
|
],
|
|
deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"],
|
|
deleteCommitSignatureProtection: [
|
|
"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"
|
|
],
|
|
deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"],
|
|
deleteDeployment: [
|
|
"DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"
|
|
],
|
|
deleteDeploymentBranchPolicy: [
|
|
"DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"
|
|
],
|
|
deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"],
|
|
deleteInvitation: [
|
|
"DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"
|
|
],
|
|
deleteOrgRuleset: ["DELETE /orgs/{org}/rulesets/{ruleset_id}"],
|
|
deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages"],
|
|
deletePullRequestReviewProtection: [
|
|
"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"
|
|
],
|
|
deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"],
|
|
deleteReleaseAsset: [
|
|
"DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"
|
|
],
|
|
deleteRepoRuleset: ["DELETE /repos/{owner}/{repo}/rulesets/{ruleset_id}"],
|
|
deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"],
|
|
disableAutomatedSecurityFixes: [
|
|
"DELETE /repos/{owner}/{repo}/automated-security-fixes"
|
|
],
|
|
disableDeploymentProtectionRule: [
|
|
"DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}"
|
|
],
|
|
disableImmutableReleases: [
|
|
"DELETE /repos/{owner}/{repo}/immutable-releases"
|
|
],
|
|
disablePrivateVulnerabilityReporting: [
|
|
"DELETE /repos/{owner}/{repo}/private-vulnerability-reporting"
|
|
],
|
|
disableVulnerabilityAlerts: [
|
|
"DELETE /repos/{owner}/{repo}/vulnerability-alerts"
|
|
],
|
|
downloadArchive: [
|
|
"GET /repos/{owner}/{repo}/zipball/{ref}",
|
|
{},
|
|
{ renamed: ["repos", "downloadZipballArchive"] }
|
|
],
|
|
downloadTarballArchive: ["GET /repos/{owner}/{repo}/tarball/{ref}"],
|
|
downloadZipballArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}"],
|
|
enableAutomatedSecurityFixes: [
|
|
"PUT /repos/{owner}/{repo}/automated-security-fixes"
|
|
],
|
|
enableImmutableReleases: ["PUT /repos/{owner}/{repo}/immutable-releases"],
|
|
enablePrivateVulnerabilityReporting: [
|
|
"PUT /repos/{owner}/{repo}/private-vulnerability-reporting"
|
|
],
|
|
enableVulnerabilityAlerts: [
|
|
"PUT /repos/{owner}/{repo}/vulnerability-alerts"
|
|
],
|
|
generateReleaseNotes: [
|
|
"POST /repos/{owner}/{repo}/releases/generate-notes"
|
|
],
|
|
get: ["GET /repos/{owner}/{repo}"],
|
|
getAccessRestrictions: [
|
|
"GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"
|
|
],
|
|
getAdminBranchProtection: [
|
|
"GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"
|
|
],
|
|
getAllDeploymentProtectionRules: [
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules"
|
|
],
|
|
getAllEnvironments: ["GET /repos/{owner}/{repo}/environments"],
|
|
getAllStatusCheckContexts: [
|
|
"GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"
|
|
],
|
|
getAllTopics: ["GET /repos/{owner}/{repo}/topics"],
|
|
getAppsWithAccessToProtectedBranch: [
|
|
"GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"
|
|
],
|
|
getAutolink: ["GET /repos/{owner}/{repo}/autolinks/{autolink_id}"],
|
|
getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"],
|
|
getBranchProtection: [
|
|
"GET /repos/{owner}/{repo}/branches/{branch}/protection"
|
|
],
|
|
getBranchRules: ["GET /repos/{owner}/{repo}/rules/branches/{branch}"],
|
|
getClones: ["GET /repos/{owner}/{repo}/traffic/clones"],
|
|
getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"],
|
|
getCollaboratorPermissionLevel: [
|
|
"GET /repos/{owner}/{repo}/collaborators/{username}/permission"
|
|
],
|
|
getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"],
|
|
getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"],
|
|
getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"],
|
|
getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"],
|
|
getCommitSignatureProtection: [
|
|
"GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"
|
|
],
|
|
getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile"],
|
|
getContent: ["GET /repos/{owner}/{repo}/contents/{path}"],
|
|
getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"],
|
|
getCustomDeploymentProtectionRule: [
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}"
|
|
],
|
|
getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"],
|
|
getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"],
|
|
getDeploymentBranchPolicy: [
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"
|
|
],
|
|
getDeploymentStatus: [
|
|
"GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"
|
|
],
|
|
getEnvironment: [
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}"
|
|
],
|
|
getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"],
|
|
getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"],
|
|
getOrgRuleSuite: ["GET /orgs/{org}/rulesets/rule-suites/{rule_suite_id}"],
|
|
getOrgRuleSuites: ["GET /orgs/{org}/rulesets/rule-suites"],
|
|
getOrgRuleset: ["GET /orgs/{org}/rulesets/{ruleset_id}"],
|
|
getOrgRulesets: ["GET /orgs/{org}/rulesets"],
|
|
getPages: ["GET /repos/{owner}/{repo}/pages"],
|
|
getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"],
|
|
getPagesDeployment: [
|
|
"GET /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}"
|
|
],
|
|
getPagesHealthCheck: ["GET /repos/{owner}/{repo}/pages/health"],
|
|
getParticipationStats: ["GET /repos/{owner}/{repo}/stats/participation"],
|
|
getPullRequestReviewProtection: [
|
|
"GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"
|
|
],
|
|
getPunchCardStats: ["GET /repos/{owner}/{repo}/stats/punch_card"],
|
|
getReadme: ["GET /repos/{owner}/{repo}/readme"],
|
|
getReadmeInDirectory: ["GET /repos/{owner}/{repo}/readme/{dir}"],
|
|
getRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}"],
|
|
getReleaseAsset: ["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"],
|
|
getReleaseByTag: ["GET /repos/{owner}/{repo}/releases/tags/{tag}"],
|
|
getRepoRuleSuite: [
|
|
"GET /repos/{owner}/{repo}/rulesets/rule-suites/{rule_suite_id}"
|
|
],
|
|
getRepoRuleSuites: ["GET /repos/{owner}/{repo}/rulesets/rule-suites"],
|
|
getRepoRuleset: ["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}"],
|
|
getRepoRulesetHistory: [
|
|
"GET /repos/{owner}/{repo}/rulesets/{ruleset_id}/history"
|
|
],
|
|
getRepoRulesetVersion: [
|
|
"GET /repos/{owner}/{repo}/rulesets/{ruleset_id}/history/{version_id}"
|
|
],
|
|
getRepoRulesets: ["GET /repos/{owner}/{repo}/rulesets"],
|
|
getStatusChecksProtection: [
|
|
"GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"
|
|
],
|
|
getTeamsWithAccessToProtectedBranch: [
|
|
"GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"
|
|
],
|
|
getTopPaths: ["GET /repos/{owner}/{repo}/traffic/popular/paths"],
|
|
getTopReferrers: ["GET /repos/{owner}/{repo}/traffic/popular/referrers"],
|
|
getUsersWithAccessToProtectedBranch: [
|
|
"GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"
|
|
],
|
|
getViews: ["GET /repos/{owner}/{repo}/traffic/views"],
|
|
getWebhook: ["GET /repos/{owner}/{repo}/hooks/{hook_id}"],
|
|
getWebhookConfigForRepo: [
|
|
"GET /repos/{owner}/{repo}/hooks/{hook_id}/config"
|
|
],
|
|
getWebhookDelivery: [
|
|
"GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}"
|
|
],
|
|
listActivities: ["GET /repos/{owner}/{repo}/activity"],
|
|
listAttestations: [
|
|
"GET /repos/{owner}/{repo}/attestations/{subject_digest}"
|
|
],
|
|
listAutolinks: ["GET /repos/{owner}/{repo}/autolinks"],
|
|
listBranches: ["GET /repos/{owner}/{repo}/branches"],
|
|
listBranchesForHeadCommit: [
|
|
"GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head"
|
|
],
|
|
listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"],
|
|
listCommentsForCommit: [
|
|
"GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"
|
|
],
|
|
listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"],
|
|
listCommitStatusesForRef: [
|
|
"GET /repos/{owner}/{repo}/commits/{ref}/statuses"
|
|
],
|
|
listCommits: ["GET /repos/{owner}/{repo}/commits"],
|
|
listContributors: ["GET /repos/{owner}/{repo}/contributors"],
|
|
listCustomDeploymentRuleIntegrations: [
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/apps"
|
|
],
|
|
listDeployKeys: ["GET /repos/{owner}/{repo}/keys"],
|
|
listDeploymentBranchPolicies: [
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"
|
|
],
|
|
listDeploymentStatuses: [
|
|
"GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"
|
|
],
|
|
listDeployments: ["GET /repos/{owner}/{repo}/deployments"],
|
|
listForAuthenticatedUser: ["GET /user/repos"],
|
|
listForOrg: ["GET /orgs/{org}/repos"],
|
|
listForUser: ["GET /users/{username}/repos"],
|
|
listForks: ["GET /repos/{owner}/{repo}/forks"],
|
|
listInvitations: ["GET /repos/{owner}/{repo}/invitations"],
|
|
listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"],
|
|
listLanguages: ["GET /repos/{owner}/{repo}/languages"],
|
|
listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"],
|
|
listPublic: ["GET /repositories"],
|
|
listPullRequestsAssociatedWithCommit: [
|
|
"GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls"
|
|
],
|
|
listReleaseAssets: [
|
|
"GET /repos/{owner}/{repo}/releases/{release_id}/assets"
|
|
],
|
|
listReleases: ["GET /repos/{owner}/{repo}/releases"],
|
|
listTags: ["GET /repos/{owner}/{repo}/tags"],
|
|
listTeams: ["GET /repos/{owner}/{repo}/teams"],
|
|
listWebhookDeliveries: [
|
|
"GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries"
|
|
],
|
|
listWebhooks: ["GET /repos/{owner}/{repo}/hooks"],
|
|
merge: ["POST /repos/{owner}/{repo}/merges"],
|
|
mergeUpstream: ["POST /repos/{owner}/{repo}/merge-upstream"],
|
|
pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"],
|
|
redeliverWebhookDelivery: [
|
|
"POST /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"
|
|
],
|
|
removeAppAccessRestrictions: [
|
|
"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",
|
|
{},
|
|
{ mapToData: "apps" }
|
|
],
|
|
removeCollaborator: [
|
|
"DELETE /repos/{owner}/{repo}/collaborators/{username}"
|
|
],
|
|
removeStatusCheckContexts: [
|
|
"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",
|
|
{},
|
|
{ mapToData: "contexts" }
|
|
],
|
|
removeStatusCheckProtection: [
|
|
"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"
|
|
],
|
|
removeTeamAccessRestrictions: [
|
|
"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",
|
|
{},
|
|
{ mapToData: "teams" }
|
|
],
|
|
removeUserAccessRestrictions: [
|
|
"DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",
|
|
{},
|
|
{ mapToData: "users" }
|
|
],
|
|
renameBranch: ["POST /repos/{owner}/{repo}/branches/{branch}/rename"],
|
|
replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics"],
|
|
requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"],
|
|
setAdminBranchProtection: [
|
|
"POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"
|
|
],
|
|
setAppAccessRestrictions: [
|
|
"PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",
|
|
{},
|
|
{ mapToData: "apps" }
|
|
],
|
|
setStatusCheckContexts: [
|
|
"PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",
|
|
{},
|
|
{ mapToData: "contexts" }
|
|
],
|
|
setTeamAccessRestrictions: [
|
|
"PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",
|
|
{},
|
|
{ mapToData: "teams" }
|
|
],
|
|
setUserAccessRestrictions: [
|
|
"PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",
|
|
{},
|
|
{ mapToData: "users" }
|
|
],
|
|
testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"],
|
|
transfer: ["POST /repos/{owner}/{repo}/transfer"],
|
|
update: ["PATCH /repos/{owner}/{repo}"],
|
|
updateBranchProtection: [
|
|
"PUT /repos/{owner}/{repo}/branches/{branch}/protection"
|
|
],
|
|
updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"],
|
|
updateDeploymentBranchPolicy: [
|
|
"PUT /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"
|
|
],
|
|
updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"],
|
|
updateInvitation: [
|
|
"PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"
|
|
],
|
|
updateOrgRuleset: ["PUT /orgs/{org}/rulesets/{ruleset_id}"],
|
|
updatePullRequestReviewProtection: [
|
|
"PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"
|
|
],
|
|
updateRelease: ["PATCH /repos/{owner}/{repo}/releases/{release_id}"],
|
|
updateReleaseAsset: [
|
|
"PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"
|
|
],
|
|
updateRepoRuleset: ["PUT /repos/{owner}/{repo}/rulesets/{ruleset_id}"],
|
|
updateStatusCheckPotection: [
|
|
"PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks",
|
|
{},
|
|
{ renamed: ["repos", "updateStatusCheckProtection"] }
|
|
],
|
|
updateStatusCheckProtection: [
|
|
"PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"
|
|
],
|
|
updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"],
|
|
updateWebhookConfigForRepo: [
|
|
"PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config"
|
|
],
|
|
uploadReleaseAsset: [
|
|
"POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}",
|
|
{ baseUrl: "https://uploads.github.com" }
|
|
]
|
|
},
|
|
search: {
|
|
code: ["GET /search/code"],
|
|
commits: ["GET /search/commits"],
|
|
issuesAndPullRequests: ["GET /search/issues"],
|
|
labels: ["GET /search/labels"],
|
|
repos: ["GET /search/repositories"],
|
|
topics: ["GET /search/topics"],
|
|
users: ["GET /search/users"]
|
|
},
|
|
secretScanning: {
|
|
createPushProtectionBypass: [
|
|
"POST /repos/{owner}/{repo}/secret-scanning/push-protection-bypasses"
|
|
],
|
|
getAlert: [
|
|
"GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"
|
|
],
|
|
getScanHistory: ["GET /repos/{owner}/{repo}/secret-scanning/scan-history"],
|
|
listAlertsForOrg: ["GET /orgs/{org}/secret-scanning/alerts"],
|
|
listAlertsForRepo: ["GET /repos/{owner}/{repo}/secret-scanning/alerts"],
|
|
listLocationsForAlert: [
|
|
"GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations"
|
|
],
|
|
listOrgPatternConfigs: [
|
|
"GET /orgs/{org}/secret-scanning/pattern-configurations"
|
|
],
|
|
updateAlert: [
|
|
"PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"
|
|
],
|
|
updateOrgPatternConfigs: [
|
|
"PATCH /orgs/{org}/secret-scanning/pattern-configurations"
|
|
]
|
|
},
|
|
securityAdvisories: {
|
|
createFork: [
|
|
"POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/forks"
|
|
],
|
|
createPrivateVulnerabilityReport: [
|
|
"POST /repos/{owner}/{repo}/security-advisories/reports"
|
|
],
|
|
createRepositoryAdvisory: [
|
|
"POST /repos/{owner}/{repo}/security-advisories"
|
|
],
|
|
createRepositoryAdvisoryCveRequest: [
|
|
"POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/cve"
|
|
],
|
|
getGlobalAdvisory: ["GET /advisories/{ghsa_id}"],
|
|
getRepositoryAdvisory: [
|
|
"GET /repos/{owner}/{repo}/security-advisories/{ghsa_id}"
|
|
],
|
|
listGlobalAdvisories: ["GET /advisories"],
|
|
listOrgRepositoryAdvisories: ["GET /orgs/{org}/security-advisories"],
|
|
listRepositoryAdvisories: ["GET /repos/{owner}/{repo}/security-advisories"],
|
|
updateRepositoryAdvisory: [
|
|
"PATCH /repos/{owner}/{repo}/security-advisories/{ghsa_id}"
|
|
]
|
|
},
|
|
teams: {
|
|
addOrUpdateMembershipForUserInOrg: [
|
|
"PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"
|
|
],
|
|
addOrUpdateRepoPermissionsInOrg: [
|
|
"PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"
|
|
],
|
|
checkPermissionsForRepoInOrg: [
|
|
"GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"
|
|
],
|
|
create: ["POST /orgs/{org}/teams"],
|
|
createDiscussionCommentInOrg: [
|
|
"POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"
|
|
],
|
|
createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"],
|
|
deleteDiscussionCommentInOrg: [
|
|
"DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"
|
|
],
|
|
deleteDiscussionInOrg: [
|
|
"DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"
|
|
],
|
|
deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"],
|
|
getByName: ["GET /orgs/{org}/teams/{team_slug}"],
|
|
getDiscussionCommentInOrg: [
|
|
"GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"
|
|
],
|
|
getDiscussionInOrg: [
|
|
"GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"
|
|
],
|
|
getMembershipForUserInOrg: [
|
|
"GET /orgs/{org}/teams/{team_slug}/memberships/{username}"
|
|
],
|
|
list: ["GET /orgs/{org}/teams"],
|
|
listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"],
|
|
listDiscussionCommentsInOrg: [
|
|
"GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"
|
|
],
|
|
listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"],
|
|
listForAuthenticatedUser: ["GET /user/teams"],
|
|
listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"],
|
|
listPendingInvitationsInOrg: [
|
|
"GET /orgs/{org}/teams/{team_slug}/invitations"
|
|
],
|
|
listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"],
|
|
removeMembershipForUserInOrg: [
|
|
"DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"
|
|
],
|
|
removeRepoInOrg: [
|
|
"DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"
|
|
],
|
|
updateDiscussionCommentInOrg: [
|
|
"PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"
|
|
],
|
|
updateDiscussionInOrg: [
|
|
"PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"
|
|
],
|
|
updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"]
|
|
},
|
|
users: {
|
|
addEmailForAuthenticated: [
|
|
"POST /user/emails",
|
|
{},
|
|
{ renamed: ["users", "addEmailForAuthenticatedUser"] }
|
|
],
|
|
addEmailForAuthenticatedUser: ["POST /user/emails"],
|
|
addSocialAccountForAuthenticatedUser: ["POST /user/social_accounts"],
|
|
block: ["PUT /user/blocks/{username}"],
|
|
checkBlocked: ["GET /user/blocks/{username}"],
|
|
checkFollowingForUser: ["GET /users/{username}/following/{target_user}"],
|
|
checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"],
|
|
createGpgKeyForAuthenticated: [
|
|
"POST /user/gpg_keys",
|
|
{},
|
|
{ renamed: ["users", "createGpgKeyForAuthenticatedUser"] }
|
|
],
|
|
createGpgKeyForAuthenticatedUser: ["POST /user/gpg_keys"],
|
|
createPublicSshKeyForAuthenticated: [
|
|
"POST /user/keys",
|
|
{},
|
|
{ renamed: ["users", "createPublicSshKeyForAuthenticatedUser"] }
|
|
],
|
|
createPublicSshKeyForAuthenticatedUser: ["POST /user/keys"],
|
|
createSshSigningKeyForAuthenticatedUser: ["POST /user/ssh_signing_keys"],
|
|
deleteAttestationsBulk: [
|
|
"POST /users/{username}/attestations/delete-request"
|
|
],
|
|
deleteAttestationsById: [
|
|
"DELETE /users/{username}/attestations/{attestation_id}"
|
|
],
|
|
deleteAttestationsBySubjectDigest: [
|
|
"DELETE /users/{username}/attestations/digest/{subject_digest}"
|
|
],
|
|
deleteEmailForAuthenticated: [
|
|
"DELETE /user/emails",
|
|
{},
|
|
{ renamed: ["users", "deleteEmailForAuthenticatedUser"] }
|
|
],
|
|
deleteEmailForAuthenticatedUser: ["DELETE /user/emails"],
|
|
deleteGpgKeyForAuthenticated: [
|
|
"DELETE /user/gpg_keys/{gpg_key_id}",
|
|
{},
|
|
{ renamed: ["users", "deleteGpgKeyForAuthenticatedUser"] }
|
|
],
|
|
deleteGpgKeyForAuthenticatedUser: ["DELETE /user/gpg_keys/{gpg_key_id}"],
|
|
deletePublicSshKeyForAuthenticated: [
|
|
"DELETE /user/keys/{key_id}",
|
|
{},
|
|
{ renamed: ["users", "deletePublicSshKeyForAuthenticatedUser"] }
|
|
],
|
|
deletePublicSshKeyForAuthenticatedUser: ["DELETE /user/keys/{key_id}"],
|
|
deleteSocialAccountForAuthenticatedUser: ["DELETE /user/social_accounts"],
|
|
deleteSshSigningKeyForAuthenticatedUser: [
|
|
"DELETE /user/ssh_signing_keys/{ssh_signing_key_id}"
|
|
],
|
|
follow: ["PUT /user/following/{username}"],
|
|
getAuthenticated: ["GET /user"],
|
|
getById: ["GET /user/{account_id}"],
|
|
getByUsername: ["GET /users/{username}"],
|
|
getContextForUser: ["GET /users/{username}/hovercard"],
|
|
getGpgKeyForAuthenticated: [
|
|
"GET /user/gpg_keys/{gpg_key_id}",
|
|
{},
|
|
{ renamed: ["users", "getGpgKeyForAuthenticatedUser"] }
|
|
],
|
|
getGpgKeyForAuthenticatedUser: ["GET /user/gpg_keys/{gpg_key_id}"],
|
|
getPublicSshKeyForAuthenticated: [
|
|
"GET /user/keys/{key_id}",
|
|
{},
|
|
{ renamed: ["users", "getPublicSshKeyForAuthenticatedUser"] }
|
|
],
|
|
getPublicSshKeyForAuthenticatedUser: ["GET /user/keys/{key_id}"],
|
|
getSshSigningKeyForAuthenticatedUser: [
|
|
"GET /user/ssh_signing_keys/{ssh_signing_key_id}"
|
|
],
|
|
list: ["GET /users"],
|
|
listAttestations: ["GET /users/{username}/attestations/{subject_digest}"],
|
|
listAttestationsBulk: [
|
|
"POST /users/{username}/attestations/bulk-list{?per_page,before,after}"
|
|
],
|
|
listBlockedByAuthenticated: [
|
|
"GET /user/blocks",
|
|
{},
|
|
{ renamed: ["users", "listBlockedByAuthenticatedUser"] }
|
|
],
|
|
listBlockedByAuthenticatedUser: ["GET /user/blocks"],
|
|
listEmailsForAuthenticated: [
|
|
"GET /user/emails",
|
|
{},
|
|
{ renamed: ["users", "listEmailsForAuthenticatedUser"] }
|
|
],
|
|
listEmailsForAuthenticatedUser: ["GET /user/emails"],
|
|
listFollowedByAuthenticated: [
|
|
"GET /user/following",
|
|
{},
|
|
{ renamed: ["users", "listFollowedByAuthenticatedUser"] }
|
|
],
|
|
listFollowedByAuthenticatedUser: ["GET /user/following"],
|
|
listFollowersForAuthenticatedUser: ["GET /user/followers"],
|
|
listFollowersForUser: ["GET /users/{username}/followers"],
|
|
listFollowingForUser: ["GET /users/{username}/following"],
|
|
listGpgKeysForAuthenticated: [
|
|
"GET /user/gpg_keys",
|
|
{},
|
|
{ renamed: ["users", "listGpgKeysForAuthenticatedUser"] }
|
|
],
|
|
listGpgKeysForAuthenticatedUser: ["GET /user/gpg_keys"],
|
|
listGpgKeysForUser: ["GET /users/{username}/gpg_keys"],
|
|
listPublicEmailsForAuthenticated: [
|
|
"GET /user/public_emails",
|
|
{},
|
|
{ renamed: ["users", "listPublicEmailsForAuthenticatedUser"] }
|
|
],
|
|
listPublicEmailsForAuthenticatedUser: ["GET /user/public_emails"],
|
|
listPublicKeysForUser: ["GET /users/{username}/keys"],
|
|
listPublicSshKeysForAuthenticated: [
|
|
"GET /user/keys",
|
|
{},
|
|
{ renamed: ["users", "listPublicSshKeysForAuthenticatedUser"] }
|
|
],
|
|
listPublicSshKeysForAuthenticatedUser: ["GET /user/keys"],
|
|
listSocialAccountsForAuthenticatedUser: ["GET /user/social_accounts"],
|
|
listSocialAccountsForUser: ["GET /users/{username}/social_accounts"],
|
|
listSshSigningKeysForAuthenticatedUser: ["GET /user/ssh_signing_keys"],
|
|
listSshSigningKeysForUser: ["GET /users/{username}/ssh_signing_keys"],
|
|
setPrimaryEmailVisibilityForAuthenticated: [
|
|
"PATCH /user/email/visibility",
|
|
{},
|
|
{ renamed: ["users", "setPrimaryEmailVisibilityForAuthenticatedUser"] }
|
|
],
|
|
setPrimaryEmailVisibilityForAuthenticatedUser: [
|
|
"PATCH /user/email/visibility"
|
|
],
|
|
unblock: ["DELETE /user/blocks/{username}"],
|
|
unfollow: ["DELETE /user/following/{username}"],
|
|
updateAuthenticated: ["PATCH /user"]
|
|
}
|
|
};
|
|
var endpoints_default = Endpoints;
|
|
|
|
//# sourceMappingURL=endpoints.js.map
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/endpoints-to-methods.js
|
|
|
|
const endpointMethodsMap = /* @__PURE__ */ new Map();
|
|
for (const [scope, endpoints] of Object.entries(endpoints_default)) {
|
|
for (const [methodName, endpoint] of Object.entries(endpoints)) {
|
|
const [route, defaults, decorations] = endpoint;
|
|
const [method, url] = route.split(/ /);
|
|
const endpointDefaults = Object.assign(
|
|
{
|
|
method,
|
|
url
|
|
},
|
|
defaults
|
|
);
|
|
if (!endpointMethodsMap.has(scope)) {
|
|
endpointMethodsMap.set(scope, /* @__PURE__ */ new Map());
|
|
}
|
|
endpointMethodsMap.get(scope).set(methodName, {
|
|
scope,
|
|
methodName,
|
|
endpointDefaults,
|
|
decorations
|
|
});
|
|
}
|
|
}
|
|
const handler = {
|
|
has({ scope }, methodName) {
|
|
return endpointMethodsMap.get(scope).has(methodName);
|
|
},
|
|
getOwnPropertyDescriptor(target, methodName) {
|
|
return {
|
|
value: this.get(target, methodName),
|
|
// ensures method is in the cache
|
|
configurable: true,
|
|
writable: true,
|
|
enumerable: true
|
|
};
|
|
},
|
|
defineProperty(target, methodName, descriptor) {
|
|
Object.defineProperty(target.cache, methodName, descriptor);
|
|
return true;
|
|
},
|
|
deleteProperty(target, methodName) {
|
|
delete target.cache[methodName];
|
|
return true;
|
|
},
|
|
ownKeys({ scope }) {
|
|
return [...endpointMethodsMap.get(scope).keys()];
|
|
},
|
|
set(target, methodName, value) {
|
|
return target.cache[methodName] = value;
|
|
},
|
|
get({ octokit, scope, cache }, methodName) {
|
|
if (cache[methodName]) {
|
|
return cache[methodName];
|
|
}
|
|
const method = endpointMethodsMap.get(scope).get(methodName);
|
|
if (!method) {
|
|
return void 0;
|
|
}
|
|
const { endpointDefaults, decorations } = method;
|
|
if (decorations) {
|
|
cache[methodName] = decorate(
|
|
octokit,
|
|
scope,
|
|
methodName,
|
|
endpointDefaults,
|
|
decorations
|
|
);
|
|
} else {
|
|
cache[methodName] = octokit.request.defaults(endpointDefaults);
|
|
}
|
|
return cache[methodName];
|
|
}
|
|
};
|
|
function endpointsToMethods(octokit) {
|
|
const newMethods = {};
|
|
for (const scope of endpointMethodsMap.keys()) {
|
|
newMethods[scope] = new Proxy({ octokit, scope, cache: {} }, handler);
|
|
}
|
|
return newMethods;
|
|
}
|
|
function decorate(octokit, scope, methodName, defaults, decorations) {
|
|
const requestWithDefaults = octokit.request.defaults(defaults);
|
|
function withDecorations(...args) {
|
|
let options = requestWithDefaults.endpoint.merge(...args);
|
|
if (decorations.mapToData) {
|
|
options = Object.assign({}, options, {
|
|
data: options[decorations.mapToData],
|
|
[decorations.mapToData]: void 0
|
|
});
|
|
return requestWithDefaults(options);
|
|
}
|
|
if (decorations.renamed) {
|
|
const [newScope, newMethodName] = decorations.renamed;
|
|
octokit.log.warn(
|
|
`octokit.${scope}.${methodName}() has been renamed to octokit.${newScope}.${newMethodName}()`
|
|
);
|
|
}
|
|
if (decorations.deprecated) {
|
|
octokit.log.warn(decorations.deprecated);
|
|
}
|
|
if (decorations.renamedParameters) {
|
|
const options2 = requestWithDefaults.endpoint.merge(...args);
|
|
for (const [name, alias] of Object.entries(
|
|
decorations.renamedParameters
|
|
)) {
|
|
if (name in options2) {
|
|
octokit.log.warn(
|
|
`"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead`
|
|
);
|
|
if (!(alias in options2)) {
|
|
options2[alias] = options2[name];
|
|
}
|
|
delete options2[name];
|
|
}
|
|
}
|
|
return requestWithDefaults(options2);
|
|
}
|
|
return requestWithDefaults(...args);
|
|
}
|
|
return Object.assign(withDecorations, requestWithDefaults);
|
|
}
|
|
|
|
//# sourceMappingURL=endpoints-to-methods.js.map
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@octokit/plugin-rest-endpoint-methods/dist-src/index.js
|
|
|
|
|
|
function restEndpointMethods(octokit) {
|
|
const api = endpointsToMethods(octokit);
|
|
return {
|
|
rest: api
|
|
};
|
|
}
|
|
restEndpointMethods.VERSION = dist_src_version_VERSION;
|
|
function legacyRestEndpointMethods(octokit) {
|
|
const api = endpointsToMethods(octokit);
|
|
return {
|
|
...api,
|
|
rest: api
|
|
};
|
|
}
|
|
legacyRestEndpointMethods.VERSION = dist_src_version_VERSION;
|
|
|
|
//# sourceMappingURL=index.js.map
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@octokit/plugin-paginate-rest/dist-bundle/index.js
|
|
// pkg/dist-src/version.js
|
|
var plugin_paginate_rest_dist_bundle_VERSION = "0.0.0-development";
|
|
|
|
// pkg/dist-src/normalize-paginated-list-response.js
|
|
function normalizePaginatedListResponse(response) {
|
|
if (!response.data) {
|
|
return {
|
|
...response,
|
|
data: []
|
|
};
|
|
}
|
|
const responseNeedsNormalization = ("total_count" in response.data || "total_commits" in response.data) && !("url" in response.data);
|
|
if (!responseNeedsNormalization) return response;
|
|
const incompleteResults = response.data.incomplete_results;
|
|
const repositorySelection = response.data.repository_selection;
|
|
const totalCount = response.data.total_count;
|
|
const totalCommits = response.data.total_commits;
|
|
delete response.data.incomplete_results;
|
|
delete response.data.repository_selection;
|
|
delete response.data.total_count;
|
|
delete response.data.total_commits;
|
|
const namespaceKey = Object.keys(response.data)[0];
|
|
const data = response.data[namespaceKey];
|
|
response.data = data;
|
|
if (typeof incompleteResults !== "undefined") {
|
|
response.data.incomplete_results = incompleteResults;
|
|
}
|
|
if (typeof repositorySelection !== "undefined") {
|
|
response.data.repository_selection = repositorySelection;
|
|
}
|
|
response.data.total_count = totalCount;
|
|
response.data.total_commits = totalCommits;
|
|
return response;
|
|
}
|
|
|
|
// pkg/dist-src/iterator.js
|
|
function iterator(octokit, route, parameters) {
|
|
const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters);
|
|
const requestMethod = typeof route === "function" ? route : octokit.request;
|
|
const method = options.method;
|
|
const headers = options.headers;
|
|
let url = options.url;
|
|
return {
|
|
[Symbol.asyncIterator]: () => ({
|
|
async next() {
|
|
if (!url) return { done: true };
|
|
try {
|
|
const response = await requestMethod({ method, url, headers });
|
|
const normalizedResponse = normalizePaginatedListResponse(response);
|
|
url = ((normalizedResponse.headers.link || "").match(
|
|
/<([^<>]+)>;\s*rel="next"/
|
|
) || [])[1];
|
|
if (!url && "total_commits" in normalizedResponse.data) {
|
|
const parsedUrl = new URL(normalizedResponse.url);
|
|
const params = parsedUrl.searchParams;
|
|
const page = parseInt(params.get("page") || "1", 10);
|
|
const per_page = parseInt(params.get("per_page") || "250", 10);
|
|
if (page * per_page < normalizedResponse.data.total_commits) {
|
|
params.set("page", String(page + 1));
|
|
url = parsedUrl.toString();
|
|
}
|
|
}
|
|
return { value: normalizedResponse };
|
|
} catch (error) {
|
|
if (error.status !== 409) throw error;
|
|
url = "";
|
|
return {
|
|
value: {
|
|
status: 200,
|
|
headers: {},
|
|
data: []
|
|
}
|
|
};
|
|
}
|
|
}
|
|
})
|
|
};
|
|
}
|
|
|
|
// pkg/dist-src/paginate.js
|
|
function paginate(octokit, route, parameters, mapFn) {
|
|
if (typeof parameters === "function") {
|
|
mapFn = parameters;
|
|
parameters = void 0;
|
|
}
|
|
return gather(
|
|
octokit,
|
|
[],
|
|
iterator(octokit, route, parameters)[Symbol.asyncIterator](),
|
|
mapFn
|
|
);
|
|
}
|
|
function gather(octokit, results, iterator2, mapFn) {
|
|
return iterator2.next().then((result) => {
|
|
if (result.done) {
|
|
return results;
|
|
}
|
|
let earlyExit = false;
|
|
function done() {
|
|
earlyExit = true;
|
|
}
|
|
results = results.concat(
|
|
mapFn ? mapFn(result.value, done) : result.value.data
|
|
);
|
|
if (earlyExit) {
|
|
return results;
|
|
}
|
|
return gather(octokit, results, iterator2, mapFn);
|
|
});
|
|
}
|
|
|
|
// pkg/dist-src/compose-paginate.js
|
|
var composePaginateRest = Object.assign(paginate, {
|
|
iterator
|
|
});
|
|
|
|
// pkg/dist-src/generated/paginating-endpoints.js
|
|
var paginatingEndpoints = (/* unused pure expression or super */ null && ([
|
|
"GET /advisories",
|
|
"GET /app/hook/deliveries",
|
|
"GET /app/installation-requests",
|
|
"GET /app/installations",
|
|
"GET /assignments/{assignment_id}/accepted_assignments",
|
|
"GET /classrooms",
|
|
"GET /classrooms/{classroom_id}/assignments",
|
|
"GET /enterprises/{enterprise}/code-security/configurations",
|
|
"GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}/repositories",
|
|
"GET /enterprises/{enterprise}/dependabot/alerts",
|
|
"GET /enterprises/{enterprise}/teams",
|
|
"GET /enterprises/{enterprise}/teams/{enterprise-team}/memberships",
|
|
"GET /enterprises/{enterprise}/teams/{enterprise-team}/organizations",
|
|
"GET /events",
|
|
"GET /gists",
|
|
"GET /gists/public",
|
|
"GET /gists/starred",
|
|
"GET /gists/{gist_id}/comments",
|
|
"GET /gists/{gist_id}/commits",
|
|
"GET /gists/{gist_id}/forks",
|
|
"GET /installation/repositories",
|
|
"GET /issues",
|
|
"GET /licenses",
|
|
"GET /marketplace_listing/plans",
|
|
"GET /marketplace_listing/plans/{plan_id}/accounts",
|
|
"GET /marketplace_listing/stubbed/plans",
|
|
"GET /marketplace_listing/stubbed/plans/{plan_id}/accounts",
|
|
"GET /networks/{owner}/{repo}/events",
|
|
"GET /notifications",
|
|
"GET /organizations",
|
|
"GET /organizations/{org}/dependabot/repository-access",
|
|
"GET /orgs/{org}/actions/cache/usage-by-repository",
|
|
"GET /orgs/{org}/actions/hosted-runners",
|
|
"GET /orgs/{org}/actions/permissions/repositories",
|
|
"GET /orgs/{org}/actions/permissions/self-hosted-runners/repositories",
|
|
"GET /orgs/{org}/actions/runner-groups",
|
|
"GET /orgs/{org}/actions/runner-groups/{runner_group_id}/hosted-runners",
|
|
"GET /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories",
|
|
"GET /orgs/{org}/actions/runner-groups/{runner_group_id}/runners",
|
|
"GET /orgs/{org}/actions/runners",
|
|
"GET /orgs/{org}/actions/secrets",
|
|
"GET /orgs/{org}/actions/secrets/{secret_name}/repositories",
|
|
"GET /orgs/{org}/actions/variables",
|
|
"GET /orgs/{org}/actions/variables/{name}/repositories",
|
|
"GET /orgs/{org}/attestations/repositories",
|
|
"GET /orgs/{org}/attestations/{subject_digest}",
|
|
"GET /orgs/{org}/blocks",
|
|
"GET /orgs/{org}/campaigns",
|
|
"GET /orgs/{org}/code-scanning/alerts",
|
|
"GET /orgs/{org}/code-security/configurations",
|
|
"GET /orgs/{org}/code-security/configurations/{configuration_id}/repositories",
|
|
"GET /orgs/{org}/codespaces",
|
|
"GET /orgs/{org}/codespaces/secrets",
|
|
"GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories",
|
|
"GET /orgs/{org}/copilot/billing/seats",
|
|
"GET /orgs/{org}/copilot/metrics",
|
|
"GET /orgs/{org}/dependabot/alerts",
|
|
"GET /orgs/{org}/dependabot/secrets",
|
|
"GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories",
|
|
"GET /orgs/{org}/events",
|
|
"GET /orgs/{org}/failed_invitations",
|
|
"GET /orgs/{org}/hooks",
|
|
"GET /orgs/{org}/hooks/{hook_id}/deliveries",
|
|
"GET /orgs/{org}/insights/api/route-stats/{actor_type}/{actor_id}",
|
|
"GET /orgs/{org}/insights/api/subject-stats",
|
|
"GET /orgs/{org}/insights/api/user-stats/{user_id}",
|
|
"GET /orgs/{org}/installations",
|
|
"GET /orgs/{org}/invitations",
|
|
"GET /orgs/{org}/invitations/{invitation_id}/teams",
|
|
"GET /orgs/{org}/issues",
|
|
"GET /orgs/{org}/members",
|
|
"GET /orgs/{org}/members/{username}/codespaces",
|
|
"GET /orgs/{org}/migrations",
|
|
"GET /orgs/{org}/migrations/{migration_id}/repositories",
|
|
"GET /orgs/{org}/organization-roles/{role_id}/teams",
|
|
"GET /orgs/{org}/organization-roles/{role_id}/users",
|
|
"GET /orgs/{org}/outside_collaborators",
|
|
"GET /orgs/{org}/packages",
|
|
"GET /orgs/{org}/packages/{package_type}/{package_name}/versions",
|
|
"GET /orgs/{org}/personal-access-token-requests",
|
|
"GET /orgs/{org}/personal-access-token-requests/{pat_request_id}/repositories",
|
|
"GET /orgs/{org}/personal-access-tokens",
|
|
"GET /orgs/{org}/personal-access-tokens/{pat_id}/repositories",
|
|
"GET /orgs/{org}/private-registries",
|
|
"GET /orgs/{org}/projects",
|
|
"GET /orgs/{org}/projectsV2",
|
|
"GET /orgs/{org}/projectsV2/{project_number}/fields",
|
|
"GET /orgs/{org}/projectsV2/{project_number}/items",
|
|
"GET /orgs/{org}/properties/values",
|
|
"GET /orgs/{org}/public_members",
|
|
"GET /orgs/{org}/repos",
|
|
"GET /orgs/{org}/rulesets",
|
|
"GET /orgs/{org}/rulesets/rule-suites",
|
|
"GET /orgs/{org}/rulesets/{ruleset_id}/history",
|
|
"GET /orgs/{org}/secret-scanning/alerts",
|
|
"GET /orgs/{org}/security-advisories",
|
|
"GET /orgs/{org}/settings/immutable-releases/repositories",
|
|
"GET /orgs/{org}/settings/network-configurations",
|
|
"GET /orgs/{org}/team/{team_slug}/copilot/metrics",
|
|
"GET /orgs/{org}/teams",
|
|
"GET /orgs/{org}/teams/{team_slug}/discussions",
|
|
"GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments",
|
|
"GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions",
|
|
"GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions",
|
|
"GET /orgs/{org}/teams/{team_slug}/invitations",
|
|
"GET /orgs/{org}/teams/{team_slug}/members",
|
|
"GET /orgs/{org}/teams/{team_slug}/projects",
|
|
"GET /orgs/{org}/teams/{team_slug}/repos",
|
|
"GET /orgs/{org}/teams/{team_slug}/teams",
|
|
"GET /projects/{project_id}/collaborators",
|
|
"GET /repos/{owner}/{repo}/actions/artifacts",
|
|
"GET /repos/{owner}/{repo}/actions/caches",
|
|
"GET /repos/{owner}/{repo}/actions/organization-secrets",
|
|
"GET /repos/{owner}/{repo}/actions/organization-variables",
|
|
"GET /repos/{owner}/{repo}/actions/runners",
|
|
"GET /repos/{owner}/{repo}/actions/runs",
|
|
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts",
|
|
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs",
|
|
"GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs",
|
|
"GET /repos/{owner}/{repo}/actions/secrets",
|
|
"GET /repos/{owner}/{repo}/actions/variables",
|
|
"GET /repos/{owner}/{repo}/actions/workflows",
|
|
"GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs",
|
|
"GET /repos/{owner}/{repo}/activity",
|
|
"GET /repos/{owner}/{repo}/assignees",
|
|
"GET /repos/{owner}/{repo}/attestations/{subject_digest}",
|
|
"GET /repos/{owner}/{repo}/branches",
|
|
"GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations",
|
|
"GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs",
|
|
"GET /repos/{owner}/{repo}/code-scanning/alerts",
|
|
"GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances",
|
|
"GET /repos/{owner}/{repo}/code-scanning/analyses",
|
|
"GET /repos/{owner}/{repo}/codespaces",
|
|
"GET /repos/{owner}/{repo}/codespaces/devcontainers",
|
|
"GET /repos/{owner}/{repo}/codespaces/secrets",
|
|
"GET /repos/{owner}/{repo}/collaborators",
|
|
"GET /repos/{owner}/{repo}/comments",
|
|
"GET /repos/{owner}/{repo}/comments/{comment_id}/reactions",
|
|
"GET /repos/{owner}/{repo}/commits",
|
|
"GET /repos/{owner}/{repo}/commits/{commit_sha}/comments",
|
|
"GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls",
|
|
"GET /repos/{owner}/{repo}/commits/{ref}/check-runs",
|
|
"GET /repos/{owner}/{repo}/commits/{ref}/check-suites",
|
|
"GET /repos/{owner}/{repo}/commits/{ref}/status",
|
|
"GET /repos/{owner}/{repo}/commits/{ref}/statuses",
|
|
"GET /repos/{owner}/{repo}/compare/{basehead}",
|
|
"GET /repos/{owner}/{repo}/compare/{base}...{head}",
|
|
"GET /repos/{owner}/{repo}/contributors",
|
|
"GET /repos/{owner}/{repo}/dependabot/alerts",
|
|
"GET /repos/{owner}/{repo}/dependabot/secrets",
|
|
"GET /repos/{owner}/{repo}/deployments",
|
|
"GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses",
|
|
"GET /repos/{owner}/{repo}/environments",
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies",
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/apps",
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/secrets",
|
|
"GET /repos/{owner}/{repo}/environments/{environment_name}/variables",
|
|
"GET /repos/{owner}/{repo}/events",
|
|
"GET /repos/{owner}/{repo}/forks",
|
|
"GET /repos/{owner}/{repo}/hooks",
|
|
"GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries",
|
|
"GET /repos/{owner}/{repo}/invitations",
|
|
"GET /repos/{owner}/{repo}/issues",
|
|
"GET /repos/{owner}/{repo}/issues/comments",
|
|
"GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions",
|
|
"GET /repos/{owner}/{repo}/issues/events",
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/comments",
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by",
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocking",
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/events",
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/labels",
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/reactions",
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/sub_issues",
|
|
"GET /repos/{owner}/{repo}/issues/{issue_number}/timeline",
|
|
"GET /repos/{owner}/{repo}/keys",
|
|
"GET /repos/{owner}/{repo}/labels",
|
|
"GET /repos/{owner}/{repo}/milestones",
|
|
"GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels",
|
|
"GET /repos/{owner}/{repo}/notifications",
|
|
"GET /repos/{owner}/{repo}/pages/builds",
|
|
"GET /repos/{owner}/{repo}/projects",
|
|
"GET /repos/{owner}/{repo}/pulls",
|
|
"GET /repos/{owner}/{repo}/pulls/comments",
|
|
"GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions",
|
|
"GET /repos/{owner}/{repo}/pulls/{pull_number}/comments",
|
|
"GET /repos/{owner}/{repo}/pulls/{pull_number}/commits",
|
|
"GET /repos/{owner}/{repo}/pulls/{pull_number}/files",
|
|
"GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews",
|
|
"GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments",
|
|
"GET /repos/{owner}/{repo}/releases",
|
|
"GET /repos/{owner}/{repo}/releases/{release_id}/assets",
|
|
"GET /repos/{owner}/{repo}/releases/{release_id}/reactions",
|
|
"GET /repos/{owner}/{repo}/rules/branches/{branch}",
|
|
"GET /repos/{owner}/{repo}/rulesets",
|
|
"GET /repos/{owner}/{repo}/rulesets/rule-suites",
|
|
"GET /repos/{owner}/{repo}/rulesets/{ruleset_id}/history",
|
|
"GET /repos/{owner}/{repo}/secret-scanning/alerts",
|
|
"GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations",
|
|
"GET /repos/{owner}/{repo}/security-advisories",
|
|
"GET /repos/{owner}/{repo}/stargazers",
|
|
"GET /repos/{owner}/{repo}/subscribers",
|
|
"GET /repos/{owner}/{repo}/tags",
|
|
"GET /repos/{owner}/{repo}/teams",
|
|
"GET /repos/{owner}/{repo}/topics",
|
|
"GET /repositories",
|
|
"GET /search/code",
|
|
"GET /search/commits",
|
|
"GET /search/issues",
|
|
"GET /search/labels",
|
|
"GET /search/repositories",
|
|
"GET /search/topics",
|
|
"GET /search/users",
|
|
"GET /teams/{team_id}/discussions",
|
|
"GET /teams/{team_id}/discussions/{discussion_number}/comments",
|
|
"GET /teams/{team_id}/discussions/{discussion_number}/comments/{comment_number}/reactions",
|
|
"GET /teams/{team_id}/discussions/{discussion_number}/reactions",
|
|
"GET /teams/{team_id}/invitations",
|
|
"GET /teams/{team_id}/members",
|
|
"GET /teams/{team_id}/projects",
|
|
"GET /teams/{team_id}/repos",
|
|
"GET /teams/{team_id}/teams",
|
|
"GET /user/blocks",
|
|
"GET /user/codespaces",
|
|
"GET /user/codespaces/secrets",
|
|
"GET /user/emails",
|
|
"GET /user/followers",
|
|
"GET /user/following",
|
|
"GET /user/gpg_keys",
|
|
"GET /user/installations",
|
|
"GET /user/installations/{installation_id}/repositories",
|
|
"GET /user/issues",
|
|
"GET /user/keys",
|
|
"GET /user/marketplace_purchases",
|
|
"GET /user/marketplace_purchases/stubbed",
|
|
"GET /user/memberships/orgs",
|
|
"GET /user/migrations",
|
|
"GET /user/migrations/{migration_id}/repositories",
|
|
"GET /user/orgs",
|
|
"GET /user/packages",
|
|
"GET /user/packages/{package_type}/{package_name}/versions",
|
|
"GET /user/public_emails",
|
|
"GET /user/repos",
|
|
"GET /user/repository_invitations",
|
|
"GET /user/social_accounts",
|
|
"GET /user/ssh_signing_keys",
|
|
"GET /user/starred",
|
|
"GET /user/subscriptions",
|
|
"GET /user/teams",
|
|
"GET /users",
|
|
"GET /users/{username}/attestations/{subject_digest}",
|
|
"GET /users/{username}/events",
|
|
"GET /users/{username}/events/orgs/{org}",
|
|
"GET /users/{username}/events/public",
|
|
"GET /users/{username}/followers",
|
|
"GET /users/{username}/following",
|
|
"GET /users/{username}/gists",
|
|
"GET /users/{username}/gpg_keys",
|
|
"GET /users/{username}/keys",
|
|
"GET /users/{username}/orgs",
|
|
"GET /users/{username}/packages",
|
|
"GET /users/{username}/projects",
|
|
"GET /users/{username}/projectsV2",
|
|
"GET /users/{username}/projectsV2/{project_number}/fields",
|
|
"GET /users/{username}/projectsV2/{project_number}/items",
|
|
"GET /users/{username}/received_events",
|
|
"GET /users/{username}/received_events/public",
|
|
"GET /users/{username}/repos",
|
|
"GET /users/{username}/social_accounts",
|
|
"GET /users/{username}/ssh_signing_keys",
|
|
"GET /users/{username}/starred",
|
|
"GET /users/{username}/subscriptions"
|
|
]));
|
|
|
|
// pkg/dist-src/paginating-endpoints.js
|
|
function isPaginatingEndpoint(arg) {
|
|
if (typeof arg === "string") {
|
|
return paginatingEndpoints.includes(arg);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// pkg/dist-src/index.js
|
|
function paginateRest(octokit) {
|
|
return {
|
|
paginate: Object.assign(paginate.bind(null, octokit), {
|
|
iterator: iterator.bind(null, octokit)
|
|
})
|
|
};
|
|
}
|
|
paginateRest.VERSION = plugin_paginate_rest_dist_bundle_VERSION;
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/github/lib/utils.js
|
|
|
|
|
|
// octokit + plugins
|
|
|
|
|
|
|
|
const context = new Context();
|
|
const baseUrl = getApiBaseUrl();
|
|
const defaults = {
|
|
baseUrl,
|
|
request: {
|
|
agent: getProxyAgent(baseUrl),
|
|
fetch: getProxyFetch(baseUrl)
|
|
}
|
|
};
|
|
const GitHub = Octokit.plugin(restEndpointMethods, paginateRest).defaults(defaults);
|
|
|
|
/**
|
|
* Convience function to correctly format Octokit Options to pass into the constructor.
|
|
*
|
|
* @param token the repo PAT or GITHUB_TOKEN
|
|
* @param options other options to set
|
|
*/
|
|
function getOctokitOptions(token, options) {
|
|
const opts = Object.assign({}, options || {}); // Shallow clone - don't mutate the object provided by the caller
|
|
// Auth
|
|
const auth = getAuthString(token, opts);
|
|
if (auth) {
|
|
opts.auth = auth;
|
|
}
|
|
// Orchestration ID
|
|
const userAgent = getUserAgentWithOrchestrationId(opts.userAgent);
|
|
if (userAgent) {
|
|
opts.userAgent = userAgent;
|
|
}
|
|
return opts;
|
|
}
|
|
//# sourceMappingURL=utils.js.map
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/github/lib/github.js
|
|
|
|
|
|
const github_context = new Context();
|
|
/**
|
|
* Returns a hydrated octokit ready to use for GitHub Actions
|
|
*
|
|
* @param token the repo PAT or GITHUB_TOKEN
|
|
* @param options other options to set
|
|
*/
|
|
function getOctokit(token, options, ...additionalPlugins) {
|
|
const GitHubWithPlugins = GitHub.plugin(...additionalPlugins);
|
|
return new GitHubWithPlugins(getOctokitOptions(token, options));
|
|
}
|
|
//# sourceMappingURL=github.js.map
|
|
// EXTERNAL MODULE: ./node_modules/@actions/tool-cache/node_modules/semver/index.js
|
|
var node_modules_semver = __nccwpck_require__(885);
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/tool-cache/lib/manifest.js
|
|
var manifest_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// Internal object for testability (allows mocking in ESM)
|
|
const _internal = {
|
|
readLinuxVersionFile() {
|
|
const lsbReleaseFile = '/etc/lsb-release';
|
|
const osReleaseFile = '/etc/os-release';
|
|
let contents = '';
|
|
if (external_fs_namespaceObject.existsSync(lsbReleaseFile)) {
|
|
contents = external_fs_namespaceObject.readFileSync(lsbReleaseFile).toString();
|
|
}
|
|
else if (external_fs_namespaceObject.existsSync(osReleaseFile)) {
|
|
contents = external_fs_namespaceObject.readFileSync(osReleaseFile).toString();
|
|
}
|
|
return contents;
|
|
}
|
|
};
|
|
function _findMatch(versionSpec, stable, candidates, archFilter) {
|
|
return manifest_awaiter(this, void 0, void 0, function* () {
|
|
const platFilter = os.platform();
|
|
let result;
|
|
let match;
|
|
let file;
|
|
for (const candidate of candidates) {
|
|
const version = candidate.version;
|
|
debug(`check ${version} satisfies ${versionSpec}`);
|
|
if (semver.satisfies(version, versionSpec) &&
|
|
(!stable || candidate.stable === stable)) {
|
|
file = candidate.files.find(item => {
|
|
debug(`${item.arch}===${archFilter} && ${item.platform}===${platFilter}`);
|
|
let chk = item.arch === archFilter && item.platform === platFilter;
|
|
if (chk && item.platform_version) {
|
|
const osVersion = _getOsVersion();
|
|
if (osVersion === item.platform_version) {
|
|
chk = true;
|
|
}
|
|
else {
|
|
chk = semver.satisfies(osVersion, item.platform_version);
|
|
}
|
|
}
|
|
return chk;
|
|
});
|
|
if (file) {
|
|
debug(`matched ${candidate.version}`);
|
|
match = candidate;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (match && file) {
|
|
// clone since we're mutating the file list to be only the file that matches
|
|
result = Object.assign({}, match);
|
|
result.files = [file];
|
|
}
|
|
return result;
|
|
});
|
|
}
|
|
function _getOsVersion() {
|
|
// TODO: add windows and other linux, arm variants
|
|
// right now filtering on version is only an ubuntu and macos scenario for tools we build for hosted (python)
|
|
const plat = os.platform();
|
|
let version = '';
|
|
if (plat === 'darwin') {
|
|
version = cp.execSync('sw_vers -productVersion').toString();
|
|
}
|
|
else if (plat === 'linux') {
|
|
// lsb_release process not in some containers, readfile
|
|
// Run cat /etc/lsb-release
|
|
// DISTRIB_ID=Ubuntu
|
|
// DISTRIB_RELEASE=18.04
|
|
// DISTRIB_CODENAME=bionic
|
|
// DISTRIB_DESCRIPTION="Ubuntu 18.04.4 LTS"
|
|
const lsbContents = _internal.readLinuxVersionFile();
|
|
if (lsbContents) {
|
|
const lines = lsbContents.split('\n');
|
|
for (const line of lines) {
|
|
const parts = line.split('=');
|
|
if (parts.length === 2 &&
|
|
(parts[0].trim() === 'VERSION_ID' ||
|
|
parts[0].trim() === 'DISTRIB_RELEASE')) {
|
|
version = parts[1].trim().replace(/^"/, '').replace(/"$/, '');
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return version;
|
|
}
|
|
// Alias for backwards compatibility
|
|
function _readLinuxVersionFile() {
|
|
return _internal.readLinuxVersionFile();
|
|
}
|
|
//# sourceMappingURL=manifest.js.map
|
|
;// CONCATENATED MODULE: external "stream"
|
|
const external_stream_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("stream");
|
|
// EXTERNAL MODULE: external "util"
|
|
var external_util_ = __nccwpck_require__(9023);
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/tool-cache/lib/retry-helper.js
|
|
var retry_helper_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Internal class for retries
|
|
*/
|
|
class lib_retry_helper_RetryHelper {
|
|
constructor(maxAttempts, minSeconds, maxSeconds) {
|
|
if (maxAttempts < 1) {
|
|
throw new Error('max attempts should be greater than or equal to 1');
|
|
}
|
|
this.maxAttempts = maxAttempts;
|
|
this.minSeconds = Math.floor(minSeconds);
|
|
this.maxSeconds = Math.floor(maxSeconds);
|
|
if (this.minSeconds > this.maxSeconds) {
|
|
throw new Error('min seconds should be less than or equal to max seconds');
|
|
}
|
|
}
|
|
execute(action, isRetryable) {
|
|
return retry_helper_awaiter(this, void 0, void 0, function* () {
|
|
let attempt = 1;
|
|
while (attempt < this.maxAttempts) {
|
|
// Try
|
|
try {
|
|
return yield action();
|
|
}
|
|
catch (err) {
|
|
if (isRetryable && !isRetryable(err)) {
|
|
throw err;
|
|
}
|
|
core.info(err.message);
|
|
}
|
|
// Sleep
|
|
const seconds = this.getSleepAmount();
|
|
core.info(`Waiting ${seconds} seconds before trying again`);
|
|
yield this.sleep(seconds);
|
|
attempt++;
|
|
}
|
|
// Last attempt
|
|
return yield action();
|
|
});
|
|
}
|
|
getSleepAmount() {
|
|
return (Math.floor(Math.random() * (this.maxSeconds - this.minSeconds + 1)) +
|
|
this.minSeconds);
|
|
}
|
|
sleep(seconds) {
|
|
return retry_helper_awaiter(this, void 0, void 0, function* () {
|
|
return new Promise(resolve => setTimeout(resolve, seconds * 1000));
|
|
});
|
|
}
|
|
}
|
|
//# sourceMappingURL=retry-helper.js.map
|
|
;// CONCATENATED MODULE: ./node_modules/@actions/tool-cache/lib/tool-cache.js
|
|
var tool_cache_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class HTTPError extends Error {
|
|
constructor(httpStatusCode) {
|
|
super(`Unexpected HTTP response: ${httpStatusCode}`);
|
|
this.httpStatusCode = httpStatusCode;
|
|
Object.setPrototypeOf(this, new.target.prototype);
|
|
}
|
|
}
|
|
const tool_cache_IS_WINDOWS = process.platform === 'win32';
|
|
const IS_MAC = process.platform === 'darwin';
|
|
const tool_cache_userAgent = 'actions/tool-cache';
|
|
/**
|
|
* Download a tool from an url and stream it into a file
|
|
*
|
|
* @param url url of tool to download
|
|
* @param dest path to download tool
|
|
* @param auth authorization header
|
|
* @param headers other headers
|
|
* @returns path to downloaded tool
|
|
*/
|
|
function downloadTool(url, dest, auth, headers) {
|
|
return tool_cache_awaiter(this, void 0, void 0, function* () {
|
|
dest = dest || path.join(_getTempDirectory(), crypto.randomUUID());
|
|
yield io.mkdirP(path.dirname(dest));
|
|
core.debug(`Downloading ${url}`);
|
|
core.debug(`Destination ${dest}`);
|
|
const maxAttempts = 3;
|
|
const minSeconds = _getGlobal('TEST_DOWNLOAD_TOOL_RETRY_MIN_SECONDS', 10);
|
|
const maxSeconds = _getGlobal('TEST_DOWNLOAD_TOOL_RETRY_MAX_SECONDS', 20);
|
|
const retryHelper = new RetryHelper(maxAttempts, minSeconds, maxSeconds);
|
|
return yield retryHelper.execute(() => tool_cache_awaiter(this, void 0, void 0, function* () {
|
|
return yield downloadToolAttempt(url, dest || '', auth, headers);
|
|
}), (err) => {
|
|
if (err instanceof HTTPError && err.httpStatusCode) {
|
|
// Don't retry anything less than 500, except 408 Request Timeout and 429 Too Many Requests
|
|
if (err.httpStatusCode < 500 &&
|
|
err.httpStatusCode !== 408 &&
|
|
err.httpStatusCode !== 429) {
|
|
return false;
|
|
}
|
|
}
|
|
// Otherwise retry
|
|
return true;
|
|
});
|
|
});
|
|
}
|
|
function downloadToolAttempt(url, dest, auth, headers) {
|
|
return tool_cache_awaiter(this, void 0, void 0, function* () {
|
|
if (fs.existsSync(dest)) {
|
|
throw new Error(`Destination file path ${dest} already exists`);
|
|
}
|
|
// Get the response headers
|
|
const http = new httpm.HttpClient(tool_cache_userAgent, [], {
|
|
allowRetries: false
|
|
});
|
|
if (auth) {
|
|
core.debug('set auth');
|
|
if (headers === undefined) {
|
|
headers = {};
|
|
}
|
|
headers.authorization = auth;
|
|
}
|
|
const response = yield http.get(url, headers);
|
|
if (response.message.statusCode !== 200) {
|
|
const err = new HTTPError(response.message.statusCode);
|
|
core.debug(`Failed to download from "${url}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`);
|
|
throw err;
|
|
}
|
|
// Download the response body
|
|
const pipeline = util.promisify(stream.pipeline);
|
|
const responseMessageFactory = _getGlobal('TEST_DOWNLOAD_TOOL_RESPONSE_MESSAGE_FACTORY', () => response.message);
|
|
const readStream = responseMessageFactory();
|
|
let succeeded = false;
|
|
try {
|
|
yield pipeline(readStream, fs.createWriteStream(dest));
|
|
core.debug('download complete');
|
|
succeeded = true;
|
|
return dest;
|
|
}
|
|
finally {
|
|
// Error, delete dest before retry
|
|
if (!succeeded) {
|
|
core.debug('download failed');
|
|
try {
|
|
yield io.rmRF(dest);
|
|
}
|
|
catch (err) {
|
|
core.debug(`Failed to delete '${dest}'. ${err.message}`);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Extract a .7z file
|
|
*
|
|
* @param file path to the .7z file
|
|
* @param dest destination directory. Optional.
|
|
* @param _7zPath path to 7zr.exe. Optional, for long path support. Most .7z archives do not have this
|
|
* problem. If your .7z archive contains very long paths, you can pass the path to 7zr.exe which will
|
|
* gracefully handle long paths. By default 7zdec.exe is used because it is a very small program and is
|
|
* bundled with the tool lib. However it does not support long paths. 7zr.exe is the reduced command line
|
|
* interface, it is smaller than the full command line interface, and it does support long paths. At the
|
|
* time of this writing, it is freely available from the LZMA SDK that is available on the 7zip website.
|
|
* Be sure to check the current license agreement. If 7zr.exe is bundled with your action, then the path
|
|
* to 7zr.exe can be pass to this function.
|
|
* @returns path to the destination directory
|
|
*/
|
|
function extract7z(file, dest, _7zPath) {
|
|
return tool_cache_awaiter(this, void 0, void 0, function* () {
|
|
ok(tool_cache_IS_WINDOWS, 'extract7z() not supported on current OS');
|
|
ok(file, 'parameter "file" is required');
|
|
dest = yield _createExtractFolder(dest);
|
|
const originalCwd = process.cwd();
|
|
process.chdir(dest);
|
|
if (_7zPath) {
|
|
try {
|
|
const logLevel = core.isDebug() ? '-bb1' : '-bb0';
|
|
const args = [
|
|
'x', // eXtract files with full paths
|
|
logLevel, // -bb[0-3] : set output log level
|
|
'-bd', // disable progress indicator
|
|
'-sccUTF-8', // set charset for for console input/output
|
|
file
|
|
];
|
|
const options = {
|
|
silent: true
|
|
};
|
|
yield exec(`"${_7zPath}"`, args, options);
|
|
}
|
|
finally {
|
|
process.chdir(originalCwd);
|
|
}
|
|
}
|
|
else {
|
|
const escapedScript = path
|
|
.join(__dirname, '..', 'scripts', 'Invoke-7zdec.ps1')
|
|
.replace(/'/g, "''")
|
|
.replace(/"|\n|\r/g, ''); // double-up single quotes, remove double quotes and newlines
|
|
const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, '');
|
|
const escapedTarget = dest.replace(/'/g, "''").replace(/"|\n|\r/g, '');
|
|
const command = `& '${escapedScript}' -Source '${escapedFile}' -Target '${escapedTarget}'`;
|
|
const args = [
|
|
'-NoLogo',
|
|
'-Sta',
|
|
'-NoProfile',
|
|
'-NonInteractive',
|
|
'-ExecutionPolicy',
|
|
'Unrestricted',
|
|
'-Command',
|
|
command
|
|
];
|
|
const options = {
|
|
silent: true
|
|
};
|
|
try {
|
|
const powershellPath = yield io.which('powershell', true);
|
|
yield exec(`"${powershellPath}"`, args, options);
|
|
}
|
|
finally {
|
|
process.chdir(originalCwd);
|
|
}
|
|
}
|
|
return dest;
|
|
});
|
|
}
|
|
/**
|
|
* Extract a compressed tar archive
|
|
*
|
|
* @param file path to the tar
|
|
* @param dest destination directory. Optional.
|
|
* @param flags flags for the tar command to use for extraction. Defaults to 'xz' (extracting gzipped tars). Optional.
|
|
* @returns path to the destination directory
|
|
*/
|
|
function extractTar(file_1, dest_1) {
|
|
return tool_cache_awaiter(this, arguments, void 0, function* (file, dest, flags = 'xz') {
|
|
if (!file) {
|
|
throw new Error("parameter 'file' is required");
|
|
}
|
|
// Create dest
|
|
dest = yield _createExtractFolder(dest);
|
|
// Determine whether GNU tar
|
|
core_debug('Checking tar --version');
|
|
let versionOutput = '';
|
|
yield exec_exec('tar --version', [], {
|
|
ignoreReturnCode: true,
|
|
silent: true,
|
|
listeners: {
|
|
stdout: (data) => (versionOutput += data.toString()),
|
|
stderr: (data) => (versionOutput += data.toString())
|
|
}
|
|
});
|
|
core_debug(versionOutput.trim());
|
|
const isGnuTar = versionOutput.toUpperCase().includes('GNU TAR');
|
|
// Initialize args
|
|
let args;
|
|
if (flags instanceof Array) {
|
|
args = flags;
|
|
}
|
|
else {
|
|
args = [flags];
|
|
}
|
|
if (isDebug() && !flags.includes('v')) {
|
|
args.push('-v');
|
|
}
|
|
let destArg = dest;
|
|
let fileArg = file;
|
|
if (tool_cache_IS_WINDOWS && isGnuTar) {
|
|
args.push('--force-local');
|
|
destArg = dest.replace(/\\/g, '/');
|
|
// Technically only the dest needs to have `/` but for aesthetic consistency
|
|
// convert slashes in the file arg too.
|
|
fileArg = file.replace(/\\/g, '/');
|
|
}
|
|
if (isGnuTar) {
|
|
// Suppress warnings when using GNU tar to extract archives created by BSD tar
|
|
args.push('--warning=no-unknown-keyword');
|
|
args.push('--overwrite');
|
|
}
|
|
args.push('-C', destArg, '-f', fileArg);
|
|
yield exec_exec(`tar`, args);
|
|
return dest;
|
|
});
|
|
}
|
|
/**
|
|
* Extract a xar compatible archive
|
|
*
|
|
* @param file path to the archive
|
|
* @param dest destination directory. Optional.
|
|
* @param flags flags for the xar. Optional.
|
|
* @returns path to the destination directory
|
|
*/
|
|
function extractXar(file_1, dest_1) {
|
|
return tool_cache_awaiter(this, arguments, void 0, function* (file, dest, flags = []) {
|
|
ok(IS_MAC, 'extractXar() not supported on current OS');
|
|
ok(file, 'parameter "file" is required');
|
|
dest = yield _createExtractFolder(dest);
|
|
let args;
|
|
if (flags instanceof Array) {
|
|
args = flags;
|
|
}
|
|
else {
|
|
args = [flags];
|
|
}
|
|
args.push('-x', '-C', dest, '-f', file);
|
|
if (core.isDebug()) {
|
|
args.push('-v');
|
|
}
|
|
const xarPath = yield io.which('xar', true);
|
|
yield exec(`"${xarPath}"`, _unique(args));
|
|
return dest;
|
|
});
|
|
}
|
|
/**
|
|
* Extract a zip
|
|
*
|
|
* @param file path to the zip
|
|
* @param dest destination directory. Optional.
|
|
* @returns path to the destination directory
|
|
*/
|
|
function extractZip(file, dest) {
|
|
return tool_cache_awaiter(this, void 0, void 0, function* () {
|
|
if (!file) {
|
|
throw new Error("parameter 'file' is required");
|
|
}
|
|
dest = yield _createExtractFolder(dest);
|
|
if (tool_cache_IS_WINDOWS) {
|
|
yield extractZipWin(file, dest);
|
|
}
|
|
else {
|
|
yield extractZipNix(file, dest);
|
|
}
|
|
return dest;
|
|
});
|
|
}
|
|
function extractZipWin(file, dest) {
|
|
return tool_cache_awaiter(this, void 0, void 0, function* () {
|
|
// build the powershell command
|
|
const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, ''); // double-up single quotes, remove double quotes and newlines
|
|
const escapedDest = dest.replace(/'/g, "''").replace(/"|\n|\r/g, '');
|
|
const pwshPath = yield which('pwsh', false);
|
|
//To match the file overwrite behavior on nix systems, we use the overwrite = true flag for ExtractToDirectory
|
|
//and the -Force flag for Expand-Archive as a fallback
|
|
if (pwshPath) {
|
|
//attempt to use pwsh with ExtractToDirectory, if this fails attempt Expand-Archive
|
|
const pwshCommand = [
|
|
`$ErrorActionPreference = 'Stop' ;`,
|
|
`try { Add-Type -AssemblyName System.IO.Compression.ZipFile } catch { } ;`,
|
|
`try { [System.IO.Compression.ZipFile]::ExtractToDirectory('${escapedFile}', '${escapedDest}', $true) }`,
|
|
`catch { if (($_.Exception.GetType().FullName -eq 'System.Management.Automation.MethodException') -or ($_.Exception.GetType().FullName -eq 'System.Management.Automation.RuntimeException') ){ Expand-Archive -LiteralPath '${escapedFile}' -DestinationPath '${escapedDest}' -Force } else { throw $_ } } ;`
|
|
].join(' ');
|
|
const args = [
|
|
'-NoLogo',
|
|
'-NoProfile',
|
|
'-NonInteractive',
|
|
'-ExecutionPolicy',
|
|
'Unrestricted',
|
|
'-Command',
|
|
pwshCommand
|
|
];
|
|
core_debug(`Using pwsh at path: ${pwshPath}`);
|
|
yield exec_exec(`"${pwshPath}"`, args);
|
|
}
|
|
else {
|
|
const powershellCommand = [
|
|
`$ErrorActionPreference = 'Stop' ;`,
|
|
`try { Add-Type -AssemblyName System.IO.Compression.FileSystem } catch { } ;`,
|
|
`if ((Get-Command -Name Expand-Archive -Module Microsoft.PowerShell.Archive -ErrorAction Ignore)) { Expand-Archive -LiteralPath '${escapedFile}' -DestinationPath '${escapedDest}' -Force }`,
|
|
`else {[System.IO.Compression.ZipFile]::ExtractToDirectory('${escapedFile}', '${escapedDest}', $true) }`
|
|
].join(' ');
|
|
const args = [
|
|
'-NoLogo',
|
|
'-Sta',
|
|
'-NoProfile',
|
|
'-NonInteractive',
|
|
'-ExecutionPolicy',
|
|
'Unrestricted',
|
|
'-Command',
|
|
powershellCommand
|
|
];
|
|
const powershellPath = yield which('powershell', true);
|
|
core_debug(`Using powershell at path: ${powershellPath}`);
|
|
yield exec_exec(`"${powershellPath}"`, args);
|
|
}
|
|
});
|
|
}
|
|
function extractZipNix(file, dest) {
|
|
return tool_cache_awaiter(this, void 0, void 0, function* () {
|
|
const unzipPath = yield which('unzip', true);
|
|
const args = [file];
|
|
if (!isDebug()) {
|
|
args.unshift('-q');
|
|
}
|
|
args.unshift('-o'); //overwrite with -o, otherwise a prompt is shown which freezes the run
|
|
yield exec_exec(`"${unzipPath}"`, args, { cwd: dest });
|
|
});
|
|
}
|
|
/**
|
|
* Caches a directory and installs it into the tool cacheDir
|
|
*
|
|
* @param sourceDir the directory to cache into tools
|
|
* @param tool tool name
|
|
* @param version version of the tool. semver format
|
|
* @param arch architecture of the tool. Optional. Defaults to machine architecture
|
|
*/
|
|
function cacheDir(sourceDir, tool, version, arch) {
|
|
return tool_cache_awaiter(this, void 0, void 0, function* () {
|
|
version = semver.clean(version) || version;
|
|
arch = arch || os.arch();
|
|
core.debug(`Caching tool ${tool} ${version} ${arch}`);
|
|
core.debug(`source dir: ${sourceDir}`);
|
|
if (!fs.statSync(sourceDir).isDirectory()) {
|
|
throw new Error('sourceDir is not a directory');
|
|
}
|
|
// Create the tool dir
|
|
const destPath = yield _createToolPath(tool, version, arch);
|
|
// copy each child item. do not move. move can fail on Windows
|
|
// due to anti-virus software having an open handle on a file.
|
|
for (const itemName of fs.readdirSync(sourceDir)) {
|
|
const s = path.join(sourceDir, itemName);
|
|
yield io.cp(s, destPath, { recursive: true });
|
|
}
|
|
// write .complete
|
|
_completeToolPath(tool, version, arch);
|
|
return destPath;
|
|
});
|
|
}
|
|
/**
|
|
* Caches a downloaded file (GUID) and installs it
|
|
* into the tool cache with a given targetName
|
|
*
|
|
* @param sourceFile the file to cache into tools. Typically a result of downloadTool which is a guid.
|
|
* @param targetFile the name of the file name in the tools directory
|
|
* @param tool tool name
|
|
* @param version version of the tool. semver format
|
|
* @param arch architecture of the tool. Optional. Defaults to machine architecture
|
|
*/
|
|
function cacheFile(sourceFile, targetFile, tool, version, arch) {
|
|
return tool_cache_awaiter(this, void 0, void 0, function* () {
|
|
version = semver.clean(version) || version;
|
|
arch = arch || os.arch();
|
|
core.debug(`Caching tool ${tool} ${version} ${arch}`);
|
|
core.debug(`source file: ${sourceFile}`);
|
|
if (!fs.statSync(sourceFile).isFile()) {
|
|
throw new Error('sourceFile is not a file');
|
|
}
|
|
// create the tool dir
|
|
const destFolder = yield _createToolPath(tool, version, arch);
|
|
// copy instead of move. move can fail on Windows due to
|
|
// anti-virus software having an open handle on a file.
|
|
const destPath = path.join(destFolder, targetFile);
|
|
core.debug(`destination file ${destPath}`);
|
|
yield io.cp(sourceFile, destPath);
|
|
// write .complete
|
|
_completeToolPath(tool, version, arch);
|
|
return destFolder;
|
|
});
|
|
}
|
|
/**
|
|
* Finds the path to a tool version in the local installed tool cache
|
|
*
|
|
* @param toolName name of the tool
|
|
* @param versionSpec version of the tool
|
|
* @param arch optional arch. defaults to arch of computer
|
|
*/
|
|
function find(toolName, versionSpec, arch) {
|
|
if (!toolName) {
|
|
throw new Error('toolName parameter is required');
|
|
}
|
|
if (!versionSpec) {
|
|
throw new Error('versionSpec parameter is required');
|
|
}
|
|
arch = arch || os.arch();
|
|
// attempt to resolve an explicit version
|
|
if (!isExplicitVersion(versionSpec)) {
|
|
const localVersions = findAllVersions(toolName, arch);
|
|
const match = evaluateVersions(localVersions, versionSpec);
|
|
versionSpec = match;
|
|
}
|
|
// check for the explicit version in the cache
|
|
let toolPath = '';
|
|
if (versionSpec) {
|
|
versionSpec = semver.clean(versionSpec) || '';
|
|
const cachePath = path.join(_getCacheDirectory(), toolName, versionSpec, arch);
|
|
core.debug(`checking cache: ${cachePath}`);
|
|
if (fs.existsSync(cachePath) && fs.existsSync(`${cachePath}.complete`)) {
|
|
core.debug(`Found tool in cache ${toolName} ${versionSpec} ${arch}`);
|
|
toolPath = cachePath;
|
|
}
|
|
else {
|
|
core.debug('not found');
|
|
}
|
|
}
|
|
return toolPath;
|
|
}
|
|
/**
|
|
* Finds the paths to all versions of a tool that are installed in the local tool cache
|
|
*
|
|
* @param toolName name of the tool
|
|
* @param arch optional arch. defaults to arch of computer
|
|
*/
|
|
function findAllVersions(toolName, arch) {
|
|
const versions = [];
|
|
arch = arch || os.arch();
|
|
const toolPath = path.join(_getCacheDirectory(), toolName);
|
|
if (fs.existsSync(toolPath)) {
|
|
const children = fs.readdirSync(toolPath);
|
|
for (const child of children) {
|
|
if (isExplicitVersion(child)) {
|
|
const fullPath = path.join(toolPath, child, arch || '');
|
|
if (fs.existsSync(fullPath) && fs.existsSync(`${fullPath}.complete`)) {
|
|
versions.push(child);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return versions;
|
|
}
|
|
function getManifestFromRepo(owner_1, repo_1, auth_1) {
|
|
return tool_cache_awaiter(this, arguments, void 0, function* (owner, repo, auth, branch = 'master') {
|
|
let releases = [];
|
|
const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}`;
|
|
const http = new httpm.HttpClient('tool-cache');
|
|
const headers = {};
|
|
if (auth) {
|
|
core.debug('set auth');
|
|
headers.authorization = auth;
|
|
}
|
|
const response = yield http.getJson(treeUrl, headers);
|
|
if (!response.result) {
|
|
return releases;
|
|
}
|
|
let manifestUrl = '';
|
|
for (const item of response.result.tree) {
|
|
if (item.path === 'versions-manifest.json') {
|
|
manifestUrl = item.url;
|
|
break;
|
|
}
|
|
}
|
|
headers['accept'] = 'application/vnd.github.VERSION.raw';
|
|
let versionsRaw = yield (yield http.get(manifestUrl, headers)).readBody();
|
|
if (versionsRaw) {
|
|
// shouldn't be needed but protects against invalid json saved with BOM
|
|
versionsRaw = versionsRaw.replace(/^\uFEFF/, '');
|
|
try {
|
|
releases = JSON.parse(versionsRaw);
|
|
}
|
|
catch (_a) {
|
|
core.debug('Invalid json');
|
|
}
|
|
}
|
|
return releases;
|
|
});
|
|
}
|
|
function findFromManifest(versionSpec_1, stable_1, manifest_1) {
|
|
return tool_cache_awaiter(this, arguments, void 0, function* (versionSpec, stable, manifest, archFilter = os.arch()) {
|
|
// wrap the internal impl
|
|
const match = yield mm._findMatch(versionSpec, stable, manifest, archFilter);
|
|
return match;
|
|
});
|
|
}
|
|
function _createExtractFolder(dest) {
|
|
return tool_cache_awaiter(this, void 0, void 0, function* () {
|
|
if (!dest) {
|
|
// create a temp dir
|
|
dest = external_path_namespaceObject.join(_getTempDirectory(), external_crypto_namespaceObject.randomUUID());
|
|
}
|
|
yield mkdirP(dest);
|
|
return dest;
|
|
});
|
|
}
|
|
function _createToolPath(tool, version, arch) {
|
|
return tool_cache_awaiter(this, void 0, void 0, function* () {
|
|
const folderPath = path.join(_getCacheDirectory(), tool, semver.clean(version) || version, arch || '');
|
|
core.debug(`destination ${folderPath}`);
|
|
const markerPath = `${folderPath}.complete`;
|
|
yield io.rmRF(folderPath);
|
|
yield io.rmRF(markerPath);
|
|
yield io.mkdirP(folderPath);
|
|
return folderPath;
|
|
});
|
|
}
|
|
function _completeToolPath(tool, version, arch) {
|
|
const folderPath = path.join(_getCacheDirectory(), tool, semver.clean(version) || version, arch || '');
|
|
const markerPath = `${folderPath}.complete`;
|
|
fs.writeFileSync(markerPath, '');
|
|
core.debug('finished caching tool');
|
|
}
|
|
/**
|
|
* Check if version string is explicit
|
|
*
|
|
* @param versionSpec version string to check
|
|
*/
|
|
function isExplicitVersion(versionSpec) {
|
|
const c = semver.clean(versionSpec) || '';
|
|
core.debug(`isExplicit: ${c}`);
|
|
const valid = semver.valid(c) != null;
|
|
core.debug(`explicit? ${valid}`);
|
|
return valid;
|
|
}
|
|
/**
|
|
* Get the highest satisfiying semantic version in `versions` which satisfies `versionSpec`
|
|
*
|
|
* @param versions array of versions to evaluate
|
|
* @param versionSpec semantic version spec to satisfy
|
|
*/
|
|
function evaluateVersions(versions, versionSpec) {
|
|
let version = '';
|
|
core.debug(`evaluating ${versions.length} versions`);
|
|
versions = versions.sort((a, b) => {
|
|
if (semver.gt(a, b)) {
|
|
return 1;
|
|
}
|
|
return -1;
|
|
});
|
|
for (let i = versions.length - 1; i >= 0; i--) {
|
|
const potential = versions[i];
|
|
const satisfied = semver.satisfies(potential, versionSpec);
|
|
if (satisfied) {
|
|
version = potential;
|
|
break;
|
|
}
|
|
}
|
|
if (version) {
|
|
core.debug(`matched: ${version}`);
|
|
}
|
|
else {
|
|
core.debug('match not found');
|
|
}
|
|
return version;
|
|
}
|
|
/**
|
|
* Gets RUNNER_TOOL_CACHE
|
|
*/
|
|
function _getCacheDirectory() {
|
|
const cacheDirectory = process.env['RUNNER_TOOL_CACHE'] || '';
|
|
ok(cacheDirectory, 'Expected RUNNER_TOOL_CACHE to be defined');
|
|
return cacheDirectory;
|
|
}
|
|
/**
|
|
* Gets RUNNER_TEMP
|
|
*/
|
|
function _getTempDirectory() {
|
|
const tempDirectory = process.env['RUNNER_TEMP'] || '';
|
|
(0,external_assert_.ok)(tempDirectory, 'Expected RUNNER_TEMP to be defined');
|
|
return tempDirectory;
|
|
}
|
|
/**
|
|
* Gets a global variable
|
|
*/
|
|
function _getGlobal(key, defaultValue) {
|
|
/* eslint-disable @typescript-eslint/no-explicit-any */
|
|
const value = global[key];
|
|
/* eslint-enable @typescript-eslint/no-explicit-any */
|
|
return value !== undefined ? value : defaultValue;
|
|
}
|
|
/**
|
|
* Returns an array of unique values.
|
|
* @param values Values to make unique.
|
|
*/
|
|
function _unique(values) {
|
|
return Array.from(new Set(values));
|
|
}
|
|
//# sourceMappingURL=tool-cache.js.map
|
|
;// CONCATENATED MODULE: ./src/github-api-helper.ts
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const github_api_helper_IS_WINDOWS = process.platform === 'win32';
|
|
async function downloadRepository(authToken, owner, repo, ref, commit, repositoryPath, baseUrl) {
|
|
// Determine the default branch
|
|
if (!ref && !commit) {
|
|
info('Determining the default branch');
|
|
ref = await getDefaultBranch(authToken, owner, repo, baseUrl);
|
|
}
|
|
// Download the archive
|
|
let archiveData = await execute(async () => {
|
|
info('Downloading the archive');
|
|
return await downloadArchive(authToken, owner, repo, ref, commit, baseUrl);
|
|
});
|
|
// Write archive to disk
|
|
info('Writing archive to disk');
|
|
const uniqueId = (0,external_crypto_namespaceObject.randomUUID)();
|
|
const archivePath = github_api_helper_IS_WINDOWS
|
|
? external_path_namespaceObject.join(repositoryPath, `${uniqueId}.zip`)
|
|
: external_path_namespaceObject.join(repositoryPath, `${uniqueId}.tar.gz`);
|
|
await external_fs_namespaceObject.promises.writeFile(archivePath, archiveData);
|
|
archiveData = Buffer.from(''); // Free memory
|
|
// Extract archive
|
|
info('Extracting the archive');
|
|
const extractPath = external_path_namespaceObject.join(repositoryPath, uniqueId);
|
|
await mkdirP(extractPath);
|
|
if (github_api_helper_IS_WINDOWS) {
|
|
await extractZip(archivePath, extractPath);
|
|
}
|
|
else {
|
|
await extractTar(archivePath, extractPath);
|
|
}
|
|
await rmRF(archivePath);
|
|
// Determine the path of the repository content. The archive contains
|
|
// a top-level folder and the repository content is inside.
|
|
const archiveFileNames = await external_fs_namespaceObject.promises.readdir(extractPath);
|
|
external_assert_.ok(archiveFileNames.length == 1, 'Expected exactly one directory inside archive');
|
|
const archiveVersion = archiveFileNames[0]; // The top-level folder name includes the short SHA
|
|
info(`Resolved version ${archiveVersion}`);
|
|
const tempRepositoryPath = external_path_namespaceObject.join(extractPath, archiveVersion);
|
|
// Move the files
|
|
for (const fileName of await external_fs_namespaceObject.promises.readdir(tempRepositoryPath)) {
|
|
const sourcePath = external_path_namespaceObject.join(tempRepositoryPath, fileName);
|
|
const targetPath = external_path_namespaceObject.join(repositoryPath, fileName);
|
|
if (github_api_helper_IS_WINDOWS) {
|
|
await io_cp(sourcePath, targetPath, { recursive: true }); // Copy on Windows (Windows Defender may have a lock)
|
|
}
|
|
else {
|
|
await mv(sourcePath, targetPath);
|
|
}
|
|
}
|
|
await rmRF(extractPath);
|
|
}
|
|
/**
|
|
* Looks up the default branch name
|
|
*/
|
|
async function getDefaultBranch(authToken, owner, repo, baseUrl) {
|
|
return await execute(async () => {
|
|
info('Retrieving the default branch name');
|
|
const octokit = getOctokit(authToken, {
|
|
baseUrl: getServerApiUrl(baseUrl)
|
|
});
|
|
let result;
|
|
try {
|
|
// Get the default branch from the repo info
|
|
const response = await octokit.rest.repos.get({ owner, repo });
|
|
result = response.data.default_branch;
|
|
external_assert_.ok(result, 'default_branch cannot be empty');
|
|
}
|
|
catch (err) {
|
|
// Handle .wiki repo
|
|
if (err?.status === 404 &&
|
|
repo.toUpperCase().endsWith('.WIKI')) {
|
|
result = 'master';
|
|
}
|
|
// Otherwise error
|
|
else {
|
|
throw err;
|
|
}
|
|
}
|
|
// Print the default branch
|
|
info(`Default branch '${result}'`);
|
|
// Prefix with 'refs/heads'
|
|
if (!result.startsWith('refs/')) {
|
|
result = `refs/heads/${result}`;
|
|
}
|
|
return result;
|
|
});
|
|
}
|
|
async function tryGetRepositoryObjectFormat(authToken, owner, repo, baseUrl, commit) {
|
|
const commitFormat = getObjectFormat(commit);
|
|
if (commitFormat) {
|
|
return { format: commitFormat, succeeded: true };
|
|
}
|
|
try {
|
|
const octokit = getOctokit(authToken, {
|
|
baseUrl: getServerApiUrl(baseUrl)
|
|
});
|
|
const response = await octokit.request('GET /repos/{owner}/{repo}/hash-algorithm', { owner, repo });
|
|
const hashAlgorithm = response.data.hash_algorithm;
|
|
if (hashAlgorithm === 'sha256' || hashAlgorithm === 'sha1') {
|
|
return { format: hashAlgorithm, succeeded: true };
|
|
}
|
|
core_debug('Unable to determine repository object format from hash-algorithm endpoint');
|
|
return { format: '', succeeded: false };
|
|
}
|
|
catch (err) {
|
|
core_debug(`Unable to determine repository object format from hash-algorithm endpoint: ${err?.message ?? err}`);
|
|
return { format: '', succeeded: false };
|
|
}
|
|
}
|
|
function getObjectFormat(sha) {
|
|
if (/^[0-9a-fA-F]{64}$/.test(sha || '')) {
|
|
return 'sha256';
|
|
}
|
|
if (/^[0-9a-fA-F]{40}$/.test(sha || '')) {
|
|
return 'sha1';
|
|
}
|
|
return '';
|
|
}
|
|
async function downloadArchive(authToken, owner, repo, ref, commit, baseUrl) {
|
|
const octokit = getOctokit(authToken, {
|
|
baseUrl: getServerApiUrl(baseUrl)
|
|
});
|
|
const download = github_api_helper_IS_WINDOWS
|
|
? octokit.rest.repos.downloadZipballArchive
|
|
: octokit.rest.repos.downloadTarballArchive;
|
|
const response = await download({
|
|
owner: owner,
|
|
repo: repo,
|
|
ref: commit || ref
|
|
});
|
|
return Buffer.from(response.data); // response.data is ArrayBuffer
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/ref-helper.ts
|
|
|
|
|
|
|
|
const tagsRefSpec = '+refs/tags/*:refs/tags/*';
|
|
async function getCheckoutInfo(git, ref, commit) {
|
|
if (!git) {
|
|
throw new Error('Arg git cannot be empty');
|
|
}
|
|
if (!ref && !commit) {
|
|
throw new Error('Args ref and commit cannot both be empty');
|
|
}
|
|
const result = {};
|
|
const upperRef = (ref || '').toUpperCase();
|
|
// SHA only
|
|
if (!ref) {
|
|
result.ref = commit;
|
|
}
|
|
// refs/heads/
|
|
else if (upperRef.startsWith('REFS/HEADS/')) {
|
|
const branch = ref.substring('refs/heads/'.length);
|
|
result.ref = branch;
|
|
result.startPoint = `refs/remotes/origin/${branch}`;
|
|
}
|
|
// refs/pull/
|
|
else if (upperRef.startsWith('REFS/PULL/')) {
|
|
const branch = ref.substring('refs/pull/'.length);
|
|
result.ref = `refs/remotes/pull/${branch}`;
|
|
}
|
|
// refs/tags/
|
|
else if (upperRef.startsWith('REFS/TAGS/')) {
|
|
result.ref = ref;
|
|
}
|
|
// refs/
|
|
else if (upperRef.startsWith('REFS/')) {
|
|
result.ref = commit ? commit : ref;
|
|
}
|
|
// Unqualified ref, check for a matching branch or tag
|
|
else {
|
|
if (await git.branchExists(true, `origin/${ref}`)) {
|
|
result.ref = ref;
|
|
result.startPoint = `refs/remotes/origin/${ref}`;
|
|
}
|
|
else if (await git.tagExists(`${ref}`)) {
|
|
result.ref = `refs/tags/${ref}`;
|
|
}
|
|
else {
|
|
throw new Error(`A branch or tag with the name '${ref}' could not be found`);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getRefSpecForAllHistory(ref, commit) {
|
|
const result = ['+refs/heads/*:refs/remotes/origin/*', tagsRefSpec];
|
|
if (ref && ref.toUpperCase().startsWith('REFS/PULL/')) {
|
|
const branch = ref.substring('refs/pull/'.length);
|
|
result.push(`+${commit || ref}:refs/remotes/pull/${branch}`);
|
|
}
|
|
return result;
|
|
}
|
|
function getRefSpec(ref, commit, fetchTags) {
|
|
if (!ref && !commit) {
|
|
throw new Error('Args ref and commit cannot both be empty');
|
|
}
|
|
const upperRef = (ref || '').toUpperCase();
|
|
const result = [];
|
|
// When fetchTags is true, always include the tags refspec
|
|
if (fetchTags) {
|
|
result.push(tagsRefSpec);
|
|
}
|
|
// SHA
|
|
if (commit) {
|
|
// refs/heads
|
|
if (upperRef.startsWith('REFS/HEADS/')) {
|
|
const branch = ref.substring('refs/heads/'.length);
|
|
result.push(`+${commit}:refs/remotes/origin/${branch}`);
|
|
}
|
|
// refs/pull/
|
|
else if (upperRef.startsWith('REFS/PULL/')) {
|
|
const branch = ref.substring('refs/pull/'.length);
|
|
result.push(`+${commit}:refs/remotes/pull/${branch}`);
|
|
}
|
|
// refs/tags/
|
|
else if (upperRef.startsWith('REFS/TAGS/')) {
|
|
if (!fetchTags) {
|
|
result.push(`+${ref}:${ref}`);
|
|
}
|
|
}
|
|
// Otherwise no destination ref
|
|
else {
|
|
result.push(commit);
|
|
}
|
|
}
|
|
// Unqualified ref, check for a matching branch or tag
|
|
else if (!upperRef.startsWith('REFS/')) {
|
|
result.push(`+refs/heads/${ref}*:refs/remotes/origin/${ref}*`);
|
|
if (!fetchTags) {
|
|
result.push(`+refs/tags/${ref}*:refs/tags/${ref}*`);
|
|
}
|
|
}
|
|
// refs/heads/
|
|
else if (upperRef.startsWith('REFS/HEADS/')) {
|
|
const branch = ref.substring('refs/heads/'.length);
|
|
result.push(`+${ref}:refs/remotes/origin/${branch}`);
|
|
}
|
|
// refs/pull/
|
|
else if (upperRef.startsWith('REFS/PULL/')) {
|
|
const branch = ref.substring('refs/pull/'.length);
|
|
result.push(`+${ref}:refs/remotes/pull/${branch}`);
|
|
}
|
|
// refs/tags/
|
|
else if (upperRef.startsWith('REFS/TAGS/')) {
|
|
if (!fetchTags) {
|
|
result.push(`+${ref}:${ref}`);
|
|
}
|
|
}
|
|
// Other refs
|
|
else {
|
|
result.push(`+${ref}:${ref}`);
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Tests whether the initial fetch created the ref at the expected commit
|
|
*/
|
|
async function testRef(git, ref, commit) {
|
|
if (!git) {
|
|
throw new Error('Arg git cannot be empty');
|
|
}
|
|
if (!ref && !commit) {
|
|
throw new Error('Args ref and commit cannot both be empty');
|
|
}
|
|
// No SHA? Nothing to test
|
|
if (!commit) {
|
|
return true;
|
|
}
|
|
// SHA only?
|
|
else if (!ref) {
|
|
return await git.shaExists(commit);
|
|
}
|
|
const upperRef = ref.toUpperCase();
|
|
// refs/heads/
|
|
if (upperRef.startsWith('REFS/HEADS/')) {
|
|
const branch = ref.substring('refs/heads/'.length);
|
|
return ((await git.branchExists(true, `origin/${branch}`)) &&
|
|
commit === (await git.revParse(`refs/remotes/origin/${branch}`)));
|
|
}
|
|
// refs/pull/
|
|
else if (upperRef.startsWith('REFS/PULL/')) {
|
|
// Assume matches because fetched using the commit
|
|
return true;
|
|
}
|
|
// refs/tags/
|
|
else if (upperRef.startsWith('REFS/TAGS/')) {
|
|
const tagName = ref.substring('refs/tags/'.length);
|
|
// Use ^{commit} to dereference annotated tags to their underlying commit
|
|
return ((await git.tagExists(tagName)) &&
|
|
commit === (await git.revParse(`${ref}^{commit}`)));
|
|
}
|
|
// Unexpected
|
|
else {
|
|
core_debug(`Unexpected ref format '${ref}' when testing ref info`);
|
|
return true;
|
|
}
|
|
}
|
|
async function checkCommitInfo(token, commitInfo, repositoryOwner, repositoryName, ref, commit, baseUrl) {
|
|
try {
|
|
// GHES?
|
|
if (isGhes(baseUrl)) {
|
|
return;
|
|
}
|
|
// Auth token?
|
|
if (!token) {
|
|
return;
|
|
}
|
|
// Public PR synchronize, for workflow repo?
|
|
if (fromPayload('repository.private') !== false ||
|
|
github_context.eventName !== 'pull_request' ||
|
|
fromPayload('action') !== 'synchronize' ||
|
|
repositoryOwner !== github_context.repo.owner ||
|
|
repositoryName !== github_context.repo.repo ||
|
|
ref !== github_context.ref ||
|
|
!ref.startsWith('refs/pull/') ||
|
|
commit !== github_context.sha) {
|
|
return;
|
|
}
|
|
// Head SHA
|
|
const expectedHeadSha = fromPayload('after');
|
|
if (!expectedHeadSha) {
|
|
core_debug('Unable to determine head sha');
|
|
return;
|
|
}
|
|
// Base SHA
|
|
const expectedBaseSha = fromPayload('pull_request.base.sha');
|
|
if (!expectedBaseSha) {
|
|
core_debug('Unable to determine base sha');
|
|
return;
|
|
}
|
|
// Expected message?
|
|
const expectedMessage = `Merge ${expectedHeadSha} into ${expectedBaseSha}`;
|
|
if (commitInfo.indexOf(expectedMessage) >= 0) {
|
|
return;
|
|
}
|
|
// Extract details from message
|
|
const match = commitInfo.match(/Merge ([0-9a-f]{40}|[0-9a-f]{64}) into ([0-9a-f]{40}|[0-9a-f]{64})/);
|
|
if (!match) {
|
|
core_debug('Unexpected message format');
|
|
return;
|
|
}
|
|
// Post telemetry
|
|
const actualHeadSha = match[1];
|
|
if (actualHeadSha !== expectedHeadSha) {
|
|
core_debug(`Expected head sha ${expectedHeadSha}; actual head sha ${actualHeadSha}`);
|
|
const octokit = getOctokit(token, {
|
|
baseUrl: getServerApiUrl(baseUrl),
|
|
userAgent: `actions-checkout-tracepoint/1.0 (code=STALE_MERGE;owner=${repositoryOwner};repo=${repositoryName};pr=${fromPayload('number')};run_id=${process.env['GITHUB_RUN_ID']};expected_head_sha=${expectedHeadSha};actual_head_sha=${actualHeadSha})`
|
|
});
|
|
await octokit.rest.repos.get({
|
|
owner: repositoryOwner,
|
|
repo: repositoryName
|
|
});
|
|
}
|
|
}
|
|
catch (err) {
|
|
core_debug(`Error when validating commit info: ${err?.stack ?? err}`);
|
|
}
|
|
}
|
|
function fromPayload(path) {
|
|
return ref_helper_select(github_context.payload, path);
|
|
}
|
|
function ref_helper_select(obj, path) {
|
|
if (!obj) {
|
|
return undefined;
|
|
}
|
|
const i = path.indexOf('.');
|
|
if (i < 0) {
|
|
return obj[path];
|
|
}
|
|
const key = path.substr(0, i);
|
|
return ref_helper_select(obj[key], path.substr(i + 1));
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/git-source-provider.ts
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
async function getSource(settings) {
|
|
// Repository URL
|
|
info(`Syncing repository: ${settings.repositoryOwner}/${settings.repositoryName}`);
|
|
const repositoryUrl = getFetchUrl(settings);
|
|
// Remove conflicting file path
|
|
if (fileExistsSync(settings.repositoryPath)) {
|
|
await rmRF(settings.repositoryPath);
|
|
}
|
|
// Create directory
|
|
let isExisting = true;
|
|
if (!directoryExistsSync(settings.repositoryPath)) {
|
|
isExisting = false;
|
|
await mkdirP(settings.repositoryPath);
|
|
}
|
|
// Git command manager
|
|
startGroup('Getting Git version info');
|
|
const git = await getGitCommandManager(settings);
|
|
endGroup();
|
|
let authHelper = null;
|
|
try {
|
|
if (git) {
|
|
authHelper = createAuthHelper(git, settings);
|
|
if (settings.setSafeDirectory) {
|
|
// Setup the repository path as a safe directory, so if we pass this into a container job with a different user it doesn't fail
|
|
// Otherwise all git commands we run in a container fail
|
|
await authHelper.configureTempGlobalConfig();
|
|
info(`Adding repository directory to the temporary git global config as a safe directory`);
|
|
await git
|
|
.config('safe.directory', settings.repositoryPath, true, true)
|
|
.catch(error => {
|
|
info(`Failed to initialize safe directory with error: ${error}`);
|
|
});
|
|
setSafeDirectory();
|
|
}
|
|
}
|
|
// Prepare existing directory, otherwise recreate
|
|
if (isExisting) {
|
|
await prepareExistingDirectory(git, settings.repositoryPath, repositoryUrl, settings.clean, settings.ref);
|
|
}
|
|
if (!git) {
|
|
// Downloading using REST API
|
|
info(`The repository will be downloaded using the GitHub REST API`);
|
|
info(`To create a local Git repository instead, add Git ${MinimumGitVersion} or higher to the PATH`);
|
|
if (settings.submodules) {
|
|
throw new Error(`Input 'submodules' not supported when falling back to download using the GitHub REST API. To create a local Git repository instead, add Git ${MinimumGitVersion} or higher to the PATH.`);
|
|
}
|
|
else if (settings.sshKey) {
|
|
throw new Error(`Input 'ssh-key' not supported when falling back to download using the GitHub REST API. To create a local Git repository instead, add Git ${MinimumGitVersion} or higher to the PATH.`);
|
|
}
|
|
await downloadRepository(settings.authToken, settings.repositoryOwner, settings.repositoryName, settings.ref, settings.commit, settings.repositoryPath, settings.githubServerUrl);
|
|
return;
|
|
}
|
|
// Save state for POST action
|
|
setRepositoryPath(settings.repositoryPath);
|
|
// Initialize the repository
|
|
if (!directoryExistsSync(external_path_namespaceObject.join(settings.repositoryPath, '.git'))) {
|
|
startGroup('Determining repository object format');
|
|
const objectFormatResult = await tryGetRepositoryObjectFormat(settings.authToken, settings.repositoryOwner, settings.repositoryName, settings.githubServerUrl, settings.commit);
|
|
const objectFormat = objectFormatResult.succeeded
|
|
? objectFormatResult.format
|
|
: '';
|
|
if (objectFormat === 'sha256') {
|
|
info('Detected SHA-256 repository object format');
|
|
}
|
|
endGroup();
|
|
startGroup('Initializing the repository');
|
|
await git.init(objectFormat);
|
|
await git.remoteAdd('origin', repositoryUrl);
|
|
endGroup();
|
|
}
|
|
// Disable automatic garbage collection
|
|
startGroup('Disabling automatic garbage collection');
|
|
if (!(await git.tryDisableAutomaticGarbageCollection())) {
|
|
warning(`Unable to turn off git automatic garbage collection. The git fetch operation may trigger garbage collection and cause a delay.`);
|
|
}
|
|
endGroup();
|
|
// If we didn't initialize it above, do it now
|
|
if (!authHelper) {
|
|
authHelper = createAuthHelper(git, settings);
|
|
}
|
|
// Configure auth
|
|
startGroup('Setting up auth');
|
|
await authHelper.configureAuth();
|
|
endGroup();
|
|
// Determine the default branch
|
|
if (!settings.ref && !settings.commit) {
|
|
startGroup('Determining the default branch');
|
|
if (settings.sshKey) {
|
|
settings.ref = await git.getDefaultBranch(repositoryUrl);
|
|
}
|
|
else {
|
|
settings.ref = await getDefaultBranch(settings.authToken, settings.repositoryOwner, settings.repositoryName, settings.githubServerUrl);
|
|
}
|
|
endGroup();
|
|
}
|
|
// LFS install
|
|
if (settings.lfs) {
|
|
await git.lfsInstall();
|
|
}
|
|
// Fetch
|
|
startGroup('Fetching the repository');
|
|
const fetchOptions = {};
|
|
if (settings.filter) {
|
|
fetchOptions.filter = settings.filter;
|
|
}
|
|
else if (settings.sparseCheckout) {
|
|
fetchOptions.filter = 'blob:none';
|
|
}
|
|
if (settings.fetchDepth <= 0) {
|
|
// Fetch all branches and tags
|
|
let refSpec = getRefSpecForAllHistory(settings.ref, settings.commit);
|
|
await git.fetch(refSpec, fetchOptions);
|
|
// When all history is fetched, the ref we're interested in may have moved to a different
|
|
// commit (push or force push). If so, fetch again with a targeted refspec.
|
|
if (!(await testRef(git, settings.ref, settings.commit))) {
|
|
refSpec = getRefSpec(settings.ref, settings.commit);
|
|
await git.fetch(refSpec, fetchOptions);
|
|
// Verify the ref now matches. For branches, the targeted fetch above brings
|
|
// in the specific commit. For tags (fetched by ref), this will fail if
|
|
// the tag was moved after the workflow was triggered.
|
|
if (!(await testRef(git, settings.ref, settings.commit))) {
|
|
throw new Error(`The ref '${settings.ref}' does not point to the expected commit '${settings.commit}'. ` +
|
|
`The ref may have been updated after the workflow was triggered.`);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
fetchOptions.fetchDepth = settings.fetchDepth;
|
|
const refSpec = getRefSpec(settings.ref, settings.commit, settings.fetchTags);
|
|
await git.fetch(refSpec, fetchOptions);
|
|
// For tags, verify the ref still points to the expected commit.
|
|
// Tags are fetched by ref (not commit), so if a tag was moved after the
|
|
// workflow was triggered, we would silently check out the wrong commit.
|
|
if (!(await testRef(git, settings.ref, settings.commit))) {
|
|
throw new Error(`The ref '${settings.ref}' does not point to the expected commit '${settings.commit}'. ` +
|
|
`The ref may have been updated after the workflow was triggered.`);
|
|
}
|
|
}
|
|
endGroup();
|
|
// Checkout info
|
|
startGroup('Determining the checkout info');
|
|
const checkoutInfo = await getCheckoutInfo(git, settings.ref, settings.commit);
|
|
endGroup();
|
|
// LFS fetch
|
|
// Explicit lfs-fetch to avoid slow checkout (fetches one lfs object at a time).
|
|
// Explicit lfs fetch will fetch lfs objects in parallel.
|
|
// For sparse checkouts, let `checkout` fetch the needed objects lazily.
|
|
if (settings.lfs && !settings.sparseCheckout) {
|
|
startGroup('Fetching LFS objects');
|
|
await git.lfsFetch(checkoutInfo.startPoint || checkoutInfo.ref);
|
|
endGroup();
|
|
}
|
|
// Sparse checkout
|
|
if (!settings.sparseCheckout) {
|
|
let gitVersion = await git.version();
|
|
// no need to disable sparse-checkout if the installed git runtime doesn't even support it.
|
|
if (gitVersion.checkMinimum(MinimumGitSparseCheckoutVersion)) {
|
|
await git.disableSparseCheckout();
|
|
}
|
|
}
|
|
else {
|
|
startGroup('Setting up sparse checkout');
|
|
if (settings.sparseCheckoutConeMode) {
|
|
await git.sparseCheckout(settings.sparseCheckout);
|
|
}
|
|
else {
|
|
await git.sparseCheckoutNonConeMode(settings.sparseCheckout);
|
|
}
|
|
endGroup();
|
|
}
|
|
// Checkout
|
|
startGroup('Checking out the ref');
|
|
await git.checkout(checkoutInfo.ref, checkoutInfo.startPoint);
|
|
endGroup();
|
|
// Submodules
|
|
if (settings.submodules) {
|
|
// Temporarily override global config
|
|
startGroup('Setting up auth for fetching submodules');
|
|
await authHelper.configureGlobalAuth();
|
|
endGroup();
|
|
// Checkout submodules
|
|
startGroup('Fetching submodules');
|
|
await git.submoduleSync(settings.nestedSubmodules);
|
|
await git.submoduleUpdate(settings.fetchDepth, settings.nestedSubmodules);
|
|
await git.submoduleForeach('git config --local gc.auto 0', settings.nestedSubmodules);
|
|
endGroup();
|
|
// Persist credentials
|
|
if (settings.persistCredentials) {
|
|
startGroup('Persisting credentials for submodules');
|
|
await authHelper.configureSubmoduleAuth();
|
|
endGroup();
|
|
}
|
|
}
|
|
// Get commit information
|
|
const commitInfo = await git.log1();
|
|
// Log commit sha
|
|
const commitSHA = await git.log1('--format=%H');
|
|
setOutput('commit', commitSHA.trim());
|
|
// Check for incorrect pull request merge commit
|
|
await checkCommitInfo(settings.authToken, commitInfo, settings.repositoryOwner, settings.repositoryName, settings.ref, settings.commit, settings.githubServerUrl);
|
|
}
|
|
finally {
|
|
// Remove auth
|
|
if (authHelper) {
|
|
if (!settings.persistCredentials) {
|
|
startGroup('Removing auth');
|
|
await authHelper.removeAuth();
|
|
endGroup();
|
|
}
|
|
authHelper.removeGlobalConfig();
|
|
}
|
|
}
|
|
}
|
|
async function cleanup(repositoryPath) {
|
|
// Repo exists?
|
|
if (!repositoryPath ||
|
|
!fileExistsSync(external_path_namespaceObject.join(repositoryPath, '.git', 'config'))) {
|
|
return;
|
|
}
|
|
let git;
|
|
try {
|
|
git = await createCommandManager(repositoryPath, false, false);
|
|
}
|
|
catch {
|
|
return;
|
|
}
|
|
// Remove auth
|
|
const authHelper = createAuthHelper(git);
|
|
try {
|
|
if (PostSetSafeDirectory) {
|
|
// Setup the repository path as a safe directory, so if we pass this into a container job with a different user it doesn't fail
|
|
// Otherwise all git commands we run in a container fail
|
|
await authHelper.configureTempGlobalConfig();
|
|
info(`Adding repository directory to the temporary git global config as a safe directory`);
|
|
await git
|
|
.config('safe.directory', repositoryPath, true, true)
|
|
.catch(error => {
|
|
info(`Failed to initialize safe directory with error: ${error}`);
|
|
});
|
|
}
|
|
await authHelper.removeAuth();
|
|
}
|
|
finally {
|
|
await authHelper.removeGlobalConfig();
|
|
}
|
|
}
|
|
async function getGitCommandManager(settings) {
|
|
info(`Working directory is '${settings.repositoryPath}'`);
|
|
try {
|
|
return await createCommandManager(settings.repositoryPath, settings.lfs, settings.sparseCheckout != null);
|
|
}
|
|
catch (err) {
|
|
// Git is required for LFS
|
|
if (settings.lfs) {
|
|
throw err;
|
|
}
|
|
// Otherwise fallback to REST API
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/unsafe-pr-checkout-helper.ts
|
|
|
|
|
|
const PR_REF_PATTERN = /^refs\/pull\/[0-9]+\/(?:head|merge)$/;
|
|
function assertSafePrCheckout(input) {
|
|
if (input.allowUnsafePrCheckout) {
|
|
return;
|
|
}
|
|
const eventName = github_context.eventName;
|
|
if (eventName !== 'pull_request_target' && eventName !== 'workflow_run') {
|
|
return;
|
|
}
|
|
const baseRepoId = fromPayload('repository.id');
|
|
if (typeof baseRepoId !== 'number') {
|
|
return;
|
|
}
|
|
let prHeadRepoId;
|
|
let prHeadRepoFullName;
|
|
const prShas = [];
|
|
if (eventName === 'pull_request_target') {
|
|
prHeadRepoId = fromPayload('pull_request.head.repo.id');
|
|
prHeadRepoFullName = fromPayload('pull_request.head.repo.full_name');
|
|
pushIfSha(prShas, fromPayload('pull_request.head.sha'));
|
|
pushIfSha(prShas, fromPayload('pull_request.merge_commit_sha'));
|
|
}
|
|
else {
|
|
const wrEvent = fromPayload('workflow_run.event');
|
|
if (typeof wrEvent !== 'string' || !wrEvent.startsWith('pull_request')) {
|
|
return;
|
|
}
|
|
prHeadRepoId = fromPayload('workflow_run.head_repository.id');
|
|
prHeadRepoFullName = fromPayload('workflow_run.head_repository.full_name');
|
|
pushIfSha(prShas, fromPayload('workflow_run.head_commit.id'));
|
|
// For `pull_request_target`-triggered workflow_run, `head_sha` is the base
|
|
// default branch SHA (not the PR head)
|
|
if (wrEvent !== 'pull_request_target') {
|
|
pushIfSha(prShas, fromPayload('workflow_run.head_sha'));
|
|
}
|
|
}
|
|
// (A) Fork PR?
|
|
if (typeof prHeadRepoId !== 'number' || prHeadRepoId === baseRepoId) {
|
|
return;
|
|
}
|
|
// (B) We cannot check for all fork PR refs so check to see
|
|
// if the resolved input points to the fork PR sha we have in the payload
|
|
const repositoryMatchesPrHead = typeof prHeadRepoFullName === 'string' &&
|
|
input.qualifiedRepository.toLowerCase() === prHeadRepoFullName.toLowerCase();
|
|
const refMatchesPullPattern = PR_REF_PATTERN.test(input.ref);
|
|
const commitMatchesPrHeadSha = !!input.commit && prShas.includes(input.commit.toLowerCase());
|
|
if (!repositoryMatchesPrHead &&
|
|
!refMatchesPullPattern &&
|
|
!commitMatchesPrHeadSha) {
|
|
return;
|
|
}
|
|
throw new Error(`Refusing to check out fork pull request code from a '${eventName}' workflow. ` +
|
|
`This workflow runs with the base repository's GITHUB_TOKEN, secrets, default-branch ` +
|
|
`cache scope, and runner access. Fetching and executing a fork's code in that trusted ` +
|
|
`context commonly leads to "pwn request" vulnerabilities. To opt in after reviewing ` +
|
|
`the risks at https://gh.io/securely-using-pull_request_target, set ` +
|
|
`'allow-unsafe-pr-checkout: true' on the actions/checkout step.`);
|
|
}
|
|
function pushIfSha(target, value) {
|
|
if (typeof value === 'string' && value.length > 0) {
|
|
target.push(value.toLowerCase());
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/workflow-context-helper.ts
|
|
|
|
|
|
/**
|
|
* Gets the organization ID of the running workflow or undefined if the value cannot be loaded from the GITHUB_EVENT_PATH
|
|
*/
|
|
async function getOrganizationId() {
|
|
try {
|
|
const eventPath = process.env.GITHUB_EVENT_PATH;
|
|
if (!eventPath) {
|
|
core_debug(`GITHUB_EVENT_PATH is not defined`);
|
|
return;
|
|
}
|
|
const content = await external_fs_namespaceObject.promises.readFile(eventPath, { encoding: 'utf8' });
|
|
const event = JSON.parse(content);
|
|
const id = event?.repository?.owner?.id;
|
|
if (typeof id !== 'number') {
|
|
core_debug('Repository owner ID not found within GITHUB event info');
|
|
return;
|
|
}
|
|
return id;
|
|
}
|
|
catch (err) {
|
|
core_debug(`Unable to load organization ID from GITHUB_EVENT_PATH: ${err.message || err}`);
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/input-helper.ts
|
|
|
|
|
|
|
|
|
|
|
|
|
|
async function getInputs() {
|
|
const result = {};
|
|
// GitHub workspace
|
|
let githubWorkspacePath = process.env['GITHUB_WORKSPACE'];
|
|
if (!githubWorkspacePath) {
|
|
throw new Error('GITHUB_WORKSPACE not defined');
|
|
}
|
|
githubWorkspacePath = external_path_namespaceObject.resolve(githubWorkspacePath);
|
|
core_debug(`GITHUB_WORKSPACE = '${githubWorkspacePath}'`);
|
|
directoryExistsSync(githubWorkspacePath, true);
|
|
// Qualified repository
|
|
const qualifiedRepository = getInput('repository') ||
|
|
`${github_context.repo.owner}/${github_context.repo.repo}`;
|
|
core_debug(`qualified repository = '${qualifiedRepository}'`);
|
|
const splitRepository = qualifiedRepository.split('/');
|
|
if (splitRepository.length !== 2 ||
|
|
!splitRepository[0] ||
|
|
!splitRepository[1]) {
|
|
throw new Error(`Invalid repository '${qualifiedRepository}'. Expected format {owner}/{repo}.`);
|
|
}
|
|
result.repositoryOwner = splitRepository[0];
|
|
result.repositoryName = splitRepository[1];
|
|
// Repository path
|
|
result.repositoryPath = getInput('path') || '.';
|
|
result.repositoryPath = external_path_namespaceObject.resolve(githubWorkspacePath, result.repositoryPath);
|
|
if (!(result.repositoryPath + external_path_namespaceObject.sep).startsWith(githubWorkspacePath + external_path_namespaceObject.sep)) {
|
|
throw new Error(`Repository path '${result.repositoryPath}' is not under '${githubWorkspacePath}'`);
|
|
}
|
|
// Workflow repository?
|
|
const isWorkflowRepository = qualifiedRepository.toUpperCase() ===
|
|
`${github_context.repo.owner}/${github_context.repo.repo}`.toUpperCase();
|
|
// Source branch, source version
|
|
result.ref = getInput('ref');
|
|
if (!result.ref) {
|
|
if (isWorkflowRepository) {
|
|
result.ref = github_context.ref;
|
|
result.commit = github_context.sha;
|
|
// Some events have an unqualifed ref. For example when a PR is merged (pull_request closed event),
|
|
// the ref is unqualifed like "main" instead of "refs/heads/main".
|
|
if (result.commit && result.ref && !result.ref.startsWith('refs/')) {
|
|
result.ref = `refs/heads/${result.ref}`;
|
|
}
|
|
}
|
|
}
|
|
// SHA?
|
|
else if (result.ref.match(/^(?:[0-9a-fA-F]{40}|[0-9a-fA-F]{64})$/)) {
|
|
result.commit = result.ref;
|
|
result.ref = '';
|
|
}
|
|
core_debug(`ref = '${result.ref}'`);
|
|
core_debug(`commit = '${result.commit}'`);
|
|
// Clean
|
|
result.clean = (getInput('clean') || 'true').toUpperCase() === 'TRUE';
|
|
core_debug(`clean = ${result.clean}`);
|
|
// Filter
|
|
const filter = getInput('filter');
|
|
if (filter) {
|
|
result.filter = filter;
|
|
}
|
|
core_debug(`filter = ${result.filter}`);
|
|
// Sparse checkout
|
|
const sparseCheckout = getMultilineInput('sparse-checkout');
|
|
if (sparseCheckout.length) {
|
|
result.sparseCheckout = sparseCheckout;
|
|
core_debug(`sparse checkout = ${result.sparseCheckout}`);
|
|
}
|
|
result.sparseCheckoutConeMode =
|
|
(getInput('sparse-checkout-cone-mode') || 'true').toUpperCase() ===
|
|
'TRUE';
|
|
// Fetch depth
|
|
result.fetchDepth = Math.floor(Number(getInput('fetch-depth') || '1'));
|
|
if (isNaN(result.fetchDepth) || result.fetchDepth < 0) {
|
|
result.fetchDepth = 0;
|
|
}
|
|
core_debug(`fetch depth = ${result.fetchDepth}`);
|
|
// Fetch tags
|
|
result.fetchTags =
|
|
(getInput('fetch-tags') || 'false').toUpperCase() === 'TRUE';
|
|
core_debug(`fetch tags = ${result.fetchTags}`);
|
|
// Show fetch progress
|
|
result.showProgress =
|
|
(getInput('show-progress') || 'true').toUpperCase() === 'TRUE';
|
|
core_debug(`show progress = ${result.showProgress}`);
|
|
// LFS
|
|
result.lfs = (getInput('lfs') || 'false').toUpperCase() === 'TRUE';
|
|
core_debug(`lfs = ${result.lfs}`);
|
|
// Submodules
|
|
result.submodules = false;
|
|
result.nestedSubmodules = false;
|
|
const submodulesString = (getInput('submodules') || '').toUpperCase();
|
|
if (submodulesString == 'RECURSIVE') {
|
|
result.submodules = true;
|
|
result.nestedSubmodules = true;
|
|
}
|
|
else if (submodulesString == 'TRUE') {
|
|
result.submodules = true;
|
|
}
|
|
core_debug(`submodules = ${result.submodules}`);
|
|
core_debug(`recursive submodules = ${result.nestedSubmodules}`);
|
|
// Auth token
|
|
result.authToken = getInput('token', { required: true });
|
|
// SSH
|
|
result.sshKey = getInput('ssh-key');
|
|
result.sshKnownHosts = getInput('ssh-known-hosts');
|
|
result.sshStrict =
|
|
(getInput('ssh-strict') || 'true').toUpperCase() === 'TRUE';
|
|
result.sshUser = getInput('ssh-user');
|
|
// Persist credentials
|
|
result.persistCredentials =
|
|
(getInput('persist-credentials') || 'false').toUpperCase() === 'TRUE';
|
|
// Workflow organization ID
|
|
result.workflowOrganizationId =
|
|
await getOrganizationId();
|
|
// Set safe.directory in git global config.
|
|
result.setSafeDirectory =
|
|
(getInput('set-safe-directory') || 'true').toUpperCase() === 'TRUE';
|
|
// Determine the GitHub URL that the repository is being hosted from
|
|
result.githubServerUrl = getInput('github-server-url');
|
|
core_debug(`GitHub Host URL = ${result.githubServerUrl}`);
|
|
// Allow unsafe PR checkout (opt-in for pull_request_target / workflow_run fork PRs)
|
|
result.allowUnsafePrCheckout =
|
|
(getInput('allow-unsafe-pr-checkout') || 'false').toUpperCase() ===
|
|
'TRUE';
|
|
core_debug(`allow unsafe PR checkout = ${result.allowUnsafePrCheckout}`);
|
|
assertSafePrCheckout({
|
|
qualifiedRepository,
|
|
ref: result.ref,
|
|
commit: result.commit,
|
|
allowUnsafePrCheckout: result.allowUnsafePrCheckout
|
|
});
|
|
return result;
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/main.ts
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const main_dirname = external_path_namespaceObject.dirname((0,external_url_namespaceObject.fileURLToPath)(import.meta.url));
|
|
async function run() {
|
|
try {
|
|
const sourceSettings = await getInputs();
|
|
try {
|
|
// Register problem matcher
|
|
info(`::add-matcher::${external_path_namespaceObject.join(main_dirname, 'problem-matcher.json')}`);
|
|
// Get sources
|
|
await getSource(sourceSettings);
|
|
setOutput('ref', sourceSettings.ref);
|
|
}
|
|
finally {
|
|
// Unregister problem matcher
|
|
info('::remove-matcher owner=checkout-git::');
|
|
}
|
|
}
|
|
catch (error) {
|
|
setFailed(`${error?.message ?? error}`);
|
|
}
|
|
}
|
|
async function main_cleanup() {
|
|
try {
|
|
await cleanup(RepositoryPath);
|
|
}
|
|
catch (error) {
|
|
warning(`${error?.message ?? error}`);
|
|
}
|
|
}
|
|
// Main
|
|
if (!IsPost) {
|
|
run();
|
|
}
|
|
// Post
|
|
else {
|
|
main_cleanup();
|
|
}
|
|
|