diff --git a/dist/main/index.js b/dist/main/index.js
index 7beb145..1b72894 100644
--- a/dist/main/index.js
+++ b/dist/main/index.js
@@ -252,6 +252,38 @@ var eos = function(stream, opts, callback) {
module.exports = eos;
+/***/ }),
+
+/***/ 10:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = __webpack_require__(534);
+exports.default = (url) => {
+ // Cast to URL
+ url = url;
+ const options = {
+ protocol: url.protocol,
+ hostname: is_1.default.string(url.hostname) && url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname,
+ host: url.host,
+ hash: url.hash,
+ search: url.search,
+ pathname: url.pathname,
+ href: url.href,
+ path: `${url.pathname || ''}${url.search || ''}`
+ };
+ if (is_1.default.string(url.port) && url.port.length !== 0) {
+ options.port = Number(url.port);
+ }
+ if (url.username || url.password) {
+ options.auth = `${url.username || ''}:${url.password || ''}`;
+ }
+ return options;
+};
+
+
/***/ }),
/***/ 11:
@@ -392,6 +424,41 @@ module.exports._parse = parse;
module.exports._enoent = enoent;
+/***/ }),
+
+/***/ 36:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const p_cancelable_1 = __webpack_require__(557);
+exports.CancelError = p_cancelable_1.CancelError;
+const core_1 = __webpack_require__(946);
+exports.RequestError =
+// Errors to be exported
+core_1.RequestError;
+exports.MaxRedirectsError = core_1.MaxRedirectsError;
+exports.CacheError = core_1.CacheError;
+exports.UploadError = core_1.UploadError;
+exports.TimeoutError = core_1.TimeoutError;
+exports.HTTPError = core_1.HTTPError;
+exports.ReadError = core_1.ReadError;
+exports.UnsupportedProtocolError = core_1.UnsupportedProtocolError;
+class ParseError extends core_1.RequestError {
+ constructor(error, response) {
+ const { options } = response.request;
+ super(`${error.message} in "${options.url.toString()}"`, error, response.request);
+ this.name = 'ParseError';
+ Object.defineProperty(this, 'response', {
+ enumerable: false,
+ value: response
+ });
+ }
+}
+exports.ParseError = ParseError;
+
+
/***/ }),
/***/ 39:
@@ -430,6 +497,43 @@ function factory(plugins) {
}
+/***/ }),
+
+/***/ 48:
+/***/ (function(__unusedmodule, exports) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+class WeakableMap {
+ constructor() {
+ this.weakMap = new WeakMap();
+ this.map = new Map();
+ }
+ set(key, value) {
+ if (typeof key === 'object') {
+ this.weakMap.set(key, value);
+ }
+ else {
+ this.map.set(key, value);
+ }
+ }
+ get(key) {
+ if (typeof key === 'object') {
+ return this.weakMap.get(key);
+ }
+ return this.map.get(key);
+ }
+ has(key) {
+ if (typeof key === 'object') {
+ return this.weakMap.has(key);
+ }
+ return this.map.has(key);
+ }
+}
+exports.default = WeakableMap;
+
+
/***/ }),
/***/ 49:
@@ -490,6 +594,423 @@ const windowsRelease = release => {
module.exports = windowsRelease;
+/***/ }),
+
+/***/ 53:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+// TODO: Use the `URL` global when targeting Node.js 10
+const URLParser = typeof URL === 'undefined' ? __webpack_require__(835).URL : URL;
+
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
+const DATA_URL_DEFAULT_MIME_TYPE = 'text/plain';
+const DATA_URL_DEFAULT_CHARSET = 'us-ascii';
+
+const testParameter = (name, filters) => {
+ return filters.some(filter => filter instanceof RegExp ? filter.test(name) : filter === name);
+};
+
+const normalizeDataURL = (urlString, {stripHash}) => {
+ const parts = urlString.match(/^data:(.*?),(.*?)(?:#(.*))?$/);
+
+ if (!parts) {
+ throw new Error(`Invalid URL: ${urlString}`);
+ }
+
+ const mediaType = parts[1].split(';');
+ const body = parts[2];
+ const hash = stripHash ? '' : parts[3];
+
+ let base64 = false;
+
+ if (mediaType[mediaType.length - 1] === 'base64') {
+ mediaType.pop();
+ base64 = true;
+ }
+
+ // Lowercase MIME type
+ const mimeType = (mediaType.shift() || '').toLowerCase();
+ const attributes = mediaType
+ .map(attribute => {
+ let [key, value = ''] = attribute.split('=').map(string => string.trim());
+
+ // Lowercase `charset`
+ if (key === 'charset') {
+ value = value.toLowerCase();
+
+ if (value === DATA_URL_DEFAULT_CHARSET) {
+ return '';
+ }
+ }
+
+ return `${key}${value ? `=${value}` : ''}`;
+ })
+ .filter(Boolean);
+
+ const normalizedMediaType = [
+ ...attributes
+ ];
+
+ if (base64) {
+ normalizedMediaType.push('base64');
+ }
+
+ if (normalizedMediaType.length !== 0 || (mimeType && mimeType !== DATA_URL_DEFAULT_MIME_TYPE)) {
+ normalizedMediaType.unshift(mimeType);
+ }
+
+ return `data:${normalizedMediaType.join(';')},${base64 ? body.trim() : body}${hash ? `#${hash}` : ''}`;
+};
+
+const normalizeUrl = (urlString, options) => {
+ options = {
+ defaultProtocol: 'http:',
+ normalizeProtocol: true,
+ forceHttp: false,
+ forceHttps: false,
+ stripAuthentication: true,
+ stripHash: false,
+ stripWWW: true,
+ removeQueryParameters: [/^utm_\w+/i],
+ removeTrailingSlash: true,
+ removeDirectoryIndex: false,
+ sortQueryParameters: true,
+ ...options
+ };
+
+ // TODO: Remove this at some point in the future
+ if (Reflect.has(options, 'normalizeHttps')) {
+ throw new Error('options.normalizeHttps is renamed to options.forceHttp');
+ }
+
+ if (Reflect.has(options, 'normalizeHttp')) {
+ throw new Error('options.normalizeHttp is renamed to options.forceHttps');
+ }
+
+ if (Reflect.has(options, 'stripFragment')) {
+ throw new Error('options.stripFragment is renamed to options.stripHash');
+ }
+
+ urlString = urlString.trim();
+
+ // Data URL
+ if (/^data:/i.test(urlString)) {
+ return normalizeDataURL(urlString, options);
+ }
+
+ const hasRelativeProtocol = urlString.startsWith('//');
+ const isRelativeUrl = !hasRelativeProtocol && /^\.*\//.test(urlString);
+
+ // Prepend protocol
+ if (!isRelativeUrl) {
+ urlString = urlString.replace(/^(?!(?:\w+:)?\/\/)|^\/\//, options.defaultProtocol);
+ }
+
+ const urlObj = new URLParser(urlString);
+
+ if (options.forceHttp && options.forceHttps) {
+ throw new Error('The `forceHttp` and `forceHttps` options cannot be used together');
+ }
+
+ if (options.forceHttp && urlObj.protocol === 'https:') {
+ urlObj.protocol = 'http:';
+ }
+
+ if (options.forceHttps && urlObj.protocol === 'http:') {
+ urlObj.protocol = 'https:';
+ }
+
+ // Remove auth
+ if (options.stripAuthentication) {
+ urlObj.username = '';
+ urlObj.password = '';
+ }
+
+ // Remove hash
+ if (options.stripHash) {
+ urlObj.hash = '';
+ }
+
+ // Remove duplicate slashes if not preceded by a protocol
+ if (urlObj.pathname) {
+ // TODO: Use the following instead when targeting Node.js 10
+ // `urlObj.pathname = urlObj.pathname.replace(/(? {
+ if (/^(?!\/)/g.test(p1)) {
+ return `${p1}/`;
+ }
+
+ return '/';
+ });
+ }
+
+ // Decode URI octets
+ if (urlObj.pathname) {
+ urlObj.pathname = decodeURI(urlObj.pathname);
+ }
+
+ // Remove directory index
+ if (options.removeDirectoryIndex === true) {
+ options.removeDirectoryIndex = [/^index\.[a-z]+$/];
+ }
+
+ if (Array.isArray(options.removeDirectoryIndex) && options.removeDirectoryIndex.length > 0) {
+ let pathComponents = urlObj.pathname.split('/');
+ const lastComponent = pathComponents[pathComponents.length - 1];
+
+ if (testParameter(lastComponent, options.removeDirectoryIndex)) {
+ pathComponents = pathComponents.slice(0, pathComponents.length - 1);
+ urlObj.pathname = pathComponents.slice(1).join('/') + '/';
+ }
+ }
+
+ if (urlObj.hostname) {
+ // Remove trailing dot
+ urlObj.hostname = urlObj.hostname.replace(/\.$/, '');
+
+ // Remove `www.`
+ if (options.stripWWW && /^www\.([a-z\-\d]{2,63})\.([a-z.]{2,5})$/.test(urlObj.hostname)) {
+ // Each label should be max 63 at length (min: 2).
+ // The extension should be max 5 at length (min: 2).
+ // Source: https://en.wikipedia.org/wiki/Hostname#Restrictions_on_valid_host_names
+ urlObj.hostname = urlObj.hostname.replace(/^www\./, '');
+ }
+ }
+
+ // Remove query unwanted parameters
+ if (Array.isArray(options.removeQueryParameters)) {
+ for (const key of [...urlObj.searchParams.keys()]) {
+ if (testParameter(key, options.removeQueryParameters)) {
+ urlObj.searchParams.delete(key);
+ }
+ }
+ }
+
+ // Sort query parameters
+ if (options.sortQueryParameters) {
+ urlObj.searchParams.sort();
+ }
+
+ if (options.removeTrailingSlash) {
+ urlObj.pathname = urlObj.pathname.replace(/\/$/, '');
+ }
+
+ // Take advantage of many of the Node `url` normalizations
+ urlString = urlObj.toString();
+
+ // Remove ending `/`
+ if ((options.removeTrailingSlash || urlObj.pathname === '/') && urlObj.hash === '') {
+ urlString = urlString.replace(/\/$/, '');
+ }
+
+ // Restore relative protocol, if applicable
+ if (hasRelativeProtocol && !options.normalizeProtocol) {
+ urlString = urlString.replace(/^http:\/\//, '//');
+ }
+
+ // Remove http/https
+ if (options.stripProtocol) {
+ urlString = urlString.replace(/^(?:https?:)?\/\//, '');
+ }
+
+ return urlString;
+};
+
+module.exports = normalizeUrl;
+// TODO: Remove this for the next major release
+module.exports.default = normalizeUrl;
+
+
+/***/ }),
+
+/***/ 77:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = __webpack_require__(835);
+const create_1 = __webpack_require__(903);
+const defaults = {
+ options: {
+ method: 'GET',
+ retry: {
+ limit: 2,
+ methods: [
+ 'GET',
+ 'PUT',
+ 'HEAD',
+ 'DELETE',
+ 'OPTIONS',
+ 'TRACE'
+ ],
+ statusCodes: [
+ 408,
+ 413,
+ 429,
+ 500,
+ 502,
+ 503,
+ 504,
+ 521,
+ 522,
+ 524
+ ],
+ errorCodes: [
+ 'ETIMEDOUT',
+ 'ECONNRESET',
+ 'EADDRINUSE',
+ 'ECONNREFUSED',
+ 'EPIPE',
+ 'ENOTFOUND',
+ 'ENETUNREACH',
+ 'EAI_AGAIN'
+ ],
+ maxRetryAfter: undefined,
+ calculateDelay: ({ computedValue }) => computedValue
+ },
+ timeout: {},
+ headers: {
+ 'user-agent': 'got (https://github.com/sindresorhus/got)'
+ },
+ hooks: {
+ init: [],
+ beforeRequest: [],
+ beforeRedirect: [],
+ beforeRetry: [],
+ beforeError: [],
+ afterResponse: []
+ },
+ cache: undefined,
+ dnsCache: undefined,
+ decompress: true,
+ throwHttpErrors: true,
+ followRedirect: true,
+ isStream: false,
+ responseType: 'text',
+ resolveBodyOnly: false,
+ maxRedirects: 10,
+ prefixUrl: '',
+ methodRewriting: true,
+ ignoreInvalidCookies: false,
+ context: {},
+ // TODO: Set this to `true` when Got 12 gets released
+ http2: false,
+ allowGetBody: false,
+ https: undefined,
+ pagination: {
+ transform: (response) => {
+ if (response.request.options.responseType === 'json') {
+ return response.body;
+ }
+ return JSON.parse(response.body);
+ },
+ paginate: response => {
+ if (!Reflect.has(response.headers, 'link')) {
+ return false;
+ }
+ const items = response.headers.link.split(',');
+ let next;
+ for (const item of items) {
+ const parsed = item.split(';');
+ if (parsed[1].includes('next')) {
+ next = parsed[0].trimStart().trim();
+ next = next.slice(1, -1);
+ break;
+ }
+ }
+ if (next) {
+ const options = {
+ url: new url_1.URL(next)
+ };
+ return options;
+ }
+ return false;
+ },
+ filter: () => true,
+ shouldContinue: () => true,
+ countLimit: Infinity,
+ requestLimit: 10000,
+ stackAllItems: true
+ },
+ parseJson: (text) => JSON.parse(text),
+ stringifyJson: (object) => JSON.stringify(object)
+ },
+ handlers: [create_1.defaultHandler],
+ mutableDefaults: false
+};
+const got = create_1.default(defaults);
+exports.default = got;
+// For CommonJS default export support
+module.exports = got;
+module.exports.default = got;
+__export(__webpack_require__(903));
+__export(__webpack_require__(952));
+
+
+/***/ }),
+
+/***/ 79:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+const pump = __webpack_require__(453);
+const bufferStream = __webpack_require__(625);
+
+class MaxBufferError extends Error {
+ constructor() {
+ super('maxBuffer exceeded');
+ this.name = 'MaxBufferError';
+ }
+}
+
+function getStream(inputStream, options) {
+ if (!inputStream) {
+ return Promise.reject(new Error('Expected a stream'));
+ }
+
+ options = Object.assign({maxBuffer: Infinity}, options);
+
+ const {maxBuffer} = options;
+
+ let stream;
+ return new Promise((resolve, reject) => {
+ const rejectPromise = error => {
+ if (error) { // A null check
+ error.bufferedData = stream.getBufferedValue();
+ }
+ reject(error);
+ };
+
+ stream = pump(inputStream, bufferStream(options), error => {
+ if (error) {
+ rejectPromise(error);
+ return;
+ }
+
+ resolve();
+ });
+
+ stream.on('data', () => {
+ if (stream.getBufferedLength() > maxBuffer) {
+ rejectPromise(new MaxBufferError());
+ }
+ });
+ }).then(() => stream.getBufferedValue());
+}
+
+module.exports = getStream;
+module.exports.buffer = (stream, options) => getStream(stream, Object.assign({}, options, {encoding: 'buffer'}));
+module.exports.array = (stream, options) => getStream(stream, Object.assign({}, options, {array: true}));
+module.exports.MaxBufferError = MaxBufferError;
+
+
/***/ }),
/***/ 87:
@@ -497,6 +1018,133 @@ module.exports = windowsRelease;
module.exports = require("os");
+/***/ }),
+
+/***/ 89:
+/***/ (function(module) {
+
+"use strict";
+
+
+// We define these manually to ensure they're always copied
+// even if they would move up the prototype chain
+// https://nodejs.org/api/http.html#http_class_http_incomingmessage
+const knownProperties = [
+ 'aborted',
+ 'complete',
+ 'headers',
+ 'httpVersion',
+ 'httpVersionMinor',
+ 'httpVersionMajor',
+ 'method',
+ 'rawHeaders',
+ 'rawTrailers',
+ 'setTimeout',
+ 'socket',
+ 'statusCode',
+ 'statusMessage',
+ 'trailers',
+ 'url'
+];
+
+module.exports = (fromStream, toStream) => {
+ if (toStream._readableState.autoDestroy) {
+ throw new Error('The second stream must have the `autoDestroy` option set to `false`');
+ }
+
+ const fromProperties = new Set(Object.keys(fromStream).concat(knownProperties));
+
+ const properties = {};
+
+ for (const property of fromProperties) {
+ // Don't overwrite existing properties.
+ if (property in toStream) {
+ continue;
+ }
+
+ properties[property] = {
+ get() {
+ const value = fromStream[property];
+ const isFunction = typeof value === 'function';
+
+ return isFunction ? value.bind(fromStream) : value;
+ },
+ set(value) {
+ fromStream[property] = value;
+ },
+ enumerable: true,
+ configurable: false
+ };
+ }
+
+ Object.defineProperties(toStream, properties);
+
+ fromStream.once('aborted', () => {
+ toStream.destroy();
+
+ toStream.emit('aborted');
+ });
+
+ fromStream.once('close', () => {
+ if (fromStream.complete) {
+ if (toStream.readable) {
+ toStream.once('end', () => {
+ toStream.emit('close');
+ });
+ } else {
+ toStream.emit('close');
+ }
+ } else {
+ toStream.emit('close');
+ }
+ });
+
+ return toStream;
+};
+
+
+/***/ }),
+
+/***/ 93:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+
+const Readable = __webpack_require__(413).Readable;
+const lowercaseKeys = __webpack_require__(474);
+
+class Response extends Readable {
+ constructor(statusCode, headers, body, url) {
+ if (typeof statusCode !== 'number') {
+ throw new TypeError('Argument `statusCode` should be a number');
+ }
+ if (typeof headers !== 'object') {
+ throw new TypeError('Argument `headers` should be an object');
+ }
+ if (!(body instanceof Buffer)) {
+ throw new TypeError('Argument `body` should be a buffer');
+ }
+ if (typeof url !== 'string') {
+ throw new TypeError('Argument `url` should be a string');
+ }
+
+ super();
+ this.statusCode = statusCode;
+ this.headers = lowercaseKeys(headers);
+ this.body = body;
+ this.url = url;
+ }
+
+ _read() {
+ this.push(this.body);
+ this.push(null);
+ }
+}
+
+module.exports = Response;
+
+
/***/ }),
/***/ 118:
@@ -1766,21 +2414,25 @@ class MaxBufferError extends Error {
}
}
-function getStream(inputStream, options) {
+async function getStream(inputStream, options) {
if (!inputStream) {
return Promise.reject(new Error('Expected a stream'));
}
- options = Object.assign({maxBuffer: Infinity}, options);
+ options = {
+ maxBuffer: Infinity,
+ ...options
+ };
const {maxBuffer} = options;
let stream;
- return new Promise((resolve, reject) => {
+ await new Promise((resolve, reject) => {
const rejectPromise = error => {
if (error) { // A null check
error.bufferedData = stream.getBufferedValue();
}
+
reject(error);
};
@@ -1798,12 +2450,16 @@ function getStream(inputStream, options) {
rejectPromise(new MaxBufferError());
}
});
- }).then(() => stream.getBufferedValue());
+ });
+
+ return stream.getBufferedValue();
}
module.exports = getStream;
-module.exports.buffer = (stream, options) => getStream(stream, Object.assign({}, options, {encoding: 'buffer'}));
-module.exports.array = (stream, options) => getStream(stream, Object.assign({}, options, {array: true}));
+// TODO: Remove this for the next major release
+module.exports.default = getStream;
+module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
+module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
module.exports.MaxBufferError = MaxBufferError;
@@ -1821,6 +2477,722 @@ function paginatePlugin(octokit) {
}
+/***/ }),
+
+/***/ 154:
+/***/ (function(module) {
+
+"use strict";
+
+// rfc7231 6.1
+const statusCodeCacheableByDefault = new Set([
+ 200,
+ 203,
+ 204,
+ 206,
+ 300,
+ 301,
+ 404,
+ 405,
+ 410,
+ 414,
+ 501,
+]);
+
+// This implementation does not understand partial responses (206)
+const understoodStatuses = new Set([
+ 200,
+ 203,
+ 204,
+ 300,
+ 301,
+ 302,
+ 303,
+ 307,
+ 308,
+ 404,
+ 405,
+ 410,
+ 414,
+ 501,
+]);
+
+const errorStatusCodes = new Set([
+ 500,
+ 502,
+ 503,
+ 504,
+]);
+
+const hopByHopHeaders = {
+ date: true, // included, because we add Age update Date
+ connection: true,
+ 'keep-alive': true,
+ 'proxy-authenticate': true,
+ 'proxy-authorization': true,
+ te: true,
+ trailer: true,
+ 'transfer-encoding': true,
+ upgrade: true,
+};
+
+const excludedFromRevalidationUpdate = {
+ // Since the old body is reused, it doesn't make sense to change properties of the body
+ 'content-length': true,
+ 'content-encoding': true,
+ 'transfer-encoding': true,
+ 'content-range': true,
+};
+
+function toNumberOrZero(s) {
+ const n = parseInt(s, 10);
+ return isFinite(n) ? n : 0;
+}
+
+// RFC 5861
+function isErrorResponse(response) {
+ // consider undefined response as faulty
+ if(!response) {
+ return true
+ }
+ return errorStatusCodes.has(response.status);
+}
+
+function parseCacheControl(header) {
+ const cc = {};
+ if (!header) return cc;
+
+ // TODO: When there is more than one value present for a given directive (e.g., two Expires header fields, multiple Cache-Control: max-age directives),
+ // the directive's value is considered invalid. Caches are encouraged to consider responses that have invalid freshness information to be stale
+ const parts = header.trim().split(/\s*,\s*/); // TODO: lame parsing
+ for (const part of parts) {
+ const [k, v] = part.split(/\s*=\s*/, 2);
+ cc[k] = v === undefined ? true : v.replace(/^"|"$/g, ''); // TODO: lame unquoting
+ }
+
+ return cc;
+}
+
+function formatCacheControl(cc) {
+ let parts = [];
+ for (const k in cc) {
+ const v = cc[k];
+ parts.push(v === true ? k : k + '=' + v);
+ }
+ if (!parts.length) {
+ return undefined;
+ }
+ return parts.join(', ');
+}
+
+module.exports = class CachePolicy {
+ constructor(
+ req,
+ res,
+ {
+ shared,
+ cacheHeuristic,
+ immutableMinTimeToLive,
+ ignoreCargoCult,
+ _fromObject,
+ } = {}
+ ) {
+ if (_fromObject) {
+ this._fromObject(_fromObject);
+ return;
+ }
+
+ if (!res || !res.headers) {
+ throw Error('Response headers missing');
+ }
+ this._assertRequestHasHeaders(req);
+
+ this._responseTime = this.now();
+ this._isShared = shared !== false;
+ this._cacheHeuristic =
+ undefined !== cacheHeuristic ? cacheHeuristic : 0.1; // 10% matches IE
+ this._immutableMinTtl =
+ undefined !== immutableMinTimeToLive
+ ? immutableMinTimeToLive
+ : 24 * 3600 * 1000;
+
+ this._status = 'status' in res ? res.status : 200;
+ this._resHeaders = res.headers;
+ this._rescc = parseCacheControl(res.headers['cache-control']);
+ this._method = 'method' in req ? req.method : 'GET';
+ this._url = req.url;
+ this._host = req.headers.host;
+ this._noAuthorization = !req.headers.authorization;
+ this._reqHeaders = res.headers.vary ? req.headers : null; // Don't keep all request headers if they won't be used
+ this._reqcc = parseCacheControl(req.headers['cache-control']);
+
+ // Assume that if someone uses legacy, non-standard uncecessary options they don't understand caching,
+ // so there's no point stricly adhering to the blindly copy&pasted directives.
+ if (
+ ignoreCargoCult &&
+ 'pre-check' in this._rescc &&
+ 'post-check' in this._rescc
+ ) {
+ delete this._rescc['pre-check'];
+ delete this._rescc['post-check'];
+ delete this._rescc['no-cache'];
+ delete this._rescc['no-store'];
+ delete this._rescc['must-revalidate'];
+ this._resHeaders = Object.assign({}, this._resHeaders, {
+ 'cache-control': formatCacheControl(this._rescc),
+ });
+ delete this._resHeaders.expires;
+ delete this._resHeaders.pragma;
+ }
+
+ // When the Cache-Control header field is not present in a request, caches MUST consider the no-cache request pragma-directive
+ // as having the same effect as if "Cache-Control: no-cache" were present (see Section 5.2.1).
+ if (
+ res.headers['cache-control'] == null &&
+ /no-cache/.test(res.headers.pragma)
+ ) {
+ this._rescc['no-cache'] = true;
+ }
+ }
+
+ now() {
+ return Date.now();
+ }
+
+ storable() {
+ // The "no-store" request directive indicates that a cache MUST NOT store any part of either this request or any response to it.
+ return !!(
+ !this._reqcc['no-store'] &&
+ // A cache MUST NOT store a response to any request, unless:
+ // The request method is understood by the cache and defined as being cacheable, and
+ ('GET' === this._method ||
+ 'HEAD' === this._method ||
+ ('POST' === this._method && this._hasExplicitExpiration())) &&
+ // the response status code is understood by the cache, and
+ understoodStatuses.has(this._status) &&
+ // the "no-store" cache directive does not appear in request or response header fields, and
+ !this._rescc['no-store'] &&
+ // the "private" response directive does not appear in the response, if the cache is shared, and
+ (!this._isShared || !this._rescc.private) &&
+ // the Authorization header field does not appear in the request, if the cache is shared,
+ (!this._isShared ||
+ this._noAuthorization ||
+ this._allowsStoringAuthenticated()) &&
+ // the response either:
+ // contains an Expires header field, or
+ (this._resHeaders.expires ||
+ // contains a max-age response directive, or
+ // contains a s-maxage response directive and the cache is shared, or
+ // contains a public response directive.
+ this._rescc['max-age'] ||
+ (this._isShared && this._rescc['s-maxage']) ||
+ this._rescc.public ||
+ // has a status code that is defined as cacheable by default
+ statusCodeCacheableByDefault.has(this._status))
+ );
+ }
+
+ _hasExplicitExpiration() {
+ // 4.2.1 Calculating Freshness Lifetime
+ return (
+ (this._isShared && this._rescc['s-maxage']) ||
+ this._rescc['max-age'] ||
+ this._resHeaders.expires
+ );
+ }
+
+ _assertRequestHasHeaders(req) {
+ if (!req || !req.headers) {
+ throw Error('Request headers missing');
+ }
+ }
+
+ satisfiesWithoutRevalidation(req) {
+ this._assertRequestHasHeaders(req);
+
+ // When presented with a request, a cache MUST NOT reuse a stored response, unless:
+ // the presented request does not contain the no-cache pragma (Section 5.4), nor the no-cache cache directive,
+ // unless the stored response is successfully validated (Section 4.3), and
+ const requestCC = parseCacheControl(req.headers['cache-control']);
+ if (requestCC['no-cache'] || /no-cache/.test(req.headers.pragma)) {
+ return false;
+ }
+
+ if (requestCC['max-age'] && this.age() > requestCC['max-age']) {
+ return false;
+ }
+
+ if (
+ requestCC['min-fresh'] &&
+ this.timeToLive() < 1000 * requestCC['min-fresh']
+ ) {
+ return false;
+ }
+
+ // the stored response is either:
+ // fresh, or allowed to be served stale
+ if (this.stale()) {
+ const allowsStale =
+ requestCC['max-stale'] &&
+ !this._rescc['must-revalidate'] &&
+ (true === requestCC['max-stale'] ||
+ requestCC['max-stale'] > this.age() - this.maxAge());
+ if (!allowsStale) {
+ return false;
+ }
+ }
+
+ return this._requestMatches(req, false);
+ }
+
+ _requestMatches(req, allowHeadMethod) {
+ // The presented effective request URI and that of the stored response match, and
+ return (
+ (!this._url || this._url === req.url) &&
+ this._host === req.headers.host &&
+ // the request method associated with the stored response allows it to be used for the presented request, and
+ (!req.method ||
+ this._method === req.method ||
+ (allowHeadMethod && 'HEAD' === req.method)) &&
+ // selecting header fields nominated by the stored response (if any) match those presented, and
+ this._varyMatches(req)
+ );
+ }
+
+ _allowsStoringAuthenticated() {
+ // following Cache-Control response directives (Section 5.2.2) have such an effect: must-revalidate, public, and s-maxage.
+ return (
+ this._rescc['must-revalidate'] ||
+ this._rescc.public ||
+ this._rescc['s-maxage']
+ );
+ }
+
+ _varyMatches(req) {
+ if (!this._resHeaders.vary) {
+ return true;
+ }
+
+ // A Vary header field-value of "*" always fails to match
+ if (this._resHeaders.vary === '*') {
+ return false;
+ }
+
+ const fields = this._resHeaders.vary
+ .trim()
+ .toLowerCase()
+ .split(/\s*,\s*/);
+ for (const name of fields) {
+ if (req.headers[name] !== this._reqHeaders[name]) return false;
+ }
+ return true;
+ }
+
+ _copyWithoutHopByHopHeaders(inHeaders) {
+ const headers = {};
+ for (const name in inHeaders) {
+ if (hopByHopHeaders[name]) continue;
+ headers[name] = inHeaders[name];
+ }
+ // 9.1. Connection
+ if (inHeaders.connection) {
+ const tokens = inHeaders.connection.trim().split(/\s*,\s*/);
+ for (const name of tokens) {
+ delete headers[name];
+ }
+ }
+ if (headers.warning) {
+ const warnings = headers.warning.split(/,/).filter(warning => {
+ return !/^\s*1[0-9][0-9]/.test(warning);
+ });
+ if (!warnings.length) {
+ delete headers.warning;
+ } else {
+ headers.warning = warnings.join(',').trim();
+ }
+ }
+ return headers;
+ }
+
+ responseHeaders() {
+ const headers = this._copyWithoutHopByHopHeaders(this._resHeaders);
+ const age = this.age();
+
+ // A cache SHOULD generate 113 warning if it heuristically chose a freshness
+ // lifetime greater than 24 hours and the response's age is greater than 24 hours.
+ if (
+ age > 3600 * 24 &&
+ !this._hasExplicitExpiration() &&
+ this.maxAge() > 3600 * 24
+ ) {
+ headers.warning =
+ (headers.warning ? `${headers.warning}, ` : '') +
+ '113 - "rfc7234 5.5.4"';
+ }
+ headers.age = `${Math.round(age)}`;
+ headers.date = new Date(this.now()).toUTCString();
+ return headers;
+ }
+
+ /**
+ * Value of the Date response header or current time if Date was invalid
+ * @return timestamp
+ */
+ date() {
+ const serverDate = Date.parse(this._resHeaders.date);
+ if (isFinite(serverDate)) {
+ return serverDate;
+ }
+ return this._responseTime;
+ }
+
+ /**
+ * Value of the Age header, in seconds, updated for the current time.
+ * May be fractional.
+ *
+ * @return Number
+ */
+ age() {
+ let age = this._ageValue();
+
+ const residentTime = (this.now() - this._responseTime) / 1000;
+ return age + residentTime;
+ }
+
+ _ageValue() {
+ return toNumberOrZero(this._resHeaders.age);
+ }
+
+ /**
+ * Value of applicable max-age (or heuristic equivalent) in seconds. This counts since response's `Date`.
+ *
+ * For an up-to-date value, see `timeToLive()`.
+ *
+ * @return Number
+ */
+ maxAge() {
+ if (!this.storable() || this._rescc['no-cache']) {
+ return 0;
+ }
+
+ // Shared responses with cookies are cacheable according to the RFC, but IMHO it'd be unwise to do so by default
+ // so this implementation requires explicit opt-in via public header
+ if (
+ this._isShared &&
+ (this._resHeaders['set-cookie'] &&
+ !this._rescc.public &&
+ !this._rescc.immutable)
+ ) {
+ return 0;
+ }
+
+ if (this._resHeaders.vary === '*') {
+ return 0;
+ }
+
+ if (this._isShared) {
+ if (this._rescc['proxy-revalidate']) {
+ return 0;
+ }
+ // if a response includes the s-maxage directive, a shared cache recipient MUST ignore the Expires field.
+ if (this._rescc['s-maxage']) {
+ return toNumberOrZero(this._rescc['s-maxage']);
+ }
+ }
+
+ // If a response includes a Cache-Control field with the max-age directive, a recipient MUST ignore the Expires field.
+ if (this._rescc['max-age']) {
+ return toNumberOrZero(this._rescc['max-age']);
+ }
+
+ const defaultMinTtl = this._rescc.immutable ? this._immutableMinTtl : 0;
+
+ const serverDate = this.date();
+ if (this._resHeaders.expires) {
+ const expires = Date.parse(this._resHeaders.expires);
+ // A cache recipient MUST interpret invalid date formats, especially the value "0", as representing a time in the past (i.e., "already expired").
+ if (Number.isNaN(expires) || expires < serverDate) {
+ return 0;
+ }
+ return Math.max(defaultMinTtl, (expires - serverDate) / 1000);
+ }
+
+ if (this._resHeaders['last-modified']) {
+ const lastModified = Date.parse(this._resHeaders['last-modified']);
+ if (isFinite(lastModified) && serverDate > lastModified) {
+ return Math.max(
+ defaultMinTtl,
+ ((serverDate - lastModified) / 1000) * this._cacheHeuristic
+ );
+ }
+ }
+
+ return defaultMinTtl;
+ }
+
+ timeToLive() {
+ const age = this.maxAge() - this.age();
+ const staleIfErrorAge = age + toNumberOrZero(this._rescc['stale-if-error']);
+ const staleWhileRevalidateAge = age + toNumberOrZero(this._rescc['stale-while-revalidate']);
+ return Math.max(0, age, staleIfErrorAge, staleWhileRevalidateAge) * 1000;
+ }
+
+ stale() {
+ return this.maxAge() <= this.age();
+ }
+
+ _useStaleIfError() {
+ return this.maxAge() + toNumberOrZero(this._rescc['stale-if-error']) > this.age();
+ }
+
+ useStaleWhileRevalidate() {
+ return this.maxAge() + toNumberOrZero(this._rescc['stale-while-revalidate']) > this.age();
+ }
+
+ static fromObject(obj) {
+ return new this(undefined, undefined, { _fromObject: obj });
+ }
+
+ _fromObject(obj) {
+ if (this._responseTime) throw Error('Reinitialized');
+ if (!obj || obj.v !== 1) throw Error('Invalid serialization');
+
+ this._responseTime = obj.t;
+ this._isShared = obj.sh;
+ this._cacheHeuristic = obj.ch;
+ this._immutableMinTtl =
+ obj.imm !== undefined ? obj.imm : 24 * 3600 * 1000;
+ this._status = obj.st;
+ this._resHeaders = obj.resh;
+ this._rescc = obj.rescc;
+ this._method = obj.m;
+ this._url = obj.u;
+ this._host = obj.h;
+ this._noAuthorization = obj.a;
+ this._reqHeaders = obj.reqh;
+ this._reqcc = obj.reqcc;
+ }
+
+ toObject() {
+ return {
+ v: 1,
+ t: this._responseTime,
+ sh: this._isShared,
+ ch: this._cacheHeuristic,
+ imm: this._immutableMinTtl,
+ st: this._status,
+ resh: this._resHeaders,
+ rescc: this._rescc,
+ m: this._method,
+ u: this._url,
+ h: this._host,
+ a: this._noAuthorization,
+ reqh: this._reqHeaders,
+ reqcc: this._reqcc,
+ };
+ }
+
+ /**
+ * Headers for sending to the origin server to revalidate stale response.
+ * Allows server to return 304 to allow reuse of the previous response.
+ *
+ * Hop by hop headers are always stripped.
+ * Revalidation headers may be added or removed, depending on request.
+ */
+ revalidationHeaders(incomingReq) {
+ this._assertRequestHasHeaders(incomingReq);
+ const headers = this._copyWithoutHopByHopHeaders(incomingReq.headers);
+
+ // This implementation does not understand range requests
+ delete headers['if-range'];
+
+ if (!this._requestMatches(incomingReq, true) || !this.storable()) {
+ // revalidation allowed via HEAD
+ // not for the same resource, or wasn't allowed to be cached anyway
+ delete headers['if-none-match'];
+ delete headers['if-modified-since'];
+ return headers;
+ }
+
+ /* MUST send that entity-tag in any cache validation request (using If-Match or If-None-Match) if an entity-tag has been provided by the origin server. */
+ if (this._resHeaders.etag) {
+ headers['if-none-match'] = headers['if-none-match']
+ ? `${headers['if-none-match']}, ${this._resHeaders.etag}`
+ : this._resHeaders.etag;
+ }
+
+ // Clients MAY issue simple (non-subrange) GET requests with either weak validators or strong validators. Clients MUST NOT use weak validators in other forms of request.
+ const forbidsWeakValidators =
+ headers['accept-ranges'] ||
+ headers['if-match'] ||
+ headers['if-unmodified-since'] ||
+ (this._method && this._method != 'GET');
+
+ /* SHOULD send the Last-Modified value in non-subrange cache validation requests (using If-Modified-Since) if only a Last-Modified value has been provided by the origin server.
+ Note: This implementation does not understand partial responses (206) */
+ if (forbidsWeakValidators) {
+ delete headers['if-modified-since'];
+
+ if (headers['if-none-match']) {
+ const etags = headers['if-none-match']
+ .split(/,/)
+ .filter(etag => {
+ return !/^\s*W\//.test(etag);
+ });
+ if (!etags.length) {
+ delete headers['if-none-match'];
+ } else {
+ headers['if-none-match'] = etags.join(',').trim();
+ }
+ }
+ } else if (
+ this._resHeaders['last-modified'] &&
+ !headers['if-modified-since']
+ ) {
+ headers['if-modified-since'] = this._resHeaders['last-modified'];
+ }
+
+ return headers;
+ }
+
+ /**
+ * Creates new CachePolicy with information combined from the previews response,
+ * and the new revalidation response.
+ *
+ * Returns {policy, modified} where modified is a boolean indicating
+ * whether the response body has been modified, and old cached body can't be used.
+ *
+ * @return {Object} {policy: CachePolicy, modified: Boolean}
+ */
+ revalidatedPolicy(request, response) {
+ this._assertRequestHasHeaders(request);
+ if(this._useStaleIfError() && isErrorResponse(response)) { // I consider the revalidation request unsuccessful
+ return {
+ modified: false,
+ matches: false,
+ policy: this,
+ };
+ }
+ if (!response || !response.headers) {
+ throw Error('Response headers missing');
+ }
+
+ // These aren't going to be supported exactly, since one CachePolicy object
+ // doesn't know about all the other cached objects.
+ let matches = false;
+ if (response.status !== undefined && response.status != 304) {
+ matches = false;
+ } else if (
+ response.headers.etag &&
+ !/^\s*W\//.test(response.headers.etag)
+ ) {
+ // "All of the stored responses with the same strong validator are selected.
+ // If none of the stored responses contain the same strong validator,
+ // then the cache MUST NOT use the new response to update any stored responses."
+ matches =
+ this._resHeaders.etag &&
+ this._resHeaders.etag.replace(/^\s*W\//, '') ===
+ response.headers.etag;
+ } else if (this._resHeaders.etag && response.headers.etag) {
+ // "If the new response contains a weak validator and that validator corresponds
+ // to one of the cache's stored responses,
+ // then the most recent of those matching stored responses is selected for update."
+ matches =
+ this._resHeaders.etag.replace(/^\s*W\//, '') ===
+ response.headers.etag.replace(/^\s*W\//, '');
+ } else if (this._resHeaders['last-modified']) {
+ matches =
+ this._resHeaders['last-modified'] ===
+ response.headers['last-modified'];
+ } else {
+ // If the new response does not include any form of validator (such as in the case where
+ // a client generates an If-Modified-Since request from a source other than the Last-Modified
+ // response header field), and there is only one stored response, and that stored response also
+ // lacks a validator, then that stored response is selected for update.
+ if (
+ !this._resHeaders.etag &&
+ !this._resHeaders['last-modified'] &&
+ !response.headers.etag &&
+ !response.headers['last-modified']
+ ) {
+ matches = true;
+ }
+ }
+
+ if (!matches) {
+ return {
+ policy: new this.constructor(request, response),
+ // Client receiving 304 without body, even if it's invalid/mismatched has no option
+ // but to reuse a cached body. We don't have a good way to tell clients to do
+ // error recovery in such case.
+ modified: response.status != 304,
+ matches: false,
+ };
+ }
+
+ // use other header fields provided in the 304 (Not Modified) response to replace all instances
+ // of the corresponding header fields in the stored response.
+ const headers = {};
+ for (const k in this._resHeaders) {
+ headers[k] =
+ k in response.headers && !excludedFromRevalidationUpdate[k]
+ ? response.headers[k]
+ : this._resHeaders[k];
+ }
+
+ const newResponse = Object.assign({}, response, {
+ status: this._status,
+ method: this._method,
+ headers,
+ });
+ return {
+ policy: new this.constructor(request, newResponse, {
+ shared: this._isShared,
+ cacheHeuristic: this._cacheHeuristic,
+ immutableMinTimeToLive: this._immutableMinTtl,
+ }),
+ modified: false,
+ matches: true,
+ };
+ }
+};
+
+
+/***/ }),
+
+/***/ 157:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+const http2 = __webpack_require__(565);
+const agent = __webpack_require__(899);
+const ClientRequest = __webpack_require__(181);
+const IncomingMessage = __webpack_require__(750);
+const auto = __webpack_require__(988);
+
+const request = (url, options, callback) => {
+ return new ClientRequest(url, options, callback);
+};
+
+const get = (url, options, callback) => {
+ const req = new ClientRequest(url, options, callback);
+ req.end();
+
+ return req;
+};
+
+module.exports = {
+ ...http2,
+ ClientRequest,
+ IncomingMessage,
+ ...agent,
+ request,
+ get,
+ auto
+};
+
+
/***/ }),
/***/ 168:
@@ -1870,6 +3242,447 @@ module.exports = opts => {
};
+/***/ }),
+
+/***/ 181:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+const http2 = __webpack_require__(565);
+const {Writable} = __webpack_require__(413);
+const {Agent, globalAgent} = __webpack_require__(899);
+const IncomingMessage = __webpack_require__(750);
+const urlToOptions = __webpack_require__(507);
+const proxyEvents = __webpack_require__(231);
+const isRequestPseudoHeader = __webpack_require__(723);
+const {
+ ERR_INVALID_ARG_TYPE,
+ ERR_INVALID_PROTOCOL,
+ ERR_HTTP_HEADERS_SENT,
+ ERR_INVALID_HTTP_TOKEN,
+ ERR_HTTP_INVALID_HEADER_VALUE,
+ ERR_INVALID_CHAR
+} = __webpack_require__(699);
+
+const {
+ HTTP2_HEADER_STATUS,
+ HTTP2_HEADER_METHOD,
+ HTTP2_HEADER_PATH,
+ HTTP2_METHOD_CONNECT
+} = http2.constants;
+
+const kHeaders = Symbol('headers');
+const kOrigin = Symbol('origin');
+const kSession = Symbol('session');
+const kOptions = Symbol('options');
+const kFlushedHeaders = Symbol('flushedHeaders');
+const kJobs = Symbol('jobs');
+
+const isValidHttpToken = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
+const isInvalidHeaderValue = /[^\t\u0020-\u007E\u0080-\u00FF]/;
+
+class ClientRequest extends Writable {
+ constructor(input, options, callback) {
+ super({
+ autoDestroy: false
+ });
+
+ const hasInput = typeof input === 'string' || input instanceof URL;
+ if (hasInput) {
+ input = urlToOptions(input instanceof URL ? input : new URL(input));
+ }
+
+ if (typeof options === 'function' || options === undefined) {
+ // (options, callback)
+ callback = options;
+ options = hasInput ? input : {...input};
+ } else {
+ // (input, options, callback)
+ options = {...input, ...options};
+ }
+
+ if (options.h2session) {
+ this[kSession] = options.h2session;
+ } else if (options.agent === false) {
+ this.agent = new Agent({maxFreeSessions: 0});
+ } else if (typeof options.agent === 'undefined' || options.agent === null) {
+ if (typeof options.createConnection === 'function') {
+ // This is a workaround - we don't have to create the session on our own.
+ this.agent = new Agent({maxFreeSessions: 0});
+ this.agent.createConnection = options.createConnection;
+ } else {
+ this.agent = globalAgent;
+ }
+ } else if (typeof options.agent.request === 'function') {
+ this.agent = options.agent;
+ } else {
+ throw new ERR_INVALID_ARG_TYPE('options.agent', ['Agent-like Object', 'undefined', 'false'], options.agent);
+ }
+
+ if (!options.port) {
+ options.port = options.defaultPort || (this.agent && this.agent.defaultPort) || 443;
+ }
+
+ options.host = options.hostname || options.host || 'localhost';
+
+ if (options.protocol && options.protocol !== 'https:') {
+ throw new ERR_INVALID_PROTOCOL(options.protocol, 'https:');
+ }
+
+ const {timeout} = options;
+ options.timeout = undefined;
+
+ this[kHeaders] = Object.create(null);
+ this[kJobs] = [];
+
+ this.socket = null;
+ this.connection = null;
+
+ this.method = options.method;
+ this.path = options.path;
+
+ this.res = null;
+ this.aborted = false;
+ this.reusedSocket = false;
+
+ if (options.headers) {
+ for (const [header, value] of Object.entries(options.headers)) {
+ this.setHeader(header, value);
+ }
+ }
+
+ if (options.auth && !('authorization' in this[kHeaders])) {
+ this[kHeaders].authorization = 'Basic ' + Buffer.from(options.auth).toString('base64');
+ }
+
+ options.session = options.tlsSession;
+ options.path = options.socketPath;
+
+ this[kOptions] = options;
+
+ // Clients that generate HTTP/2 requests directly SHOULD use the :authority pseudo-header field instead of the Host header field.
+ // What about IPv6? Square brackets?
+ if (options.port === 443) {
+ options.origin = `https://${options.host}`;
+
+ if (!(':authority' in this[kHeaders])) {
+ this[kHeaders][':authority'] = options.host;
+ }
+ } else {
+ options.origin = `https://${options.host}:${options.port}`;
+
+ if (!(':authority' in this[kHeaders])) {
+ this[kHeaders][':authority'] = `${options.host}:${options.port}`;
+ }
+ }
+
+ this[kOrigin] = options;
+
+ if (timeout) {
+ this.setTimeout(timeout);
+ }
+
+ if (callback) {
+ this.once('response', callback);
+ }
+
+ this[kFlushedHeaders] = false;
+ }
+
+ get method() {
+ return this[kHeaders][HTTP2_HEADER_METHOD];
+ }
+
+ set method(value) {
+ if (value) {
+ this[kHeaders][HTTP2_HEADER_METHOD] = value.toUpperCase();
+ }
+ }
+
+ get path() {
+ return this[kHeaders][HTTP2_HEADER_PATH];
+ }
+
+ set path(value) {
+ if (value) {
+ this[kHeaders][HTTP2_HEADER_PATH] = value;
+ }
+ }
+
+ _write(chunk, encoding, callback) {
+ this.flushHeaders();
+
+ const callWrite = () => this._request.write(chunk, encoding, callback);
+ if (this._request) {
+ callWrite();
+ } else {
+ this[kJobs].push(callWrite);
+ }
+ }
+
+ _final(callback) {
+ if (this.destroyed) {
+ return;
+ }
+
+ this.flushHeaders();
+
+ const callEnd = () => this._request.end(callback);
+ if (this._request) {
+ callEnd();
+ } else {
+ this[kJobs].push(callEnd);
+ }
+ }
+
+ abort() {
+ if (this.res && this.res.complete) {
+ return;
+ }
+
+ if (!this.aborted) {
+ process.nextTick(() => this.emit('abort'));
+ }
+
+ this.aborted = true;
+
+ this.destroy();
+ }
+
+ _destroy(error, callback) {
+ if (this.res) {
+ this.res._dump();
+ }
+
+ if (this._request) {
+ this._request.destroy();
+ }
+
+ callback(error);
+ }
+
+ async flushHeaders() {
+ if (this[kFlushedHeaders] || this.destroyed) {
+ return;
+ }
+
+ this[kFlushedHeaders] = true;
+
+ const isConnectMethod = this.method === HTTP2_METHOD_CONNECT;
+
+ // The real magic is here
+ const onStream = stream => {
+ this._request = stream;
+
+ if (this.destroyed) {
+ stream.destroy();
+ return;
+ }
+
+ // Forwards `timeout`, `continue`, `close` and `error` events to this instance.
+ if (!isConnectMethod) {
+ proxyEvents(stream, this, ['timeout', 'continue', 'close', 'error']);
+ }
+
+ // This event tells we are ready to listen for the data.
+ stream.once('response', (headers, flags, rawHeaders) => {
+ // If we were to emit raw request stream, it would be as fast as the native approach.
+ // Note that wrapping the raw stream in a Proxy instance won't improve the performance (already tested it).
+ const response = new IncomingMessage(this.socket, stream.readableHighWaterMark);
+ this.res = response;
+
+ response.req = this;
+ response.statusCode = headers[HTTP2_HEADER_STATUS];
+ response.headers = headers;
+ response.rawHeaders = rawHeaders;
+
+ response.once('end', () => {
+ if (this.aborted) {
+ response.aborted = true;
+ response.emit('aborted');
+ } else {
+ response.complete = true;
+
+ // Has no effect, just be consistent with the Node.js behavior
+ response.socket = null;
+ response.connection = null;
+ }
+ });
+
+ if (isConnectMethod) {
+ response.upgrade = true;
+
+ // The HTTP1 API says the socket is detached here,
+ // but we can't do that so we pass the original HTTP2 request.
+ if (this.emit('connect', response, stream, Buffer.alloc(0))) {
+ this.emit('close');
+ } else {
+ // No listeners attached, destroy the original request.
+ stream.destroy();
+ }
+ } else {
+ // Forwards data
+ stream.on('data', chunk => {
+ if (!response._dumped && !response.push(chunk)) {
+ stream.pause();
+ }
+ });
+
+ stream.once('end', () => {
+ response.push(null);
+ });
+
+ if (!this.emit('response', response)) {
+ // No listeners attached, dump the response.
+ response._dump();
+ }
+ }
+ });
+
+ // Emits `information` event
+ stream.once('headers', headers => this.emit('information', {statusCode: headers[HTTP2_HEADER_STATUS]}));
+
+ stream.once('trailers', (trailers, flags, rawTrailers) => {
+ const {res} = this;
+
+ // Assigns trailers to the response object.
+ res.trailers = trailers;
+ res.rawTrailers = rawTrailers;
+ });
+
+ const {socket} = stream.session;
+ this.socket = socket;
+ this.connection = socket;
+
+ for (const job of this[kJobs]) {
+ job();
+ }
+
+ this.emit('socket', this.socket);
+ };
+
+ // Makes a HTTP2 request
+ if (this[kSession]) {
+ try {
+ onStream(this[kSession].request(this[kHeaders], {
+ endStream: false
+ }));
+ } catch (error) {
+ this.emit('error', error);
+ }
+ } else {
+ this.reusedSocket = true;
+
+ try {
+ onStream(await this.agent.request(this[kOrigin], this[kOptions], this[kHeaders]));
+ } catch (error) {
+ this.emit('error', error);
+ }
+ }
+ }
+
+ getHeader(name) {
+ if (typeof name !== 'string') {
+ throw new ERR_INVALID_ARG_TYPE('name', 'string', name);
+ }
+
+ return this[kHeaders][name.toLowerCase()];
+ }
+
+ get headersSent() {
+ return this[kFlushedHeaders];
+ }
+
+ removeHeader(name) {
+ if (typeof name !== 'string') {
+ throw new ERR_INVALID_ARG_TYPE('name', 'string', name);
+ }
+
+ if (this.headersSent) {
+ throw new ERR_HTTP_HEADERS_SENT('remove');
+ }
+
+ delete this[kHeaders][name.toLowerCase()];
+ }
+
+ setHeader(name, value) {
+ if (this.headersSent) {
+ throw new ERR_HTTP_HEADERS_SENT('set');
+ }
+
+ if (typeof name !== 'string' || (!isValidHttpToken.test(name) && !isRequestPseudoHeader(name))) {
+ throw new ERR_INVALID_HTTP_TOKEN('Header name', name);
+ }
+
+ if (typeof value === 'undefined') {
+ throw new ERR_HTTP_INVALID_HEADER_VALUE(value, name);
+ }
+
+ if (isInvalidHeaderValue.test(value)) {
+ throw new ERR_INVALID_CHAR('header content', name);
+ }
+
+ this[kHeaders][name.toLowerCase()] = value;
+ }
+
+ setNoDelay() {
+ // HTTP2 sockets cannot be malformed, do nothing.
+ }
+
+ setSocketKeepAlive() {
+ // HTTP2 sockets cannot be malformed, do nothing.
+ }
+
+ setTimeout(ms, callback) {
+ const applyTimeout = () => this._request.setTimeout(ms, callback);
+
+ if (this._request) {
+ applyTimeout();
+ } else {
+ this[kJobs].push(applyTimeout);
+ }
+
+ return this;
+ }
+
+ get maxHeadersCount() {
+ if (!this.destroyed && this._request) {
+ return this._request.session.localSettings.maxHeaderListSize;
+ }
+
+ return undefined;
+ }
+
+ set maxHeadersCount(_value) {
+ // Updating HTTP2 settings would affect all requests, do nothing.
+ }
+}
+
+module.exports = ClientRequest;
+
+
+/***/ }),
+
+/***/ 189:
+/***/ (function(__unusedmodule, exports) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const alreadyWarned = new Set();
+exports.default = (message) => {
+ if (alreadyWarned.has(message)) {
+ return;
+ }
+ alreadyWarned.add(message);
+ // @ts-ignore Missing types.
+ process.emitWarning(`Got: ${message}`, {
+ type: 'DeprecationWarning'
+ });
+};
+
+
/***/ }),
/***/ 190:
@@ -2001,6 +3814,111 @@ function checkMode (stat, options) {
}
+/***/ }),
+
+/***/ 205:
+/***/ (function(__unusedmodule, exports) {
+
+//TODO: handle reviver/dehydrate function like normal
+//and handle indentation, like normal.
+//if anyone needs this... please send pull request.
+
+exports.stringify = function stringify (o) {
+ if('undefined' == typeof o) return o
+
+ if(o && Buffer.isBuffer(o))
+ return JSON.stringify(':base64:' + o.toString('base64'))
+
+ if(o && o.toJSON)
+ o = o.toJSON()
+
+ if(o && 'object' === typeof o) {
+ var s = ''
+ var array = Array.isArray(o)
+ s = array ? '[' : '{'
+ var first = true
+
+ for(var k in o) {
+ var ignore = 'function' == typeof o[k] || (!array && 'undefined' === typeof o[k])
+ if(Object.hasOwnProperty.call(o, k) && !ignore) {
+ if(!first)
+ s += ','
+ first = false
+ if (array) {
+ if(o[k] == undefined)
+ s += 'null'
+ else
+ s += stringify(o[k])
+ } else if (o[k] !== void(0)) {
+ s += stringify(k) + ':' + stringify(o[k])
+ }
+ }
+ }
+
+ s += array ? ']' : '}'
+
+ return s
+ } else if ('string' === typeof o) {
+ return JSON.stringify(/^:/.test(o) ? ':' + o : o)
+ } else if ('undefined' === typeof o) {
+ return 'null';
+ } else
+ return JSON.stringify(o)
+}
+
+exports.parse = function (s) {
+ return JSON.parse(s, function (key, value) {
+ if('string' === typeof value) {
+ if(/^:base64:/.test(value))
+ return Buffer.from(value.substring(8), 'base64')
+ else
+ return /^:/.test(value) ? value.substring(1) : value
+ }
+ return value
+ })
+}
+
+
+/***/ }),
+
+/***/ 210:
+/***/ (function(module) {
+
+"use strict";
+
+
+// We define these manually to ensure they're always copied
+// even if they would move up the prototype chain
+// https://nodejs.org/api/http.html#http_class_http_incomingmessage
+const knownProps = [
+ 'destroy',
+ 'setTimeout',
+ 'socket',
+ 'headers',
+ 'trailers',
+ 'rawHeaders',
+ 'statusCode',
+ 'httpVersion',
+ 'httpVersionMinor',
+ 'httpVersionMajor',
+ 'rawTrailers',
+ 'statusMessage'
+];
+
+module.exports = (fromStream, toStream) => {
+ const fromProps = new Set(Object.keys(fromStream).concat(knownProps));
+
+ for (const prop of fromProps) {
+ // Don't overwrite existing properties
+ if (prop in toStream) {
+ continue;
+ }
+
+ toStream[prop] = typeof fromStream[prop] === 'function' ? fromStream[prop].bind(fromStream) : fromStream[prop];
+ }
+};
+
+
/***/ }),
/***/ 211:
@@ -2015,6 +3933,21 @@ module.exports = require("https");
module.exports = {"name":"@octokit/rest","version":"16.43.1","publishConfig":{"access":"public"},"description":"GitHub REST API client for Node.js","keywords":["octokit","github","rest","api-client"],"author":"Gregor Martynus (https://github.com/gr2m)","contributors":[{"name":"Mike de Boer","email":"info@mikedeboer.nl"},{"name":"Fabian Jakobs","email":"fabian@c9.io"},{"name":"Joe Gallo","email":"joe@brassafrax.com"},{"name":"Gregor Martynus","url":"https://github.com/gr2m"}],"repository":"https://github.com/octokit/rest.js","dependencies":{"@octokit/auth-token":"^2.4.0","@octokit/plugin-paginate-rest":"^1.1.1","@octokit/plugin-request-log":"^1.0.0","@octokit/plugin-rest-endpoint-methods":"2.4.0","@octokit/request":"^5.2.0","@octokit/request-error":"^1.0.2","atob-lite":"^2.0.0","before-after-hook":"^2.0.0","btoa-lite":"^1.0.0","deprecation":"^2.0.0","lodash.get":"^4.4.2","lodash.set":"^4.3.2","lodash.uniq":"^4.5.0","octokit-pagination-methods":"^1.1.0","once":"^1.4.0","universal-user-agent":"^4.0.0"},"devDependencies":{"@gimenete/type-writer":"^0.1.3","@octokit/auth":"^1.1.1","@octokit/fixtures-server":"^5.0.6","@octokit/graphql":"^4.2.0","@types/node":"^13.1.0","bundlesize":"^0.18.0","chai":"^4.1.2","compression-webpack-plugin":"^3.1.0","cypress":"^3.0.0","glob":"^7.1.2","http-proxy-agent":"^4.0.0","lodash.camelcase":"^4.3.0","lodash.merge":"^4.6.1","lodash.upperfirst":"^4.3.1","lolex":"^5.1.2","mkdirp":"^1.0.0","mocha":"^7.0.1","mustache":"^4.0.0","nock":"^11.3.3","npm-run-all":"^4.1.2","nyc":"^15.0.0","prettier":"^1.14.2","proxy":"^1.0.0","semantic-release":"^17.0.0","sinon":"^8.0.0","sinon-chai":"^3.0.0","sort-keys":"^4.0.0","string-to-arraybuffer":"^1.0.0","string-to-jsdoc-comment":"^1.0.0","typescript":"^3.3.1","webpack":"^4.0.0","webpack-bundle-analyzer":"^3.0.0","webpack-cli":"^3.0.0"},"types":"index.d.ts","scripts":{"coverage":"nyc report --reporter=html && open coverage/index.html","lint":"prettier --check '{lib,plugins,scripts,test}/**/*.{js,json,ts}' 'docs/*.{js,json}' 'docs/src/**/*' index.js README.md package.json","lint:fix":"prettier --write '{lib,plugins,scripts,test}/**/*.{js,json,ts}' 'docs/*.{js,json}' 'docs/src/**/*' index.js README.md package.json","pretest":"npm run -s lint","test":"nyc mocha test/mocha-node-setup.js \"test/*/**/*-test.js\"","test:browser":"cypress run --browser chrome","build":"npm-run-all build:*","build:ts":"npm run -s update-endpoints:typescript","prebuild:browser":"mkdirp dist/","build:browser":"npm-run-all build:browser:*","build:browser:development":"webpack --mode development --entry . --output-library=Octokit --output=./dist/octokit-rest.js --profile --json > dist/bundle-stats.json","build:browser:production":"webpack --mode production --entry . --plugin=compression-webpack-plugin --output-library=Octokit --output-path=./dist --output-filename=octokit-rest.min.js --devtool source-map","generate-bundle-report":"webpack-bundle-analyzer dist/bundle-stats.json --mode=static --no-open --report dist/bundle-report.html","update-endpoints":"npm-run-all update-endpoints:*","update-endpoints:fetch-json":"node scripts/update-endpoints/fetch-json","update-endpoints:typescript":"node scripts/update-endpoints/typescript","prevalidate:ts":"npm run -s build:ts","validate:ts":"tsc --target es6 --noImplicitAny index.d.ts","postvalidate:ts":"tsc --noEmit --target es6 test/typescript-validate.ts","start-fixtures-server":"octokit-fixtures-server"},"license":"MIT","files":["index.js","index.d.ts","lib","plugins"],"nyc":{"ignore":["test"]},"release":{"publish":["@semantic-release/npm",{"path":"@semantic-release/github","assets":["dist/*","!dist/*.map.gz"]}]},"bundlesize":[{"path":"./dist/octokit-rest.min.js.gz","maxSize":"33 kB"}]};
+/***/ }),
+
+/***/ 231:
+/***/ (function(module) {
+
+"use strict";
+
+
+module.exports = (from, to, events) => {
+ for (const event of events) {
+ from.on(event, (...args) => to.emit(event, ...args));
+ }
+};
+
+
/***/ }),
/***/ 257:
@@ -3836,6 +5769,157 @@ function coerce (version) {
}
+/***/ }),
+
+/***/ 290:
+/***/ (function(module) {
+
+"use strict";
+
+
+class QuickLRU {
+ constructor(options = {}) {
+ if (!(options.maxSize && options.maxSize > 0)) {
+ throw new TypeError('`maxSize` must be a number greater than 0');
+ }
+
+ this.maxSize = options.maxSize;
+ this.onEviction = options.onEviction;
+ this.cache = new Map();
+ this.oldCache = new Map();
+ this._size = 0;
+ }
+
+ _set(key, value) {
+ this.cache.set(key, value);
+ this._size++;
+
+ if (this._size >= this.maxSize) {
+ this._size = 0;
+
+ if (typeof this.onEviction === 'function') {
+ for (const [key, value] of this.oldCache.entries()) {
+ this.onEviction(key, value);
+ }
+ }
+
+ this.oldCache = this.cache;
+ this.cache = new Map();
+ }
+ }
+
+ get(key) {
+ if (this.cache.has(key)) {
+ return this.cache.get(key);
+ }
+
+ if (this.oldCache.has(key)) {
+ const value = this.oldCache.get(key);
+ this.oldCache.delete(key);
+ this._set(key, value);
+ return value;
+ }
+ }
+
+ set(key, value) {
+ if (this.cache.has(key)) {
+ this.cache.set(key, value);
+ } else {
+ this._set(key, value);
+ }
+
+ return this;
+ }
+
+ has(key) {
+ return this.cache.has(key) || this.oldCache.has(key);
+ }
+
+ peek(key) {
+ if (this.cache.has(key)) {
+ return this.cache.get(key);
+ }
+
+ if (this.oldCache.has(key)) {
+ return this.oldCache.get(key);
+ }
+ }
+
+ delete(key) {
+ const deleted = this.cache.delete(key);
+ if (deleted) {
+ this._size--;
+ }
+
+ return this.oldCache.delete(key) || deleted;
+ }
+
+ clear() {
+ this.cache.clear();
+ this.oldCache.clear();
+ this._size = 0;
+ }
+
+ * keys() {
+ for (const [key] of this) {
+ yield key;
+ }
+ }
+
+ * values() {
+ for (const [, value] of this) {
+ yield value;
+ }
+ }
+
+ * [Symbol.iterator]() {
+ for (const item of this.cache) {
+ yield item;
+ }
+
+ for (const item of this.oldCache) {
+ const [key] = item;
+ if (!this.cache.has(key)) {
+ yield item;
+ }
+ }
+ }
+
+ get size() {
+ let oldCacheSize = 0;
+ for (const key of this.oldCache.keys()) {
+ if (!this.cache.has(key)) {
+ oldCacheSize++;
+ }
+ }
+
+ return Math.min(this._size + oldCacheSize, this.maxSize);
+ }
+}
+
+module.exports = QuickLRU;
+
+
+/***/ }),
+
+/***/ 291:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = __webpack_require__(534);
+function deepFreeze(object) {
+ for (const value of Object.values(object)) {
+ if (is_1.default.plainObject(value) || is_1.default.array(value)) {
+ deepFreeze(value);
+ }
+ }
+ return Object.freeze(object);
+}
+exports.default = deepFreeze;
+
+
/***/ }),
/***/ 293:
@@ -4172,6 +6256,125 @@ exports.paginateRest = paginateRest;
//# sourceMappingURL=index.js.map
+/***/ }),
+
+/***/ 303:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+
+const EventEmitter = __webpack_require__(614);
+const JSONB = __webpack_require__(205);
+
+const loadStore = opts => {
+ const adapters = {
+ redis: '@keyv/redis',
+ mongodb: '@keyv/mongo',
+ mongo: '@keyv/mongo',
+ sqlite: '@keyv/sqlite',
+ postgresql: '@keyv/postgres',
+ postgres: '@keyv/postgres',
+ mysql: '@keyv/mysql'
+ };
+ if (opts.adapter || opts.uri) {
+ const adapter = opts.adapter || /^[^:]*/.exec(opts.uri)[0];
+ return new (require(adapters[adapter]))(opts);
+ }
+
+ return new Map();
+};
+
+class Keyv extends EventEmitter {
+ constructor(uri, opts) {
+ super();
+ this.opts = Object.assign(
+ {
+ namespace: 'keyv',
+ serialize: JSONB.stringify,
+ deserialize: JSONB.parse
+ },
+ (typeof uri === 'string') ? { uri } : uri,
+ opts
+ );
+
+ if (!this.opts.store) {
+ const adapterOpts = Object.assign({}, this.opts);
+ this.opts.store = loadStore(adapterOpts);
+ }
+
+ if (typeof this.opts.store.on === 'function') {
+ this.opts.store.on('error', err => this.emit('error', err));
+ }
+
+ this.opts.store.namespace = this.opts.namespace;
+ }
+
+ _getKeyPrefix(key) {
+ return `${this.opts.namespace}:${key}`;
+ }
+
+ get(key, opts) {
+ const keyPrefixed = this._getKeyPrefix(key);
+ const { store } = this.opts;
+ return Promise.resolve()
+ .then(() => store.get(keyPrefixed))
+ .then(data => {
+ return (typeof data === 'string') ? this.opts.deserialize(data) : data;
+ })
+ .then(data => {
+ if (data === undefined) {
+ return undefined;
+ }
+
+ if (typeof data.expires === 'number' && Date.now() > data.expires) {
+ this.delete(key);
+ return undefined;
+ }
+
+ return (opts && opts.raw) ? data : data.value;
+ });
+ }
+
+ set(key, value, ttl) {
+ const keyPrefixed = this._getKeyPrefix(key);
+ if (typeof ttl === 'undefined') {
+ ttl = this.opts.ttl;
+ }
+
+ if (ttl === 0) {
+ ttl = undefined;
+ }
+
+ const { store } = this.opts;
+
+ return Promise.resolve()
+ .then(() => {
+ const expires = (typeof ttl === 'number') ? (Date.now() + ttl) : null;
+ value = { value, expires };
+ return this.opts.serialize(value);
+ })
+ .then(value => store.set(keyPrefixed, value, ttl))
+ .then(() => true);
+ }
+
+ delete(key) {
+ const keyPrefixed = this._getKeyPrefix(key);
+ const { store } = this.opts;
+ return Promise.resolve()
+ .then(() => store.delete(keyPrefixed));
+ }
+
+ clear() {
+ const { store } = this.opts;
+ return Promise.resolve()
+ .then(() => store.clear());
+ }
+}
+
+module.exports = Keyv;
+
+
/***/ }),
/***/ 323:
@@ -4201,6 +6404,31 @@ isStream.transform = function (stream) {
};
+/***/ }),
+
+/***/ 325:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+
+const PassThrough = __webpack_require__(413).PassThrough;
+const mimicResponse = __webpack_require__(210);
+
+const cloneResponse = response => {
+ if (!(response && response.pipe)) {
+ throw new TypeError('Parameter `response` must be a response stream.');
+ }
+
+ const clone = new PassThrough();
+ mimicResponse(response, clone);
+
+ return response.pipe(clone);
+};
+
+module.exports = cloneResponse;
+
+
/***/ }),
/***/ 336:
@@ -4936,6 +7164,265 @@ function readShebang(command) {
module.exports = readShebang;
+/***/ }),
+
+/***/ 390:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+
+const EventEmitter = __webpack_require__(614);
+const urlLib = __webpack_require__(835);
+const normalizeUrl = __webpack_require__(53);
+const getStream = __webpack_require__(145);
+const CachePolicy = __webpack_require__(154);
+const Response = __webpack_require__(93);
+const lowercaseKeys = __webpack_require__(474);
+const cloneResponse = __webpack_require__(325);
+const Keyv = __webpack_require__(303);
+
+class CacheableRequest {
+ constructor(request, cacheAdapter) {
+ if (typeof request !== 'function') {
+ throw new TypeError('Parameter `request` must be a function');
+ }
+
+ this.cache = new Keyv({
+ uri: typeof cacheAdapter === 'string' && cacheAdapter,
+ store: typeof cacheAdapter !== 'string' && cacheAdapter,
+ namespace: 'cacheable-request'
+ });
+
+ return this.createCacheableRequest(request);
+ }
+
+ createCacheableRequest(request) {
+ return (opts, cb) => {
+ let url;
+ if (typeof opts === 'string') {
+ url = normalizeUrlObject(urlLib.parse(opts));
+ opts = {};
+ } else if (opts instanceof urlLib.URL) {
+ url = normalizeUrlObject(urlLib.parse(opts.toString()));
+ opts = {};
+ } else {
+ const [pathname, ...searchParts] = (opts.path || '').split('?');
+ const search = searchParts.length > 0 ?
+ `?${searchParts.join('?')}` :
+ '';
+ url = normalizeUrlObject({ ...opts, pathname, search });
+ }
+
+ opts = {
+ headers: {},
+ method: 'GET',
+ cache: true,
+ strictTtl: false,
+ automaticFailover: false,
+ ...opts,
+ ...urlObjectToRequestOptions(url)
+ };
+ opts.headers = lowercaseKeys(opts.headers);
+
+ const ee = new EventEmitter();
+ const normalizedUrlString = normalizeUrl(
+ urlLib.format(url),
+ {
+ stripWWW: false,
+ removeTrailingSlash: false,
+ stripAuthentication: false
+ }
+ );
+ const key = `${opts.method}:${normalizedUrlString}`;
+ let revalidate = false;
+ let madeRequest = false;
+
+ const makeRequest = opts => {
+ madeRequest = true;
+ let requestErrored = false;
+ let requestErrorCallback;
+
+ const requestErrorPromise = new Promise(resolve => {
+ requestErrorCallback = () => {
+ if (!requestErrored) {
+ requestErrored = true;
+ resolve();
+ }
+ };
+ });
+
+ const handler = response => {
+ if (revalidate && !opts.forceRefresh) {
+ response.status = response.statusCode;
+ const revalidatedPolicy = CachePolicy.fromObject(revalidate.cachePolicy).revalidatedPolicy(opts, response);
+ if (!revalidatedPolicy.modified) {
+ const headers = revalidatedPolicy.policy.responseHeaders();
+ response = new Response(revalidate.statusCode, headers, revalidate.body, revalidate.url);
+ response.cachePolicy = revalidatedPolicy.policy;
+ response.fromCache = true;
+ }
+ }
+
+ if (!response.fromCache) {
+ response.cachePolicy = new CachePolicy(opts, response, opts);
+ response.fromCache = false;
+ }
+
+ let clonedResponse;
+ if (opts.cache && response.cachePolicy.storable()) {
+ clonedResponse = cloneResponse(response);
+
+ (async () => {
+ try {
+ const bodyPromise = getStream.buffer(response);
+
+ await Promise.race([
+ requestErrorPromise,
+ new Promise(resolve => response.once('end', resolve))
+ ]);
+
+ if (requestErrored) {
+ return;
+ }
+
+ const body = await bodyPromise;
+
+ const value = {
+ cachePolicy: response.cachePolicy.toObject(),
+ url: response.url,
+ statusCode: response.fromCache ? revalidate.statusCode : response.statusCode,
+ body
+ };
+
+ let ttl = opts.strictTtl ? response.cachePolicy.timeToLive() : undefined;
+ if (opts.maxTtl) {
+ ttl = ttl ? Math.min(ttl, opts.maxTtl) : opts.maxTtl;
+ }
+
+ await this.cache.set(key, value, ttl);
+ } catch (error) {
+ ee.emit('error', new CacheableRequest.CacheError(error));
+ }
+ })();
+ } else if (opts.cache && revalidate) {
+ (async () => {
+ try {
+ await this.cache.delete(key);
+ } catch (error) {
+ ee.emit('error', new CacheableRequest.CacheError(error));
+ }
+ })();
+ }
+
+ ee.emit('response', clonedResponse || response);
+ if (typeof cb === 'function') {
+ cb(clonedResponse || response);
+ }
+ };
+
+ try {
+ const req = request(opts, handler);
+ req.once('error', requestErrorCallback);
+ req.once('abort', requestErrorCallback);
+ ee.emit('request', req);
+ } catch (error) {
+ ee.emit('error', new CacheableRequest.RequestError(error));
+ }
+ };
+
+ (async () => {
+ const get = async opts => {
+ await Promise.resolve();
+
+ const cacheEntry = opts.cache ? await this.cache.get(key) : undefined;
+ if (typeof cacheEntry === 'undefined') {
+ return makeRequest(opts);
+ }
+
+ const policy = CachePolicy.fromObject(cacheEntry.cachePolicy);
+ if (policy.satisfiesWithoutRevalidation(opts) && !opts.forceRefresh) {
+ const headers = policy.responseHeaders();
+ const response = new Response(cacheEntry.statusCode, headers, cacheEntry.body, cacheEntry.url);
+ response.cachePolicy = policy;
+ response.fromCache = true;
+
+ ee.emit('response', response);
+ if (typeof cb === 'function') {
+ cb(response);
+ }
+ } else {
+ revalidate = cacheEntry;
+ opts.headers = policy.revalidationHeaders(opts);
+ makeRequest(opts);
+ }
+ };
+
+ const errorHandler = error => ee.emit('error', new CacheableRequest.CacheError(error));
+ this.cache.once('error', errorHandler);
+ ee.on('response', () => this.cache.removeListener('error', errorHandler));
+
+ try {
+ await get(opts);
+ } catch (error) {
+ if (opts.automaticFailover && !madeRequest) {
+ makeRequest(opts);
+ }
+
+ ee.emit('error', new CacheableRequest.CacheError(error));
+ }
+ })();
+
+ return ee;
+ };
+ }
+}
+
+function urlObjectToRequestOptions(url) {
+ const options = { ...url };
+ options.path = `${url.pathname || '/'}${url.search || ''}`;
+ delete options.pathname;
+ delete options.search;
+ return options;
+}
+
+function normalizeUrlObject(url) {
+ // If url was parsed by url.parse or new URL:
+ // - hostname will be set
+ // - host will be hostname[:port]
+ // - port will be set if it was explicit in the parsed string
+ // Otherwise, url was from request options:
+ // - hostname or host may be set
+ // - host shall not have port encoded
+ return {
+ protocol: url.protocol,
+ auth: url.auth,
+ hostname: url.hostname || url.host || 'localhost',
+ port: url.port,
+ pathname: url.pathname,
+ search: url.search
+ };
+}
+
+CacheableRequest.RequestError = class extends Error {
+ constructor(error) {
+ super(error.message);
+ this.name = 'RequestError';
+ Object.assign(this, error);
+ }
+};
+
+CacheableRequest.CacheError = class extends Error {
+ constructor(error) {
+ super(error.message);
+ this.name = 'CacheError';
+ Object.assign(this, error);
+ }
+};
+
+module.exports = CacheableRequest;
+
+
/***/ }),
/***/ 402:
@@ -6878,6 +9365,18 @@ exports.Response = Response;
exports.FetchError = FetchError;
+/***/ }),
+
+/***/ 460:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = __webpack_require__(534);
+exports.default = (body) => is_1.default.nodeStream(body) && is_1.default.function_(body.getBoundary);
+
+
/***/ }),
/***/ 462:
@@ -6994,6 +9493,135 @@ exports.RequestError = RequestError;
//# sourceMappingURL=index.js.map
+/***/ }),
+
+/***/ 468:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = __webpack_require__(534);
+const types_1 = __webpack_require__(36);
+const core_1 = __webpack_require__(946);
+if (!core_1.knownHookEvents.includes('beforeRetry')) {
+ core_1.knownHookEvents.push('beforeRetry', 'afterResponse');
+}
+exports.knownBodyTypes = ['json', 'buffer', 'text'];
+// @ts-ignore The error is: Not all code paths return a value.
+exports.parseBody = (response, responseType, parseJson, encoding) => {
+ const { rawBody } = response;
+ try {
+ if (responseType === 'text') {
+ return rawBody.toString(encoding);
+ }
+ if (responseType === 'json') {
+ return rawBody.length === 0 ? '' : parseJson(rawBody.toString());
+ }
+ if (responseType === 'buffer') {
+ return Buffer.from(rawBody);
+ }
+ throw new types_1.ParseError({
+ message: `Unknown body type '${responseType}'`,
+ name: 'Error'
+ }, response);
+ }
+ catch (error) {
+ throw new types_1.ParseError(error, response);
+ }
+};
+class PromisableRequest extends core_1.default {
+ static normalizeArguments(url, nonNormalizedOptions, defaults) {
+ const options = super.normalizeArguments(url, nonNormalizedOptions, defaults);
+ if (is_1.default.null_(options.encoding)) {
+ throw new TypeError('To get a Buffer, set `options.responseType` to `buffer` instead');
+ }
+ is_1.assert.any([is_1.default.string, is_1.default.undefined], options.encoding);
+ is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.resolveBodyOnly);
+ is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.methodRewriting);
+ is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.isStream);
+ is_1.assert.any([is_1.default.string, is_1.default.undefined], options.responseType);
+ // `options.responseType`
+ if (options.responseType === undefined) {
+ options.responseType = 'text';
+ }
+ // `options.retry`
+ const { retry } = options;
+ if (defaults) {
+ options.retry = { ...defaults.retry };
+ }
+ else {
+ options.retry = {
+ calculateDelay: retryObject => retryObject.computedValue,
+ limit: 0,
+ methods: [],
+ statusCodes: [],
+ errorCodes: [],
+ maxRetryAfter: undefined
+ };
+ }
+ if (is_1.default.object(retry)) {
+ options.retry = {
+ ...options.retry,
+ ...retry
+ };
+ options.retry.methods = [...new Set(options.retry.methods.map(method => method.toUpperCase()))];
+ options.retry.statusCodes = [...new Set(options.retry.statusCodes)];
+ options.retry.errorCodes = [...new Set(options.retry.errorCodes)];
+ }
+ else if (is_1.default.number(retry)) {
+ options.retry.limit = retry;
+ }
+ if (is_1.default.undefined(options.retry.maxRetryAfter)) {
+ options.retry.maxRetryAfter = Math.min(...[options.timeout.request, options.timeout.connect].filter(is_1.default.number));
+ }
+ // `options.pagination`
+ if (is_1.default.object(options.pagination)) {
+ if (defaults) {
+ options.pagination = {
+ ...defaults.pagination,
+ ...options.pagination
+ };
+ }
+ const { pagination } = options;
+ if (!is_1.default.function_(pagination.transform)) {
+ throw new Error('`options.pagination.transform` must be implemented');
+ }
+ if (!is_1.default.function_(pagination.shouldContinue)) {
+ throw new Error('`options.pagination.shouldContinue` must be implemented');
+ }
+ if (!is_1.default.function_(pagination.filter)) {
+ throw new TypeError('`options.pagination.filter` must be implemented');
+ }
+ if (!is_1.default.function_(pagination.paginate)) {
+ throw new Error('`options.pagination.paginate` must be implemented');
+ }
+ }
+ // JSON mode
+ if (options.responseType === 'json' && options.headers.accept === undefined) {
+ options.headers.accept = 'application/json';
+ }
+ return options;
+ }
+ static mergeOptions(...sources) {
+ let mergedOptions;
+ for (const source of sources) {
+ mergedOptions = PromisableRequest.normalizeArguments(undefined, source, mergedOptions);
+ }
+ return mergedOptions;
+ }
+ async _beforeError(error) {
+ if (!(error instanceof core_1.RequestError)) {
+ error = new core_1.RequestError(error.message, error, this);
+ }
+ // Let the promise decide whether to abort or not
+ // It is also responsible for the `beforeError` hook
+ this.emit('error', error);
+ }
+}
+exports.default = PromisableRequest;
+
+
/***/ }),
/***/ 469:
@@ -7388,6 +10016,24 @@ function authenticationBeforeRequest(state, options) {
}
+/***/ }),
+
+/***/ 474:
+/***/ (function(module) {
+
+"use strict";
+
+module.exports = object => {
+ const result = {};
+
+ for (const [key, value] of Object.entries(object)) {
+ result[key.toLowerCase()] = value;
+ }
+
+ return result;
+};
+
+
/***/ }),
/***/ 489:
@@ -7443,6 +10089,164 @@ function resolveCommand(parsed) {
module.exports = resolveCommand;
+/***/ }),
+
+/***/ 490:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const defer_to_connect_1 = __webpack_require__(790);
+const nodejsMajorVersion = Number(process.versions.node.split('.')[0]);
+const timer = (request) => {
+ const timings = {
+ start: Date.now(),
+ socket: undefined,
+ lookup: undefined,
+ connect: undefined,
+ secureConnect: undefined,
+ upload: undefined,
+ response: undefined,
+ end: undefined,
+ error: undefined,
+ abort: undefined,
+ phases: {
+ wait: undefined,
+ dns: undefined,
+ tcp: undefined,
+ tls: undefined,
+ request: undefined,
+ firstByte: undefined,
+ download: undefined,
+ total: undefined
+ }
+ };
+ request.timings = timings;
+ const handleError = (origin) => {
+ const emit = origin.emit.bind(origin);
+ origin.emit = (event, ...args) => {
+ // Catches the `error` event
+ if (event === 'error') {
+ timings.error = Date.now();
+ timings.phases.total = timings.error - timings.start;
+ origin.emit = emit;
+ }
+ // Saves the original behavior
+ return emit(event, ...args);
+ };
+ };
+ handleError(request);
+ request.prependOnceListener('abort', () => {
+ timings.abort = Date.now();
+ // Let the `end` response event be responsible for setting the total phase,
+ // unless the Node.js major version is >= 13.
+ if (!timings.response || nodejsMajorVersion >= 13) {
+ timings.phases.total = Date.now() - timings.start;
+ }
+ });
+ const onSocket = (socket) => {
+ timings.socket = Date.now();
+ timings.phases.wait = timings.socket - timings.start;
+ const lookupListener = () => {
+ timings.lookup = Date.now();
+ timings.phases.dns = timings.lookup - timings.socket;
+ };
+ socket.prependOnceListener('lookup', lookupListener);
+ defer_to_connect_1.default(socket, {
+ connect: () => {
+ timings.connect = Date.now();
+ if (timings.lookup === undefined) {
+ socket.removeListener('lookup', lookupListener);
+ timings.lookup = timings.connect;
+ timings.phases.dns = timings.lookup - timings.socket;
+ }
+ timings.phases.tcp = timings.connect - timings.lookup;
+ // This callback is called before flushing any data,
+ // so we don't need to set `timings.phases.request` here.
+ },
+ secureConnect: () => {
+ timings.secureConnect = Date.now();
+ timings.phases.tls = timings.secureConnect - timings.connect;
+ }
+ });
+ };
+ if (request.socket) {
+ onSocket(request.socket);
+ }
+ else {
+ request.prependOnceListener('socket', onSocket);
+ }
+ const onUpload = () => {
+ var _a;
+ timings.upload = Date.now();
+ timings.phases.request = timings.upload - (_a = timings.secureConnect, (_a !== null && _a !== void 0 ? _a : timings.connect));
+ };
+ const writableFinished = () => {
+ if (typeof request.writableFinished === 'boolean') {
+ return request.writableFinished;
+ }
+ // Node.js doesn't have `request.writableFinished` property
+ return request.finished && request.outputSize === 0 && (!request.socket || request.socket.writableLength === 0);
+ };
+ if (writableFinished()) {
+ onUpload();
+ }
+ else {
+ request.prependOnceListener('finish', onUpload);
+ }
+ request.prependOnceListener('response', (response) => {
+ timings.response = Date.now();
+ timings.phases.firstByte = timings.response - timings.upload;
+ response.timings = timings;
+ handleError(response);
+ response.prependOnceListener('end', () => {
+ timings.end = Date.now();
+ timings.phases.download = timings.end - timings.response;
+ timings.phases.total = timings.end - timings.start;
+ });
+ });
+ return timings;
+};
+exports.default = timer;
+// For CommonJS default export support
+module.exports = timer;
+module.exports.default = timer;
+
+
+/***/ }),
+
+/***/ 507:
+/***/ (function(module) {
+
+"use strict";
+
+/* istanbul ignore file: https://github.com/nodejs/node/blob/a91293d4d9ab403046ab5eb022332e4e3d249bd3/lib/internal/url.js#L1257 */
+
+module.exports = url => {
+ const options = {
+ protocol: url.protocol,
+ hostname: typeof url.hostname === 'string' && url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname,
+ host: url.host,
+ hash: url.hash,
+ search: url.search,
+ pathname: url.pathname,
+ href: url.href,
+ path: `${url.pathname || ''}${url.search || ''}`
+ };
+
+ if (typeof url.port === 'string' && url.port.length !== 0) {
+ options.port = Number(url.port);
+ }
+
+ if (url.username || url.password) {
+ options.auth = `${url.username || ''}:${url.password || ''}`;
+ }
+
+ return options;
+};
+
+
/***/ }),
/***/ 510:
@@ -7560,6 +10364,30 @@ module.exports.Singular = Hook.Singular
module.exports.Collection = Hook.Collection
+/***/ }),
+
+/***/ 524:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+const tls = __webpack_require__(16);
+
+module.exports = (options = {}) => new Promise((resolve, reject) => {
+ const socket = tls.connect(options, () => {
+ if (options.resolveSocket) {
+ socket.off('error', reject);
+ resolve({alpnProtocol: socket.alpnProtocol, socket});
+ } else {
+ socket.destroy();
+ resolve({alpnProtocol: socket.alpnProtocol});
+ }
+ });
+
+ socket.on('error', reject);
+});
+
+
/***/ }),
/***/ 529:
@@ -7570,6 +10398,373 @@ const factory = __webpack_require__(47);
module.exports = factory();
+/***/ }),
+
+/***/ 534:
+/***/ (function(module, exports) {
+
+"use strict";
+
+///
+///
+///
+Object.defineProperty(exports, "__esModule", { value: true });
+const { toString } = Object.prototype;
+const isOfType = (type) => (value) => typeof value === type;
+const getObjectType = (value) => {
+ const objectName = toString.call(value).slice(8, -1);
+ if (objectName) {
+ return objectName;
+ }
+ return undefined;
+};
+const isObjectOfType = (type) => (value) => getObjectType(value) === type;
+function is(value) {
+ switch (value) {
+ case null:
+ return "null" /* null */;
+ case true:
+ case false:
+ return "boolean" /* boolean */;
+ default:
+ }
+ switch (typeof value) {
+ case 'undefined':
+ return "undefined" /* undefined */;
+ case 'string':
+ return "string" /* string */;
+ case 'number':
+ return "number" /* number */;
+ case 'bigint':
+ return "bigint" /* bigint */;
+ case 'symbol':
+ return "symbol" /* symbol */;
+ default:
+ }
+ if (is.function_(value)) {
+ return "Function" /* Function */;
+ }
+ if (is.observable(value)) {
+ return "Observable" /* Observable */;
+ }
+ if (is.array(value)) {
+ return "Array" /* Array */;
+ }
+ if (is.buffer(value)) {
+ return "Buffer" /* Buffer */;
+ }
+ const tagType = getObjectType(value);
+ if (tagType) {
+ return tagType;
+ }
+ if (value instanceof String || value instanceof Boolean || value instanceof Number) {
+ throw new TypeError('Please don\'t use object wrappers for primitive types');
+ }
+ return "Object" /* Object */;
+}
+is.undefined = isOfType('undefined');
+is.string = isOfType('string');
+const isNumberType = isOfType('number');
+is.number = (value) => isNumberType(value) && !is.nan(value);
+is.bigint = isOfType('bigint');
+// eslint-disable-next-line @typescript-eslint/ban-types
+is.function_ = isOfType('function');
+is.null_ = (value) => value === null;
+is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
+is.boolean = (value) => value === true || value === false;
+is.symbol = isOfType('symbol');
+is.numericString = (value) => is.string(value) && !is.emptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
+is.array = Array.isArray;
+is.buffer = (value) => { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = value) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.isBuffer) === null || _c === void 0 ? void 0 : _c.call(_b, value)) !== null && _d !== void 0 ? _d : false; };
+is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
+is.object = (value) => !is.null_(value) && (typeof value === 'object' || is.function_(value));
+is.iterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.iterator]); };
+is.asyncIterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.asyncIterator]); };
+is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw);
+is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
+is.nativePromise = (value) => isObjectOfType("Promise" /* Promise */)(value);
+const hasPromiseAPI = (value) => {
+ var _a, _b;
+ return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a.then) &&
+ is.function_((_b = value) === null || _b === void 0 ? void 0 : _b.catch);
+};
+is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
+is.generatorFunction = isObjectOfType("GeneratorFunction" /* GeneratorFunction */);
+is.asyncGeneratorFunction = (value) => getObjectType(value) === "AsyncGeneratorFunction" /* AsyncGeneratorFunction */;
+is.asyncFunction = (value) => getObjectType(value) === "AsyncFunction" /* AsyncFunction */;
+// eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types
+is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype');
+is.regExp = isObjectOfType("RegExp" /* RegExp */);
+is.date = isObjectOfType("Date" /* Date */);
+is.error = isObjectOfType("Error" /* Error */);
+is.map = (value) => isObjectOfType("Map" /* Map */)(value);
+is.set = (value) => isObjectOfType("Set" /* Set */)(value);
+is.weakMap = (value) => isObjectOfType("WeakMap" /* WeakMap */)(value);
+is.weakSet = (value) => isObjectOfType("WeakSet" /* WeakSet */)(value);
+is.int8Array = isObjectOfType("Int8Array" /* Int8Array */);
+is.uint8Array = isObjectOfType("Uint8Array" /* Uint8Array */);
+is.uint8ClampedArray = isObjectOfType("Uint8ClampedArray" /* Uint8ClampedArray */);
+is.int16Array = isObjectOfType("Int16Array" /* Int16Array */);
+is.uint16Array = isObjectOfType("Uint16Array" /* Uint16Array */);
+is.int32Array = isObjectOfType("Int32Array" /* Int32Array */);
+is.uint32Array = isObjectOfType("Uint32Array" /* Uint32Array */);
+is.float32Array = isObjectOfType("Float32Array" /* Float32Array */);
+is.float64Array = isObjectOfType("Float64Array" /* Float64Array */);
+is.bigInt64Array = isObjectOfType("BigInt64Array" /* BigInt64Array */);
+is.bigUint64Array = isObjectOfType("BigUint64Array" /* BigUint64Array */);
+is.arrayBuffer = isObjectOfType("ArrayBuffer" /* ArrayBuffer */);
+is.sharedArrayBuffer = isObjectOfType("SharedArrayBuffer" /* SharedArrayBuffer */);
+is.dataView = isObjectOfType("DataView" /* DataView */);
+is.directInstanceOf = (instance, class_) => Object.getPrototypeOf(instance) === class_.prototype;
+is.urlInstance = (value) => isObjectOfType("URL" /* URL */)(value);
+is.urlString = (value) => {
+ if (!is.string(value)) {
+ return false;
+ }
+ try {
+ new URL(value); // eslint-disable-line no-new
+ return true;
+ }
+ catch (_a) {
+ return false;
+ }
+};
+// TODO: Use the `not` operator with a type guard here when it's available.
+// Example: `is.truthy = (value: unknown): value is (not false | not 0 | not '' | not undefined | not null) => Boolean(value);`
+is.truthy = (value) => Boolean(value);
+// Example: `is.falsy = (value: unknown): value is (not true | 0 | '' | undefined | null) => Boolean(value);`
+is.falsy = (value) => !value;
+is.nan = (value) => Number.isNaN(value);
+const primitiveTypeOfTypes = new Set([
+ 'undefined',
+ 'string',
+ 'number',
+ 'bigint',
+ 'boolean',
+ 'symbol'
+]);
+is.primitive = (value) => is.null_(value) || primitiveTypeOfTypes.has(typeof value);
+is.integer = (value) => Number.isInteger(value);
+is.safeInteger = (value) => Number.isSafeInteger(value);
+is.plainObject = (value) => {
+ // From: https://github.com/sindresorhus/is-plain-obj/blob/master/index.js
+ if (getObjectType(value) !== "Object" /* Object */) {
+ return false;
+ }
+ const prototype = Object.getPrototypeOf(value);
+ return prototype === null || prototype === Object.getPrototypeOf({});
+};
+const typedArrayTypes = new Set([
+ "Int8Array" /* Int8Array */,
+ "Uint8Array" /* Uint8Array */,
+ "Uint8ClampedArray" /* Uint8ClampedArray */,
+ "Int16Array" /* Int16Array */,
+ "Uint16Array" /* Uint16Array */,
+ "Int32Array" /* Int32Array */,
+ "Uint32Array" /* Uint32Array */,
+ "Float32Array" /* Float32Array */,
+ "Float64Array" /* Float64Array */,
+ "BigInt64Array" /* BigInt64Array */,
+ "BigUint64Array" /* BigUint64Array */
+]);
+is.typedArray = (value) => {
+ const objectType = getObjectType(value);
+ if (objectType === undefined) {
+ return false;
+ }
+ return typedArrayTypes.has(objectType);
+};
+const isValidLength = (value) => is.safeInteger(value) && value >= 0;
+is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length);
+is.inRange = (value, range) => {
+ if (is.number(range)) {
+ return value >= Math.min(0, range) && value <= Math.max(range, 0);
+ }
+ if (is.array(range) && range.length === 2) {
+ return value >= Math.min(...range) && value <= Math.max(...range);
+ }
+ throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
+};
+const NODE_TYPE_ELEMENT = 1;
+const DOM_PROPERTIES_TO_CHECK = [
+ 'innerHTML',
+ 'ownerDocument',
+ 'style',
+ 'attributes',
+ 'nodeValue'
+];
+is.domElement = (value) => is.object(value) && value.nodeType === NODE_TYPE_ELEMENT && is.string(value.nodeName) &&
+ !is.plainObject(value) && DOM_PROPERTIES_TO_CHECK.every(property => property in value);
+is.observable = (value) => {
+ var _a, _b, _c, _d;
+ if (!value) {
+ return false;
+ }
+ // eslint-disable-next-line no-use-extend-native/no-use-extend-native
+ if (value === ((_b = (_a = value)[Symbol.observable]) === null || _b === void 0 ? void 0 : _b.call(_a))) {
+ return true;
+ }
+ if (value === ((_d = (_c = value)['@@observable']) === null || _d === void 0 ? void 0 : _d.call(_c))) {
+ return true;
+ }
+ return false;
+};
+is.nodeStream = (value) => is.object(value) && is.function_(value.pipe) && !is.observable(value);
+is.infinite = (value) => value === Infinity || value === -Infinity;
+const isAbsoluteMod2 = (remainder) => (value) => is.integer(value) && Math.abs(value % 2) === remainder;
+is.evenInteger = isAbsoluteMod2(0);
+is.oddInteger = isAbsoluteMod2(1);
+is.emptyArray = (value) => is.array(value) && value.length === 0;
+is.nonEmptyArray = (value) => is.array(value) && value.length > 0;
+is.emptyString = (value) => is.string(value) && value.length === 0;
+// TODO: Use `not ''` when the `not` operator is available.
+is.nonEmptyString = (value) => is.string(value) && value.length > 0;
+const isWhiteSpaceString = (value) => is.string(value) && !/\S/.test(value);
+is.emptyStringOrWhitespace = (value) => is.emptyString(value) || isWhiteSpaceString(value);
+is.emptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0;
+// TODO: Use `not` operator here to remove `Map` and `Set` from type guard:
+// - https://github.com/Microsoft/TypeScript/pull/29317
+is.nonEmptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0;
+is.emptySet = (value) => is.set(value) && value.size === 0;
+is.nonEmptySet = (value) => is.set(value) && value.size > 0;
+is.emptyMap = (value) => is.map(value) && value.size === 0;
+is.nonEmptyMap = (value) => is.map(value) && value.size > 0;
+const predicateOnArray = (method, predicate, values) => {
+ if (!is.function_(predicate)) {
+ throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
+ }
+ if (values.length === 0) {
+ throw new TypeError('Invalid number of values');
+ }
+ return method.call(values, predicate);
+};
+is.any = (predicate, ...values) => {
+ const predicates = is.array(predicate) ? predicate : [predicate];
+ return predicates.some(singlePredicate => predicateOnArray(Array.prototype.some, singlePredicate, values));
+};
+is.all = (predicate, ...values) => predicateOnArray(Array.prototype.every, predicate, values);
+const assertType = (condition, description, value) => {
+ if (!condition) {
+ throw new TypeError(`Expected value which is \`${description}\`, received value of type \`${is(value)}\`.`);
+ }
+};
+exports.assert = {
+ // Unknowns.
+ undefined: (value) => assertType(is.undefined(value), "undefined" /* undefined */, value),
+ string: (value) => assertType(is.string(value), "string" /* string */, value),
+ number: (value) => assertType(is.number(value), "number" /* number */, value),
+ bigint: (value) => assertType(is.bigint(value), "bigint" /* bigint */, value),
+ // eslint-disable-next-line @typescript-eslint/ban-types
+ function_: (value) => assertType(is.function_(value), "Function" /* Function */, value),
+ null_: (value) => assertType(is.null_(value), "null" /* null */, value),
+ class_: (value) => assertType(is.class_(value), "Class" /* class_ */, value),
+ boolean: (value) => assertType(is.boolean(value), "boolean" /* boolean */, value),
+ symbol: (value) => assertType(is.symbol(value), "symbol" /* symbol */, value),
+ numericString: (value) => assertType(is.numericString(value), "string with a number" /* numericString */, value),
+ array: (value) => assertType(is.array(value), "Array" /* Array */, value),
+ buffer: (value) => assertType(is.buffer(value), "Buffer" /* Buffer */, value),
+ nullOrUndefined: (value) => assertType(is.nullOrUndefined(value), "null or undefined" /* nullOrUndefined */, value),
+ object: (value) => assertType(is.object(value), "Object" /* Object */, value),
+ iterable: (value) => assertType(is.iterable(value), "Iterable" /* iterable */, value),
+ asyncIterable: (value) => assertType(is.asyncIterable(value), "AsyncIterable" /* asyncIterable */, value),
+ generator: (value) => assertType(is.generator(value), "Generator" /* Generator */, value),
+ asyncGenerator: (value) => assertType(is.asyncGenerator(value), "AsyncGenerator" /* AsyncGenerator */, value),
+ nativePromise: (value) => assertType(is.nativePromise(value), "native Promise" /* nativePromise */, value),
+ promise: (value) => assertType(is.promise(value), "Promise" /* Promise */, value),
+ generatorFunction: (value) => assertType(is.generatorFunction(value), "GeneratorFunction" /* GeneratorFunction */, value),
+ asyncGeneratorFunction: (value) => assertType(is.asyncGeneratorFunction(value), "AsyncGeneratorFunction" /* AsyncGeneratorFunction */, value),
+ // eslint-disable-next-line @typescript-eslint/ban-types
+ asyncFunction: (value) => assertType(is.asyncFunction(value), "AsyncFunction" /* AsyncFunction */, value),
+ // eslint-disable-next-line @typescript-eslint/ban-types
+ boundFunction: (value) => assertType(is.boundFunction(value), "Function" /* Function */, value),
+ regExp: (value) => assertType(is.regExp(value), "RegExp" /* RegExp */, value),
+ date: (value) => assertType(is.date(value), "Date" /* Date */, value),
+ error: (value) => assertType(is.error(value), "Error" /* Error */, value),
+ map: (value) => assertType(is.map(value), "Map" /* Map */, value),
+ set: (value) => assertType(is.set(value), "Set" /* Set */, value),
+ weakMap: (value) => assertType(is.weakMap(value), "WeakMap" /* WeakMap */, value),
+ weakSet: (value) => assertType(is.weakSet(value), "WeakSet" /* WeakSet */, value),
+ int8Array: (value) => assertType(is.int8Array(value), "Int8Array" /* Int8Array */, value),
+ uint8Array: (value) => assertType(is.uint8Array(value), "Uint8Array" /* Uint8Array */, value),
+ uint8ClampedArray: (value) => assertType(is.uint8ClampedArray(value), "Uint8ClampedArray" /* Uint8ClampedArray */, value),
+ int16Array: (value) => assertType(is.int16Array(value), "Int16Array" /* Int16Array */, value),
+ uint16Array: (value) => assertType(is.uint16Array(value), "Uint16Array" /* Uint16Array */, value),
+ int32Array: (value) => assertType(is.int32Array(value), "Int32Array" /* Int32Array */, value),
+ uint32Array: (value) => assertType(is.uint32Array(value), "Uint32Array" /* Uint32Array */, value),
+ float32Array: (value) => assertType(is.float32Array(value), "Float32Array" /* Float32Array */, value),
+ float64Array: (value) => assertType(is.float64Array(value), "Float64Array" /* Float64Array */, value),
+ bigInt64Array: (value) => assertType(is.bigInt64Array(value), "BigInt64Array" /* BigInt64Array */, value),
+ bigUint64Array: (value) => assertType(is.bigUint64Array(value), "BigUint64Array" /* BigUint64Array */, value),
+ arrayBuffer: (value) => assertType(is.arrayBuffer(value), "ArrayBuffer" /* ArrayBuffer */, value),
+ sharedArrayBuffer: (value) => assertType(is.sharedArrayBuffer(value), "SharedArrayBuffer" /* SharedArrayBuffer */, value),
+ dataView: (value) => assertType(is.dataView(value), "DataView" /* DataView */, value),
+ urlInstance: (value) => assertType(is.urlInstance(value), "URL" /* URL */, value),
+ urlString: (value) => assertType(is.urlString(value), "string with a URL" /* urlString */, value),
+ truthy: (value) => assertType(is.truthy(value), "truthy" /* truthy */, value),
+ falsy: (value) => assertType(is.falsy(value), "falsy" /* falsy */, value),
+ nan: (value) => assertType(is.nan(value), "NaN" /* nan */, value),
+ primitive: (value) => assertType(is.primitive(value), "primitive" /* primitive */, value),
+ integer: (value) => assertType(is.integer(value), "integer" /* integer */, value),
+ safeInteger: (value) => assertType(is.safeInteger(value), "integer" /* safeInteger */, value),
+ plainObject: (value) => assertType(is.plainObject(value), "plain object" /* plainObject */, value),
+ typedArray: (value) => assertType(is.typedArray(value), "TypedArray" /* typedArray */, value),
+ arrayLike: (value) => assertType(is.arrayLike(value), "array-like" /* arrayLike */, value),
+ domElement: (value) => assertType(is.domElement(value), "Element" /* domElement */, value),
+ observable: (value) => assertType(is.observable(value), "Observable" /* Observable */, value),
+ nodeStream: (value) => assertType(is.nodeStream(value), "Node.js Stream" /* nodeStream */, value),
+ infinite: (value) => assertType(is.infinite(value), "infinite number" /* infinite */, value),
+ emptyArray: (value) => assertType(is.emptyArray(value), "empty array" /* emptyArray */, value),
+ nonEmptyArray: (value) => assertType(is.nonEmptyArray(value), "non-empty array" /* nonEmptyArray */, value),
+ emptyString: (value) => assertType(is.emptyString(value), "empty string" /* emptyString */, value),
+ nonEmptyString: (value) => assertType(is.nonEmptyString(value), "non-empty string" /* nonEmptyString */, value),
+ emptyStringOrWhitespace: (value) => assertType(is.emptyStringOrWhitespace(value), "empty string or whitespace" /* emptyStringOrWhitespace */, value),
+ emptyObject: (value) => assertType(is.emptyObject(value), "empty object" /* emptyObject */, value),
+ nonEmptyObject: (value) => assertType(is.nonEmptyObject(value), "non-empty object" /* nonEmptyObject */, value),
+ emptySet: (value) => assertType(is.emptySet(value), "empty set" /* emptySet */, value),
+ nonEmptySet: (value) => assertType(is.nonEmptySet(value), "non-empty set" /* nonEmptySet */, value),
+ emptyMap: (value) => assertType(is.emptyMap(value), "empty map" /* emptyMap */, value),
+ nonEmptyMap: (value) => assertType(is.nonEmptyMap(value), "non-empty map" /* nonEmptyMap */, value),
+ // Numbers.
+ evenInteger: (value) => assertType(is.evenInteger(value), "even integer" /* evenInteger */, value),
+ oddInteger: (value) => assertType(is.oddInteger(value), "odd integer" /* oddInteger */, value),
+ // Two arguments.
+ directInstanceOf: (instance, class_) => assertType(is.directInstanceOf(instance, class_), "T" /* directInstanceOf */, instance),
+ inRange: (value, range) => assertType(is.inRange(value, range), "in range" /* inRange */, value),
+ // Variadic functions.
+ any: (predicate, ...values) => assertType(is.any(predicate, ...values), "predicate returns truthy for any value" /* any */, values),
+ all: (predicate, ...values) => assertType(is.all(predicate, ...values), "predicate returns truthy for all values" /* all */, values)
+};
+// Some few keywords are reserved, but we'll populate them for Node.js users
+// See https://github.com/Microsoft/TypeScript/issues/2536
+Object.defineProperties(is, {
+ class: {
+ value: is.class_
+ },
+ function: {
+ value: is.function_
+ },
+ null: {
+ value: is.null_
+ }
+});
+Object.defineProperties(exports.assert, {
+ class: {
+ value: exports.assert.class_
+ },
+ function: {
+ value: exports.assert.function_
+ },
+ null: {
+ value: exports.assert.null_
+ }
+});
+exports.default = is;
+// For CommonJS default export support
+module.exports = is;
+module.exports.default = is;
+module.exports.assert = exports.assert;
+
+
/***/ }),
/***/ 536:
@@ -8139,6 +11334,121 @@ function getNextPage (octokit, link, headers) {
}
+/***/ }),
+
+/***/ 557:
+/***/ (function(module) {
+
+"use strict";
+
+
+class CancelError extends Error {
+ constructor(reason) {
+ super(reason || 'Promise was canceled');
+ this.name = 'CancelError';
+ }
+
+ get isCanceled() {
+ return true;
+ }
+}
+
+class PCancelable {
+ static fn(userFn) {
+ return (...arguments_) => {
+ return new PCancelable((resolve, reject, onCancel) => {
+ arguments_.push(onCancel);
+ // eslint-disable-next-line promise/prefer-await-to-then
+ userFn(...arguments_).then(resolve, reject);
+ });
+ };
+ }
+
+ constructor(executor) {
+ this._cancelHandlers = [];
+ this._isPending = true;
+ this._isCanceled = false;
+ this._rejectOnCancel = true;
+
+ this._promise = new Promise((resolve, reject) => {
+ this._reject = reject;
+
+ const onResolve = value => {
+ this._isPending = false;
+ resolve(value);
+ };
+
+ const onReject = error => {
+ this._isPending = false;
+ reject(error);
+ };
+
+ const onCancel = handler => {
+ if (!this._isPending) {
+ throw new Error('The `onCancel` handler was attached after the promise settled.');
+ }
+
+ this._cancelHandlers.push(handler);
+ };
+
+ Object.defineProperties(onCancel, {
+ shouldReject: {
+ get: () => this._rejectOnCancel,
+ set: boolean => {
+ this._rejectOnCancel = boolean;
+ }
+ }
+ });
+
+ return executor(onResolve, onReject, onCancel);
+ });
+ }
+
+ then(onFulfilled, onRejected) {
+ // eslint-disable-next-line promise/prefer-await-to-then
+ return this._promise.then(onFulfilled, onRejected);
+ }
+
+ catch(onRejected) {
+ return this._promise.catch(onRejected);
+ }
+
+ finally(onFinally) {
+ return this._promise.finally(onFinally);
+ }
+
+ cancel(reason) {
+ if (!this._isPending || this._isCanceled) {
+ return;
+ }
+
+ if (this._cancelHandlers.length > 0) {
+ try {
+ for (const handler of this._cancelHandlers) {
+ handler();
+ }
+ } catch (error) {
+ this._reject(error);
+ }
+ }
+
+ this._isCanceled = true;
+ if (this._rejectOnCancel) {
+ this._reject(new CancelError(reason));
+ }
+ }
+
+ get isCanceled() {
+ return this._isCanceled;
+ }
+}
+
+Object.setPrototypeOf(PCancelable.prototype, Promise.prototype);
+
+module.exports = PCancelable;
+module.exports.CancelError = CancelError;
+
+
/***/ }),
/***/ 558:
@@ -8169,6 +11479,13 @@ function getPreviousPage (octokit, link, headers) {
}
+/***/ }),
+
+/***/ 565:
+/***/ (function(module) {
+
+module.exports = require("http2");
+
/***/ }),
/***/ 568:
@@ -8302,6 +11619,454 @@ function parse(command, args, options) {
module.exports = parse;
+/***/ }),
+
+/***/ 570:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+const {
+ V4MAPPED,
+ ADDRCONFIG,
+ ALL,
+ promises: {
+ Resolver: AsyncResolver
+ },
+ lookup: dnsLookup
+} = __webpack_require__(819);
+const {promisify} = __webpack_require__(669);
+const os = __webpack_require__(87);
+
+const kCacheableLookupCreateConnection = Symbol('cacheableLookupCreateConnection');
+const kCacheableLookupInstance = Symbol('cacheableLookupInstance');
+const kExpires = Symbol('expires');
+
+const supportsALL = typeof ALL === 'number';
+
+const verifyAgent = agent => {
+ if (!(agent && typeof agent.createConnection === 'function')) {
+ throw new Error('Expected an Agent instance as the first argument');
+ }
+};
+
+const map4to6 = entries => {
+ for (const entry of entries) {
+ if (entry.family === 6) {
+ continue;
+ }
+
+ entry.address = `::ffff:${entry.address}`;
+ entry.family = 6;
+ }
+};
+
+const getIfaceInfo = () => {
+ let has4 = false;
+ let has6 = false;
+
+ for (const device of Object.values(os.networkInterfaces())) {
+ for (const iface of device) {
+ if (iface.internal) {
+ continue;
+ }
+
+ if (iface.family === 'IPv6') {
+ has6 = true;
+ } else {
+ has4 = true;
+ }
+
+ if (has4 && has6) {
+ return {has4, has6};
+ }
+ }
+ }
+
+ return {has4, has6};
+};
+
+const isIterable = map => {
+ return Symbol.iterator in map;
+};
+
+const ttl = {ttl: true};
+const all = {all: true};
+
+class CacheableLookup {
+ constructor({
+ cache = new Map(),
+ maxTtl = Infinity,
+ fallbackDuration = 3600,
+ errorTtl = 0.15,
+ resolver = new AsyncResolver(),
+ lookup = dnsLookup
+ } = {}) {
+ this.maxTtl = maxTtl;
+ this.errorTtl = errorTtl;
+
+ this._cache = cache;
+ this._resolver = resolver;
+ this._dnsLookup = promisify(lookup);
+
+ if (this._resolver instanceof AsyncResolver) {
+ this._resolve4 = this._resolver.resolve4.bind(this._resolver);
+ this._resolve6 = this._resolver.resolve6.bind(this._resolver);
+ } else {
+ this._resolve4 = promisify(this._resolver.resolve4.bind(this._resolver));
+ this._resolve6 = promisify(this._resolver.resolve6.bind(this._resolver));
+ }
+
+ this._iface = getIfaceInfo();
+
+ this._pending = {};
+ this._nextRemovalTime = false;
+ this._hostnamesToFallback = new Set();
+
+ if (fallbackDuration < 1) {
+ this._fallback = false;
+ } else {
+ this._fallback = true;
+
+ const interval = setInterval(() => {
+ this._hostnamesToFallback.clear();
+ }, fallbackDuration * 1000);
+
+ /* istanbul ignore next: There is no `interval.unref()` when running inside an Electron renderer */
+ if (interval.unref) {
+ interval.unref();
+ }
+ }
+
+ this.lookup = this.lookup.bind(this);
+ this.lookupAsync = this.lookupAsync.bind(this);
+ }
+
+ set servers(servers) {
+ this.clear();
+
+ this._resolver.setServers(servers);
+ }
+
+ get servers() {
+ return this._resolver.getServers();
+ }
+
+ lookup(hostname, options, callback) {
+ if (typeof options === 'function') {
+ callback = options;
+ options = {};
+ } else if (typeof options === 'number') {
+ options = {
+ family: options
+ };
+ }
+
+ if (!callback) {
+ throw new Error('Callback must be a function.');
+ }
+
+ // eslint-disable-next-line promise/prefer-await-to-then
+ this.lookupAsync(hostname, options).then(result => {
+ if (options.all) {
+ callback(null, result);
+ } else {
+ callback(null, result.address, result.family, result.expires, result.ttl);
+ }
+ }, callback);
+ }
+
+ async lookupAsync(hostname, options = {}) {
+ if (typeof options === 'number') {
+ options = {
+ family: options
+ };
+ }
+
+ let cached = await this.query(hostname);
+
+ if (options.family === 6) {
+ const filtered = cached.filter(entry => entry.family === 6);
+
+ if (options.hints & V4MAPPED) {
+ if ((supportsALL && options.hints & ALL) || filtered.length === 0) {
+ map4to6(cached);
+ } else {
+ cached = filtered;
+ }
+ } else {
+ cached = filtered;
+ }
+ } else if (options.family === 4) {
+ cached = cached.filter(entry => entry.family === 4);
+ }
+
+ if (options.hints & ADDRCONFIG) {
+ const {_iface} = this;
+ cached = cached.filter(entry => entry.family === 6 ? _iface.has6 : _iface.has4);
+ }
+
+ if (cached.length === 0) {
+ const error = new Error(`cacheableLookup ENOTFOUND ${hostname}`);
+ error.code = 'ENOTFOUND';
+ error.hostname = hostname;
+
+ throw error;
+ }
+
+ if (options.all) {
+ return cached;
+ }
+
+ return cached[0];
+ }
+
+ async query(hostname) {
+ let cached = await this._cache.get(hostname);
+
+ if (!cached) {
+ const pending = this._pending[hostname];
+
+ if (pending) {
+ cached = await pending;
+ } else {
+ const newPromise = this.queryAndCache(hostname);
+ this._pending[hostname] = newPromise;
+
+ cached = await newPromise;
+ }
+ }
+
+ cached = cached.map(entry => {
+ return {...entry};
+ });
+
+ return cached;
+ }
+
+ async _resolve(hostname) {
+ const wrap = async promise => {
+ try {
+ return await promise;
+ } catch (error) {
+ if (error.code === 'ENODATA' || error.code === 'ENOTFOUND') {
+ return [];
+ }
+
+ throw error;
+ }
+ };
+
+ // ANY is unsafe as it doesn't trigger new queries in the underlying server.
+ const [A, AAAA] = await Promise.all([
+ this._resolve4(hostname, ttl),
+ this._resolve6(hostname, ttl)
+ ].map(promise => wrap(promise)));
+
+ let aTtl = 0;
+ let aaaaTtl = 0;
+ let cacheTtl = 0;
+
+ const now = Date.now();
+
+ for (const entry of A) {
+ entry.family = 4;
+ entry.expires = now + (entry.ttl * 1000);
+
+ aTtl = Math.max(aTtl, entry.ttl);
+ }
+
+ for (const entry of AAAA) {
+ entry.family = 6;
+ entry.expires = now + (entry.ttl * 1000);
+
+ aaaaTtl = Math.max(aaaaTtl, entry.ttl);
+ }
+
+ if (A.length > 0) {
+ if (AAAA.length > 0) {
+ cacheTtl = Math.min(aTtl, aaaaTtl);
+ } else {
+ cacheTtl = aTtl;
+ }
+ } else {
+ cacheTtl = aaaaTtl;
+ }
+
+ return {
+ entries: [
+ ...A,
+ ...AAAA
+ ],
+ cacheTtl
+ };
+ }
+
+ async _lookup(hostname) {
+ try {
+ const entries = await this._dnsLookup(hostname, {
+ all: true
+ });
+
+ return {
+ entries,
+ cacheTtl: 0
+ };
+ } catch (_) {
+ return {
+ entries: [],
+ cacheTtl: 0
+ };
+ }
+ }
+
+ async _set(hostname, data, cacheTtl) {
+ if (this.maxTtl > 0 && cacheTtl > 0) {
+ cacheTtl = Math.min(cacheTtl, this.maxTtl) * 1000;
+ data[kExpires] = Date.now() + cacheTtl;
+
+ try {
+ await this._cache.set(hostname, data, cacheTtl);
+ } catch (error) {
+ this.lookupAsync = async () => {
+ const cacheError = new Error('Cache Error. Please recreate the CacheableLookup instance.');
+ cacheError.cause = error;
+
+ throw cacheError;
+ };
+ }
+
+ if (isIterable(this._cache)) {
+ this._tick(cacheTtl);
+ }
+ }
+ }
+
+ async queryAndCache(hostname) {
+ if (this._hostnamesToFallback.has(hostname)) {
+ return this._dnsLookup(hostname, all);
+ }
+
+ try {
+ let query = await this._resolve(hostname);
+
+ if (query.entries.length === 0 && this._fallback) {
+ query = await this._lookup(hostname);
+
+ if (query.entries.length !== 0) {
+ // Use `dns.lookup(...)` for that particular hostname
+ this._hostnamesToFallback.add(hostname);
+ }
+ }
+
+ const cacheTtl = query.entries.length === 0 ? this.errorTtl : query.cacheTtl;
+ await this._set(hostname, query.entries, cacheTtl);
+
+ delete this._pending[hostname];
+
+ return query.entries;
+ } catch (error) {
+ delete this._pending[hostname];
+
+ throw error;
+ }
+ }
+
+ _tick(ms) {
+ const nextRemovalTime = this._nextRemovalTime;
+
+ if (!nextRemovalTime || ms < nextRemovalTime) {
+ clearTimeout(this._removalTimeout);
+
+ this._nextRemovalTime = ms;
+
+ this._removalTimeout = setTimeout(() => {
+ this._nextRemovalTime = false;
+
+ let nextExpiry = Infinity;
+
+ const now = Date.now();
+
+ for (const [hostname, entries] of this._cache) {
+ const expires = entries[kExpires];
+
+ if (now >= expires) {
+ this._cache.delete(hostname);
+ } else if (expires < nextExpiry) {
+ nextExpiry = expires;
+ }
+ }
+
+ if (nextExpiry !== Infinity) {
+ this._tick(nextExpiry - now);
+ }
+ }, ms);
+
+ /* istanbul ignore next: There is no `timeout.unref()` when running inside an Electron renderer */
+ if (this._removalTimeout.unref) {
+ this._removalTimeout.unref();
+ }
+ }
+ }
+
+ install(agent) {
+ verifyAgent(agent);
+
+ if (kCacheableLookupCreateConnection in agent) {
+ throw new Error('CacheableLookup has been already installed');
+ }
+
+ agent[kCacheableLookupCreateConnection] = agent.createConnection;
+ agent[kCacheableLookupInstance] = this;
+
+ agent.createConnection = (options, callback) => {
+ if (!('lookup' in options)) {
+ options.lookup = this.lookup;
+ }
+
+ return agent[kCacheableLookupCreateConnection](options, callback);
+ };
+ }
+
+ uninstall(agent) {
+ verifyAgent(agent);
+
+ if (agent[kCacheableLookupCreateConnection]) {
+ if (agent[kCacheableLookupInstance] !== this) {
+ throw new Error('The agent is not owned by this CacheableLookup instance');
+ }
+
+ agent.createConnection = agent[kCacheableLookupCreateConnection];
+
+ delete agent[kCacheableLookupCreateConnection];
+ delete agent[kCacheableLookupInstance];
+ }
+ }
+
+ updateInterfaceInfo() {
+ const {_iface} = this;
+
+ this._iface = getIfaceInfo();
+
+ if ((_iface.has4 && !this._iface.has4) || (_iface.has6 && !this._iface.has6)) {
+ this._cache.clear();
+ }
+ }
+
+ clear(hostname) {
+ if (hostname) {
+ this._cache.delete(hostname);
+ return;
+ }
+
+ this._cache.clear();
+ }
+}
+
+module.exports = CacheableLookup;
+module.exports.default = CacheableLookup;
+
+
/***/ }),
/***/ 577:
@@ -8422,6 +12187,90 @@ module.exports.env = opts => {
module.exports = require("path");
+/***/ }),
+
+/***/ 625:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+const {PassThrough} = __webpack_require__(413);
+
+module.exports = options => {
+ options = Object.assign({}, options);
+
+ const {array} = options;
+ let {encoding} = options;
+ const buffer = encoding === 'buffer';
+ let objectMode = false;
+
+ if (array) {
+ objectMode = !(encoding || buffer);
+ } else {
+ encoding = encoding || 'utf8';
+ }
+
+ if (buffer) {
+ encoding = null;
+ }
+
+ let len = 0;
+ const ret = [];
+ const stream = new PassThrough({objectMode});
+
+ if (encoding) {
+ stream.setEncoding(encoding);
+ }
+
+ stream.on('data', chunk => {
+ ret.push(chunk);
+
+ if (objectMode) {
+ len = ret.length;
+ } else {
+ len += chunk.length;
+ }
+ });
+
+ stream.getBufferedValue = () => {
+ if (array) {
+ return ret;
+ }
+
+ return buffer ? Buffer.concat(ret, len) : ret.join('');
+ };
+
+ stream.getBufferedLength = () => len;
+
+ return stream;
+};
+
+
+/***/ }),
+
+/***/ 628:
+/***/ (function(__unusedmodule, exports) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1(from, to, events) {
+ const fns = {};
+ for (const event of events) {
+ fns[event] = (...args) => {
+ to.emit(event, ...args);
+ };
+ from.on(event, fns[event]);
+ }
+ return () => {
+ for (const event of events) {
+ from.off(event, fns[event]);
+ }
+ };
+}
+exports.default = default_1;
+
+
/***/ }),
/***/ 631:
@@ -8686,6 +12535,104 @@ module.exports = (promise, onFinally) => {
};
+/***/ }),
+
+/***/ 699:
+/***/ (function(module) {
+
+"use strict";
+
+/* istanbul ignore file: https://github.com/nodejs/node/blob/master/lib/internal/errors.js */
+
+const makeError = (Base, key, getMessage) => {
+ module.exports[key] = class NodeError extends Base {
+ constructor(...args) {
+ super(typeof getMessage === 'string' ? getMessage : getMessage(args));
+ this.name = `${super.name} [${key}]`;
+ this.code = key;
+ }
+ };
+};
+
+makeError(TypeError, 'ERR_INVALID_ARG_TYPE', args => {
+ const type = args[0].includes('.') ? 'property' : 'argument';
+
+ let valid = args[1];
+ const isManyTypes = Array.isArray(valid);
+
+ if (isManyTypes) {
+ valid = `${valid.slice(0, -1).join(', ')} or ${valid.slice(-1)}`;
+ }
+
+ return `The "${args[0]}" ${type} must be ${isManyTypes ? 'one of' : 'of'} type ${valid}. Received ${typeof args[2]}`;
+});
+
+makeError(TypeError, 'ERR_INVALID_PROTOCOL', args => {
+ return `Protocol "${args[0]}" not supported. Expected "${args[1]}"`;
+});
+
+makeError(Error, 'ERR_HTTP_HEADERS_SENT', args => {
+ return `Cannot ${args[0]} headers after they are sent to the client`;
+});
+
+makeError(TypeError, 'ERR_INVALID_HTTP_TOKEN', args => {
+ return `${args[0]} must be a valid HTTP token [${args[1]}]`;
+});
+
+makeError(TypeError, 'ERR_HTTP_INVALID_HEADER_VALUE', args => {
+ return `Invalid value "${args[0]} for header "${args[1]}"`;
+});
+
+makeError(TypeError, 'ERR_INVALID_CHAR', args => {
+ return `Invalid character in ${args[0]} [${args[1]}]`;
+});
+
+
+/***/ }),
+
+/***/ 723:
+/***/ (function(module) {
+
+"use strict";
+
+
+module.exports = header => {
+ switch (header) {
+ case ':method':
+ case ':scheme':
+ case ':authority':
+ case ':path':
+ return true;
+ default:
+ return false;
+ }
+};
+
+
+/***/ }),
+
+/***/ 738:
+/***/ (function(__unusedmodule, exports) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const conversionTable = {
+ auto: 0,
+ ipv4: 4,
+ ipv6: 6
+};
+exports.isDnsLookupIpVersion = (value) => {
+ return value in conversionTable;
+};
+exports.dnsLookupIpVersionToFamily = (dnsLookupIpVersion) => {
+ if (exports.isDnsLookupIpVersion(dnsLookupIpVersion)) {
+ return conversionTable[dnsLookupIpVersion];
+ }
+ throw new Error('Invalid DNS lookup IP version');
+};
+
+
/***/ }),
/***/ 742:
@@ -8757,6 +12704,107 @@ function sync (path, options) {
module.exports = require("fs");
+/***/ }),
+
+/***/ 750:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+const {Readable} = __webpack_require__(413);
+
+class IncomingMessage extends Readable {
+ constructor(socket, highWaterMark) {
+ super({
+ highWaterMark,
+ autoDestroy: false
+ });
+
+ this.statusCode = null;
+ this.statusMessage = '';
+ this.httpVersion = '2.0';
+ this.httpVersionMajor = 2;
+ this.httpVersionMinor = 0;
+ this.headers = {};
+ this.trailers = {};
+ this.req = null;
+
+ this.aborted = false;
+ this.complete = false;
+ this.upgrade = null;
+
+ this.rawHeaders = [];
+ this.rawTrailers = [];
+
+ this.socket = socket;
+ this.connection = socket;
+
+ this._dumped = false;
+ }
+
+ _destroy(error) {
+ this.req._request.destroy(error);
+ }
+
+ setTimeout(ms, callback) {
+ this.req.setTimeout(ms, callback);
+ return this;
+ }
+
+ _dump() {
+ if (!this._dumped) {
+ this._dumped = true;
+
+ this.removeAllListeners('data');
+ this.resume();
+ }
+ }
+
+ _read() {
+ if (this.req) {
+ this.req._request.resume();
+ }
+ }
+}
+
+module.exports = IncomingMessage;
+
+
+/***/ }),
+
+/***/ 751:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+const net = __webpack_require__(631);
+/* istanbul ignore file: https://github.com/nodejs/node/blob/v13.0.1/lib/_http_agent.js */
+
+module.exports = options => {
+ let servername = options.host;
+ const hostHeader = options.headers && options.headers.host;
+
+ if (hostHeader) {
+ if (hostHeader.startsWith('[')) {
+ const index = hostHeader.indexOf(']');
+ if (index === -1) {
+ servername = hostHeader;
+ } else {
+ servername = hostHeader.slice(1, -1);
+ }
+ } else {
+ servername = hostHeader.split(':', 1)[0];
+ }
+ }
+
+ if (net.isIP(servername)) {
+ return '';
+ }
+
+ return servername;
+};
+
+
/***/ }),
/***/ 753:
@@ -8981,6 +13029,126 @@ function getFirstPage (octokit, link, headers) {
}
+/***/ }),
+
+/***/ 784:
+/***/ (function(__unusedmodule, exports) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+// When attaching listeners, it's very easy to forget about them.
+// Especially if you do error handling and set timeouts.
+// So instead of checking if it's proper to throw an error on every timeout ever,
+// use this simple tool which will remove all listeners you have attached.
+exports.default = () => {
+ const handlers = [];
+ return {
+ once(origin, event, fn) {
+ origin.once(event, fn);
+ handlers.push({ origin, event, fn });
+ },
+ unhandleAll() {
+ for (const handler of handlers) {
+ const { origin, event, fn } = handler;
+ origin.removeListener(event, fn);
+ }
+ handlers.length = 0;
+ }
+ };
+};
+
+
+/***/ }),
+
+/***/ 786:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __webpack_require__(747);
+const util_1 = __webpack_require__(669);
+const is_1 = __webpack_require__(534);
+const is_form_data_1 = __webpack_require__(460);
+const statAsync = util_1.promisify(fs_1.stat);
+exports.default = async (body, headers) => {
+ if (headers && 'content-length' in headers) {
+ return Number(headers['content-length']);
+ }
+ if (!body) {
+ return 0;
+ }
+ if (is_1.default.string(body)) {
+ return Buffer.byteLength(body);
+ }
+ if (is_1.default.buffer(body)) {
+ return body.length;
+ }
+ if (is_form_data_1.default(body)) {
+ return util_1.promisify(body.getLength.bind(body))();
+ }
+ if (body instanceof fs_1.ReadStream) {
+ const { size } = await statAsync(body.path);
+ return size;
+ }
+ return undefined;
+};
+
+
+/***/ }),
+
+/***/ 790:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const tls_1 = __webpack_require__(16);
+const deferToConnect = (socket, fn) => {
+ let listeners;
+ if (typeof fn === 'function') {
+ const connect = fn;
+ listeners = { connect };
+ }
+ else {
+ listeners = fn;
+ }
+ const hasConnectListener = typeof listeners.connect === 'function';
+ const hasSecureConnectListener = typeof listeners.secureConnect === 'function';
+ const hasCloseListener = typeof listeners.close === 'function';
+ const onConnect = () => {
+ if (hasConnectListener) {
+ listeners.connect();
+ }
+ if (socket instanceof tls_1.TLSSocket && hasSecureConnectListener) {
+ if (socket.authorized) {
+ listeners.secureConnect();
+ }
+ else if (!socket.authorizationError) {
+ socket.once('secureConnect', listeners.secureConnect);
+ }
+ }
+ if (hasCloseListener) {
+ socket.once('close', listeners.close);
+ }
+ };
+ if (socket.writable && !socket.connecting) {
+ onConnect();
+ }
+ else if (socket.connecting) {
+ socket.once('connect', onConnect);
+ }
+ else if (socket.destroyed && hasCloseListener) {
+ listeners.close(socket._hadError);
+ }
+};
+exports.default = deferToConnect;
+// For CommonJS default export support
+module.exports = deferToConnect;
+module.exports.default = deferToConnect;
+
+
/***/ }),
/***/ 796:
@@ -9011,6 +13179,134 @@ exports.getUserAgent = getUserAgent;
//# sourceMappingURL=index.js.map
+/***/ }),
+
+/***/ 811:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const net = __webpack_require__(631);
+const unhandle_1 = __webpack_require__(784);
+const reentry = Symbol('reentry');
+const noop = () => { };
+class TimeoutError extends Error {
+ constructor(threshold, event) {
+ super(`Timeout awaiting '${event}' for ${threshold}ms`);
+ this.event = event;
+ this.name = 'TimeoutError';
+ this.code = 'ETIMEDOUT';
+ }
+}
+exports.TimeoutError = TimeoutError;
+exports.default = (request, delays, options) => {
+ if (reentry in request) {
+ return noop;
+ }
+ request[reentry] = true;
+ const cancelers = [];
+ const { once, unhandleAll } = unhandle_1.default();
+ const addTimeout = (delay, callback, event) => {
+ var _a;
+ const timeout = setTimeout(callback, delay, delay, event);
+ (_a = timeout.unref) === null || _a === void 0 ? void 0 : _a.call(timeout);
+ const cancel = () => {
+ clearTimeout(timeout);
+ };
+ cancelers.push(cancel);
+ return cancel;
+ };
+ const { host, hostname } = options;
+ const timeoutHandler = (delay, event) => {
+ request.destroy(new TimeoutError(delay, event));
+ };
+ const cancelTimeouts = () => {
+ for (const cancel of cancelers) {
+ cancel();
+ }
+ unhandleAll();
+ };
+ request.once('error', error => {
+ cancelTimeouts();
+ // Save original behavior
+ /* istanbul ignore next */
+ if (request.listenerCount('error') === 0) {
+ throw error;
+ }
+ });
+ request.once('close', cancelTimeouts);
+ once(request, 'response', (response) => {
+ once(response, 'end', cancelTimeouts);
+ });
+ if (typeof delays.request !== 'undefined') {
+ addTimeout(delays.request, timeoutHandler, 'request');
+ }
+ if (typeof delays.socket !== 'undefined') {
+ const socketTimeoutHandler = () => {
+ timeoutHandler(delays.socket, 'socket');
+ };
+ request.setTimeout(delays.socket, socketTimeoutHandler);
+ // `request.setTimeout(0)` causes a memory leak.
+ // We can just remove the listener and forget about the timer - it's unreffed.
+ // See https://github.com/sindresorhus/got/issues/690
+ cancelers.push(() => {
+ request.removeListener('timeout', socketTimeoutHandler);
+ });
+ }
+ once(request, 'socket', (socket) => {
+ var _a;
+ const { socketPath } = request;
+ /* istanbul ignore next: hard to test */
+ if (socket.connecting) {
+ const hasPath = Boolean(socketPath !== null && socketPath !== void 0 ? socketPath : net.isIP((_a = hostname !== null && hostname !== void 0 ? hostname : host) !== null && _a !== void 0 ? _a : '') !== 0);
+ if (typeof delays.lookup !== 'undefined' && !hasPath && typeof socket.address().address === 'undefined') {
+ const cancelTimeout = addTimeout(delays.lookup, timeoutHandler, 'lookup');
+ once(socket, 'lookup', cancelTimeout);
+ }
+ if (typeof delays.connect !== 'undefined') {
+ const timeConnect = () => addTimeout(delays.connect, timeoutHandler, 'connect');
+ if (hasPath) {
+ once(socket, 'connect', timeConnect());
+ }
+ else {
+ once(socket, 'lookup', (error) => {
+ if (error === null) {
+ once(socket, 'connect', timeConnect());
+ }
+ });
+ }
+ }
+ if (typeof delays.secureConnect !== 'undefined' && options.protocol === 'https:') {
+ once(socket, 'connect', () => {
+ const cancelTimeout = addTimeout(delays.secureConnect, timeoutHandler, 'secureConnect');
+ once(socket, 'secureConnect', cancelTimeout);
+ });
+ }
+ }
+ if (typeof delays.send !== 'undefined') {
+ const timeRequest = () => addTimeout(delays.send, timeoutHandler, 'send');
+ /* istanbul ignore next: hard to test */
+ if (socket.connecting) {
+ once(socket, 'connect', () => {
+ once(request, 'upload-complete', timeRequest());
+ });
+ }
+ else {
+ once(request, 'upload-complete', timeRequest());
+ }
+ }
+ });
+ if (typeof delays.response !== 'undefined') {
+ once(request, 'upload-complete', () => {
+ const cancelTimeout = addTimeout(delays.response, timeoutHandler, 'response');
+ once(request, 'response', cancelTimeout);
+ });
+ }
+ return cancelTimeouts;
+};
+
+
/***/ }),
/***/ 813:
@@ -9269,6 +13565,13 @@ function sync (path, options) {
}
+/***/ }),
+
+/***/ 819:
+/***/ (function(module) {
+
+module.exports = require("dns");
+
/***/ }),
/***/ 835:
@@ -23461,6 +27764,72 @@ function registerPlugin(plugins, pluginFunction) {
module.exports = __webpack_require__(141);
+/***/ }),
+
+/***/ 861:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+const {Transform, PassThrough} = __webpack_require__(413);
+const zlib = __webpack_require__(761);
+const mimicResponse = __webpack_require__(89);
+
+module.exports = response => {
+ const contentEncoding = (response.headers['content-encoding'] || '').toLowerCase();
+
+ if (!['gzip', 'deflate', 'br'].includes(contentEncoding)) {
+ return response;
+ }
+
+ // TODO: Remove this when targeting Node.js 12.
+ const isBrotli = contentEncoding === 'br';
+ if (isBrotli && typeof zlib.createBrotliDecompress !== 'function') {
+ response.destroy(new Error('Brotli is not supported on Node.js < 12'));
+ return response;
+ }
+
+ let isEmpty = true;
+
+ const checker = new Transform({
+ transform(data, _encoding, callback) {
+ isEmpty = false;
+
+ callback(null, data);
+ },
+
+ flush(callback) {
+ callback();
+ }
+ });
+
+ const finalStream = new PassThrough({
+ autoDestroy: false,
+ destroy(error, callback) {
+ response.destroy();
+
+ callback(error);
+ }
+ });
+
+ const decompressStream = isBrotli ? zlib.createBrotliDecompress() : zlib.createUnzip();
+
+ decompressStream.once('error', error => {
+ if (isEmpty && !response.readable) {
+ finalStream.end();
+ return;
+ }
+
+ finalStream.destroy(error);
+ });
+
+ mimicResponse(response, finalStream);
+ response.pipe(checker).pipe(decompressStream).pipe(finalStream);
+
+ return finalStream;
+};
+
+
/***/ }),
/***/ 863:
@@ -23563,20 +27932,45 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
};
const { context } = __webpack_require__(469);
const core = __webpack_require__(470);
-const isValidCommitMessage = message => message.match(/^[a-z].*:/);
+const get = __webpack_require__(854);
+const got = __webpack_require__(77);
+const isValidCommitMessage = (message) => message.match(/^[a-z].*:/);
+const extractCommits = () => __awaiter(this, void 0, void 0, function* () {
+ // For "push" events, commits can be found in the "context.payload.commits".
+ const pushCommits = Array.isArray(get(context, "payload.commits"));
+ if (pushCommits) {
+ return context.payload.commits;
+ }
+ // For PRs, we need to get a list of commits via the GH API:
+ const prCommitsUrl = typeof get(context, "payload.pull_request.commits_url");
+ if (prCommitsUrl) {
+ try {
+ const { body } = yield got.get(prCommitsUrl, {
+ responseType: "json",
+ });
+ if (Array.isArray(body)) {
+ return body.map((item) => item.commit);
+ }
+ return [];
+ }
+ catch (_a) {
+ return [];
+ }
+ }
+ return [];
+});
function run() {
return __awaiter(this, void 0, void 0, function* () {
core.info(`ℹ️ Checking if commit messages are following the Conventional Commits specification...`);
- console.log('context', JSON.stringify(context, null, 2));
- const hasCommits = context.payload && Array.isArray(context.payload.commits);
- if (!hasCommits) {
+ const extractedCommits = yield extractCommits();
+ if (extractedCommits.length === 0) {
core.info(`No commits to check, skipping...`);
return;
}
let hasErrors;
core.startGroup("Commit messages:");
- for (let i = 0; i < context.payload.commits.length; i++) {
- let commit = context.payload.commits[i];
+ for (let i = 0; i < extractedCommits.length; i++) {
+ let commit = extractedCommits[i];
if (isValidCommitMessage(commit.message)) {
core.info(`✅ ${commit.message}`);
}
@@ -24754,6 +29148,950 @@ exports.withCustomRequest = withCustomRequest;
//# sourceMappingURL=index.js.map
+/***/ }),
+
+/***/ 899:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+const EventEmitter = __webpack_require__(614);
+const tls = __webpack_require__(16);
+const http2 = __webpack_require__(565);
+const QuickLRU = __webpack_require__(290);
+
+const kCurrentStreamsCount = Symbol('currentStreamsCount');
+const kRequest = Symbol('request');
+const kOriginSet = Symbol('cachedOriginSet');
+
+const nameKeys = [
+ // `http2.connect()` options
+ 'maxDeflateDynamicTableSize',
+ 'maxSessionMemory',
+ 'maxHeaderListPairs',
+ 'maxOutstandingPings',
+ 'maxReservedRemoteStreams',
+ 'maxSendHeaderBlockLength',
+ 'paddingStrategy',
+
+ // `tls.connect()` options
+ 'localAddress',
+ 'path',
+ 'rejectUnauthorized',
+ 'minDHSize',
+
+ // `tls.createSecureContext()` options
+ 'ca',
+ 'cert',
+ 'clientCertEngine',
+ 'ciphers',
+ 'key',
+ 'pfx',
+ 'servername',
+ 'minVersion',
+ 'maxVersion',
+ 'secureProtocol',
+ 'crl',
+ 'honorCipherOrder',
+ 'ecdhCurve',
+ 'dhparam',
+ 'secureOptions',
+ 'sessionIdContext'
+];
+
+const removeSession = (where, name, session) => {
+ if (name in where) {
+ const index = where[name].indexOf(session);
+
+ if (index !== -1) {
+ where[name].splice(index, 1);
+
+ if (where[name].length === 0) {
+ delete where[name];
+ }
+
+ return true;
+ }
+ }
+
+ return false;
+};
+
+const addSession = (where, name, session) => {
+ if (name in where) {
+ where[name].push(session);
+ } else {
+ where[name] = [session];
+ }
+};
+
+const getSessions = (where, name, normalizedOrigin) => {
+ if (!(name in where)) {
+ return [];
+ }
+
+ return where[name].filter(session => {
+ return !session.closed && !session.destroyed && session[kOriginSet].includes(normalizedOrigin);
+ });
+};
+
+// See https://tools.ietf.org/html/rfc8336
+const closeCoveredSessions = (where, name, session) => {
+ if (!(name in where)) {
+ return;
+ }
+
+ // Clients SHOULD NOT emit new requests on any connection whose Origin
+ // Set is a proper subset of another connection's Origin Set, and they
+ // SHOULD close it once all outstanding requests are satisfied.
+ for (const coveredSession of where[name]) {
+ if (
+ // The set is a proper subset when its length is less than the other set.
+ coveredSession[kOriginSet].length < session[kOriginSet].length &&
+
+ // And the other set includes all elements of the subset.
+ coveredSession[kOriginSet].every(origin => session[kOriginSet].includes(origin)) &&
+
+ // Makes sure that the session can handle all requests from the covered session.
+ // TODO: can the session become uncovered when a stream is closed after checking this condition?
+ coveredSession[kCurrentStreamsCount] + session[kCurrentStreamsCount] <= session.remoteSettings.maxConcurrentStreams
+ ) {
+ // This allows pending requests to finish and prevents making new requests.
+ coveredSession.close();
+ }
+ }
+};
+
+// This is basically inverted `closeCoveredSessions(...)`.
+const closeSessionIfCovered = (where, name, coveredSession) => {
+ if (!(name in where)) {
+ return;
+ }
+
+ for (const session of where[name]) {
+ if (
+ coveredSession[kOriginSet].length < session[kOriginSet].length &&
+ coveredSession[kOriginSet].every(origin => session[kOriginSet].includes(origin)) &&
+ coveredSession[kCurrentStreamsCount] + session[kCurrentStreamsCount] <= session.remoteSettings.maxConcurrentStreams
+ ) {
+ coveredSession.close();
+ }
+ }
+};
+
+class Agent extends EventEmitter {
+ constructor({timeout = 60000, maxSessions = Infinity, maxFreeSessions = 1, maxCachedTlsSessions = 100} = {}) {
+ super();
+
+ // A session is considered busy when its current streams count
+ // is equal to or greater than the `maxConcurrentStreams` value.
+ this.busySessions = {};
+
+ // A session is considered free when its current streams count
+ // is less than the `maxConcurrentStreams` value.
+ this.freeSessions = {};
+
+ // The queue for creating new sessions. It looks like this:
+ // QUEUE[NORMALIZED_OPTIONS][NORMALIZED_ORIGIN] = ENTRY_FUNCTION
+ //
+ // The entry function has `listeners`, `completed` and `destroyed` properties.
+ // `listeners` is an array of objects containing `resolve` and `reject` functions.
+ // `completed` is a boolean. It's set to true after ENTRY_FUNCTION is executed.
+ // `destroyed` is a boolean. If it's set to true, the session will be destroyed if hasn't connected yet.
+ this.queue = {};
+
+ // Each session will use this timeout value.
+ this.timeout = timeout;
+
+ // Max sessions per origin.
+ this.maxSessions = maxSessions;
+
+ // Max free sessions per origin.
+ // TODO: decreasing `maxFreeSessions` should close some sessions
+ // TODO: should `maxFreeSessions` be related only to sessions with 0 pending streams?
+ this.maxFreeSessions = maxFreeSessions;
+
+ // We don't support push streams by default.
+ this.settings = {
+ enablePush: false
+ };
+
+ // Reusing TLS sessions increases performance.
+ this.tlsSessionCache = new QuickLRU({maxSize: maxCachedTlsSessions});
+ }
+
+ static normalizeOrigin(url, servername) {
+ if (typeof url === 'string') {
+ url = new URL(url);
+ }
+
+ if (servername && url.hostname !== servername) {
+ url.hostname = servername;
+ }
+
+ return url.origin;
+ }
+
+ normalizeOptions(options) {
+ let normalized = '';
+
+ if (options) {
+ for (const key of nameKeys) {
+ if (options[key]) {
+ normalized += `:${options[key]}`;
+ }
+ }
+ }
+
+ return normalized;
+ }
+
+ _tryToCreateNewSession(normalizedOptions, normalizedOrigin) {
+ if (!(normalizedOptions in this.queue) || !(normalizedOrigin in this.queue[normalizedOptions])) {
+ return;
+ }
+
+ // We need the busy sessions length to check if a session can be created.
+ const busyLength = getSessions(this.busySessions, normalizedOptions, normalizedOrigin).length;
+ const item = this.queue[normalizedOptions][normalizedOrigin];
+
+ // The entry function can be run only once.
+ if (busyLength < this.maxSessions && !item.completed) {
+ item.completed = true;
+
+ item();
+ }
+ }
+
+ _closeCoveredSessions(normalizedOptions, session) {
+ closeCoveredSessions(this.freeSessions, normalizedOptions, session);
+ closeCoveredSessions(this.busySessions, normalizedOptions, session);
+ }
+
+ getSession(origin, options, listeners) {
+ return new Promise((resolve, reject) => {
+ if (Array.isArray(listeners)) {
+ listeners = [...listeners];
+
+ // Resolve the current promise ASAP, we're just moving the listeners.
+ // They will be executed at a different time.
+ resolve();
+ } else {
+ listeners = [{resolve, reject}];
+ }
+
+ const normalizedOptions = this.normalizeOptions(options);
+ const normalizedOrigin = Agent.normalizeOrigin(origin, options && options.servername);
+
+ if (normalizedOrigin === undefined) {
+ for (const {reject} of listeners) {
+ reject(new TypeError('The `origin` argument needs to be a string or an URL object'));
+ }
+
+ return;
+ }
+
+ if (normalizedOptions in this.freeSessions) {
+ // Look for all available free sessions.
+ const freeSessions = getSessions(this.freeSessions, normalizedOptions, normalizedOrigin);
+
+ if (freeSessions.length !== 0) {
+ // Use session which has the biggest stream capacity in order to use the smallest number of sessions possible.
+ const session = freeSessions.reduce((previousSession, nextSession) => {
+ if (
+ nextSession.remoteSettings.maxConcurrentStreams >= previousSession.remoteSettings.maxConcurrentStreams &&
+ nextSession[kCurrentStreamsCount] > previousSession[kCurrentStreamsCount]
+ ) {
+ return nextSession;
+ }
+
+ return previousSession;
+ });
+
+ for (const {resolve} of listeners) {
+ // TODO: The session can get busy here
+ resolve(session);
+ }
+
+ return;
+ }
+ }
+
+ if (normalizedOptions in this.queue) {
+ if (normalizedOrigin in this.queue[normalizedOptions]) {
+ // There's already an item in the queue, just attach ourselves to it.
+ this.queue[normalizedOptions][normalizedOrigin].listeners.push(...listeners);
+
+ return;
+ }
+ } else {
+ this.queue[normalizedOptions] = {};
+ }
+
+ // The entry must be removed from the queue IMMEDIATELY when:
+ // 1. the session connects successfully,
+ // 2. an error occurs.
+ const removeFromQueue = () => {
+ // Our entry can be replaced. We cannot remove the new one.
+ if (normalizedOptions in this.queue && this.queue[normalizedOptions][normalizedOrigin] === entry) {
+ delete this.queue[normalizedOptions][normalizedOrigin];
+
+ if (Object.keys(this.queue[normalizedOptions]).length === 0) {
+ delete this.queue[normalizedOptions];
+ }
+ }
+ };
+
+ // The main logic is here
+ const entry = () => {
+ const name = `${normalizedOrigin}:${normalizedOptions}`;
+ let receivedSettings = false;
+ let servername;
+
+ try {
+ const tlsSessionCache = this.tlsSessionCache.get(name);
+
+ const session = http2.connect(origin, {
+ createConnection: this.createConnection,
+ settings: this.settings,
+ session: tlsSessionCache ? tlsSessionCache.session : undefined,
+ ...options
+ });
+ session[kCurrentStreamsCount] = 0;
+
+ // Tries to free the session.
+ const freeSession = () => {
+ // Fetch the smallest amount of free sessions of any origin we have.
+ const freeSessionsCount = session[kOriginSet].reduce((accumulator, origin) => {
+ return Math.min(accumulator, getSessions(this.freeSessions, normalizedOptions, origin).length);
+ }, Infinity);
+
+ // Check the limit.
+ if (freeSessionsCount < this.maxFreeSessions) {
+ addSession(this.freeSessions, normalizedOptions, session);
+
+ return true;
+ }
+
+ return false;
+ };
+
+ const isFree = () => session[kCurrentStreamsCount] < session.remoteSettings.maxConcurrentStreams;
+
+ session.socket.once('session', tlsSession => {
+ // We need to cache the servername due to a bug in OpenSSL.
+ setImmediate(() => {
+ this.tlsSessionCache.set(name, {
+ session: tlsSession,
+ servername
+ });
+ });
+ });
+
+ // OpenSSL bug workaround.
+ // See https://github.com/nodejs/node/issues/28985
+ session.socket.once('secureConnect', () => {
+ servername = session.socket.servername;
+
+ if (servername === false && typeof tlsSessionCache !== 'undefined' && typeof tlsSessionCache.servername !== 'undefined') {
+ session.socket.servername = tlsSessionCache.servername;
+ }
+ });
+
+ session.once('error', error => {
+ // `receivedSettings` is true when the session has successfully connected.
+ if (!receivedSettings) {
+ for (const {reject} of listeners) {
+ reject(error);
+ }
+ }
+
+ // The connection got broken, purge the cache.
+ this.tlsSessionCache.delete(name);
+ });
+
+ session.setTimeout(this.timeout, () => {
+ // Terminates all streams owned by this session.
+ session.destroy();
+ });
+
+ session.once('close', () => {
+ if (!receivedSettings) {
+ // Broken connection
+ const error = new Error('Session closed without receiving a SETTINGS frame');
+
+ for (const {reject} of listeners) {
+ reject(error);
+ }
+ }
+
+ removeFromQueue();
+
+ // This cannot be moved to the stream logic,
+ // because there may be a session that hadn't made a single request.
+ removeSession(this.freeSessions, normalizedOptions, session);
+
+ // There may be another session awaiting.
+ this._tryToCreateNewSession(normalizedOptions, normalizedOrigin);
+ });
+
+ // Iterates over the queue and processes listeners.
+ const processListeners = () => {
+ if (!(normalizedOptions in this.queue)) {
+ return;
+ }
+
+ for (const origin of session[kOriginSet]) {
+ if (origin in this.queue[normalizedOptions]) {
+ const {listeners} = this.queue[normalizedOptions][origin];
+
+ // Prevents session overloading.
+ while (listeners.length !== 0 && isFree()) {
+ // We assume `resolve(...)` calls `request(...)` *directly*,
+ // otherwise the session will get overloaded.
+ listeners.shift().resolve(session);
+ }
+
+ if (this.queue[normalizedOptions][origin].listeners.length === 0) {
+ delete this.queue[normalizedOptions][origin];
+
+ if (Object.keys(this.queue[normalizedOptions]).length === 0) {
+ delete this.queue[normalizedOptions];
+ break;
+ }
+ }
+
+ // We're no longer free, no point in continuing.
+ if (!isFree()) {
+ break;
+ }
+ }
+ }
+ };
+
+ // The Origin Set cannot shrink. No need to check if it suddenly became covered by another one.
+ session.once('origin', () => {
+ session[kOriginSet] = session.originSet;
+
+ if (!isFree()) {
+ // The session is full.
+ return;
+ }
+
+ // Close covered sessions (if possible).
+ this._closeCoveredSessions(normalizedOptions, session);
+
+ processListeners();
+
+ // `session.remoteSettings.maxConcurrentStreams` might get increased
+ session.on('remoteSettings', () => {
+ this._closeCoveredSessions(normalizedOptions, session);
+ });
+ });
+
+ session.once('remoteSettings', () => {
+ // The Agent could have been destroyed already.
+ if (entry.destroyed) {
+ const error = new Error('Agent has been destroyed');
+
+ for (const listener of listeners) {
+ listener.reject(error);
+ }
+
+ session.destroy();
+ return;
+ }
+
+ session[kOriginSet] = session.originSet;
+ this.emit('session', session);
+
+ if (freeSession()) {
+ // Process listeners, we're free.
+ processListeners();
+ } else if (this.maxFreeSessions === 0) {
+ processListeners();
+
+ // We're closing ASAP, when all possible requests have been made for this event loop tick.
+ setImmediate(() => {
+ session.close();
+ });
+ } else {
+ // Too late, another free session took these listeners.
+ session.close();
+ }
+
+ removeFromQueue();
+
+ // Check if we haven't managed to execute all listeners.
+ if (listeners.length !== 0) {
+ // Request for a new session with predefined listeners.
+ this.getSession(normalizedOrigin, options, listeners);
+ listeners.length = 0;
+ }
+
+ receivedSettings = true;
+
+ // `session.remoteSettings.maxConcurrentStreams` might get increased
+ session.on('remoteSettings', () => {
+ // Check if we're eligible to become a free session
+ if (isFree() && removeSession(this.busySessions, normalizedOptions, session)) {
+ // Check for free seats
+ if (freeSession()) {
+ processListeners();
+ } else {
+ // Assume it's still a busy session
+ addSession(this.busySessions, normalizedOptions, session);
+ }
+ }
+ });
+ });
+
+ // Shim `session.request()` in order to catch all streams
+ session[kRequest] = session.request;
+ session.request = headers => {
+ const stream = session[kRequest](headers, {
+ endStream: false
+ });
+
+ // The process won't exit until the session is closed.
+ session.ref();
+
+ ++session[kCurrentStreamsCount];
+
+ // Check if we became busy
+ if (!isFree() && removeSession(this.freeSessions, normalizedOptions, session)) {
+ addSession(this.busySessions, normalizedOptions, session);
+ }
+
+ stream.once('close', () => {
+ --session[kCurrentStreamsCount];
+
+ if (isFree()) {
+ if (session[kCurrentStreamsCount] === 0) {
+ // All requests are finished, the process may exit now.
+ session.unref();
+ }
+
+ // Check if we are no longer busy and the session is not broken.
+ if (removeSession(this.busySessions, normalizedOptions, session) && !session.destroyed && !session.closed) {
+ // Check the sessions count of this authority and compare it to `maxSessionsCount`.
+ if (freeSession()) {
+ this._closeCoveredSessions(normalizedOptions, session);
+ processListeners();
+ } else {
+ session.close();
+ }
+ }
+ }
+
+ if (!session.destroyed && !session.closed) {
+ closeSessionIfCovered(this.freeSessions, normalizedOptions, session);
+ }
+ });
+
+ return stream;
+ };
+ } catch (error) {
+ for (const listener of listeners) {
+ listener.reject(error);
+ }
+
+ removeFromQueue();
+ }
+ };
+
+ entry.listeners = listeners;
+ entry.completed = false;
+ entry.destroyed = false;
+
+ this.queue[normalizedOptions][normalizedOrigin] = entry;
+ this._tryToCreateNewSession(normalizedOptions, normalizedOrigin);
+ });
+ }
+
+ request(origin, options, headers) {
+ return new Promise((resolve, reject) => {
+ this.getSession(origin, options, [{
+ reject,
+ resolve: session => {
+ resolve(session.request(headers));
+ }
+ }]);
+ });
+ }
+
+ createConnection(origin, options) {
+ return Agent.connect(origin, options);
+ }
+
+ static connect(origin, options) {
+ options.ALPNProtocols = ['h2'];
+
+ const port = origin.port || 443;
+ const host = origin.hostname || origin.host;
+
+ if (typeof options.servername === 'undefined') {
+ options.servername = host;
+ }
+
+ return tls.connect(port, host, options);
+ }
+
+ closeFreeSessions() {
+ for (const freeSessions of Object.values(this.freeSessions)) {
+ for (const session of freeSessions) {
+ if (session[kCurrentStreamsCount] === 0) {
+ session.close();
+ }
+ }
+ }
+ }
+
+ destroy(reason) {
+ for (const busySessions of Object.values(this.busySessions)) {
+ for (const session of busySessions) {
+ session.destroy(reason);
+ }
+ }
+
+ for (const freeSessions of Object.values(this.freeSessions)) {
+ for (const session of freeSessions) {
+ session.destroy(reason);
+ }
+ }
+
+ for (const entriesOfAuthority of Object.values(this.queue)) {
+ for (const entry of Object.values(entriesOfAuthority)) {
+ entry.destroyed = true;
+ }
+ }
+
+ // New requests should NOT attach to destroyed sessions
+ this.queue = {};
+ }
+}
+
+module.exports = {
+ Agent,
+ globalAgent: new Agent()
+};
+
+
+/***/ }),
+
+/***/ 903:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const p_cancelable_1 = __webpack_require__(557);
+const is_1 = __webpack_require__(534);
+const as_promise_1 = __webpack_require__(952);
+const create_rejection_1 = __webpack_require__(910);
+const core_1 = __webpack_require__(946);
+const deep_freeze_1 = __webpack_require__(291);
+const errors = {
+ RequestError: as_promise_1.RequestError,
+ CacheError: as_promise_1.CacheError,
+ ReadError: as_promise_1.ReadError,
+ HTTPError: as_promise_1.HTTPError,
+ MaxRedirectsError: as_promise_1.MaxRedirectsError,
+ TimeoutError: as_promise_1.TimeoutError,
+ ParseError: as_promise_1.ParseError,
+ CancelError: p_cancelable_1.CancelError,
+ UnsupportedProtocolError: as_promise_1.UnsupportedProtocolError,
+ UploadError: as_promise_1.UploadError
+};
+const { normalizeArguments, mergeOptions } = as_promise_1.PromisableRequest;
+const getPromiseOrStream = (options) => options.isStream ? new core_1.default(options.url, options) : as_promise_1.default(options);
+const isGotInstance = (value) => ('defaults' in value && 'options' in value.defaults);
+const aliases = [
+ 'get',
+ 'post',
+ 'put',
+ 'patch',
+ 'head',
+ 'delete'
+];
+exports.defaultHandler = (options, next) => next(options);
+const callInitHooks = (hooks, options) => {
+ if (hooks) {
+ for (const hook of hooks) {
+ hook(options);
+ }
+ }
+};
+const create = (defaults) => {
+ // Proxy properties from next handlers
+ defaults._rawHandlers = defaults.handlers;
+ defaults.handlers = defaults.handlers.map(fn => ((options, next) => {
+ // This will be assigned by assigning result
+ let root;
+ const result = fn(options, newOptions => {
+ root = next(newOptions);
+ return root;
+ });
+ if (result !== root && !options.isStream && root) {
+ const typedResult = result;
+ const { then: promiseThen, catch: promiseCatch, finally: promiseFianlly } = typedResult;
+ Object.setPrototypeOf(typedResult, Object.getPrototypeOf(root));
+ Object.defineProperties(typedResult, Object.getOwnPropertyDescriptors(root));
+ // These should point to the new promise
+ // eslint-disable-next-line promise/prefer-await-to-then
+ typedResult.then = promiseThen;
+ typedResult.catch = promiseCatch;
+ typedResult.finally = promiseFianlly;
+ }
+ return result;
+ }));
+ // Got interface
+ const got = ((url, options) => {
+ var _a, _b;
+ let iteration = 0;
+ const iterateHandlers = (newOptions) => {
+ return defaults.handlers[iteration++](newOptions, iteration === defaults.handlers.length ? getPromiseOrStream : iterateHandlers);
+ };
+ if (is_1.default.plainObject(url)) {
+ options = {
+ ...url,
+ ...options
+ };
+ url = undefined;
+ }
+ try {
+ // Call `init` hooks
+ let initHookError;
+ try {
+ callInitHooks(defaults.options.hooks.init, options);
+ callInitHooks((_a = options === null || options === void 0 ? void 0 : options.hooks) === null || _a === void 0 ? void 0 : _a.init, options);
+ }
+ catch (error) {
+ initHookError = error;
+ }
+ // Normalize options & call handlers
+ const normalizedOptions = normalizeArguments(url, options, defaults.options);
+ normalizedOptions[core_1.kIsNormalizedAlready] = true;
+ if (initHookError) {
+ throw new as_promise_1.RequestError(initHookError.message, initHookError, normalizedOptions);
+ }
+ return iterateHandlers(normalizedOptions);
+ }
+ catch (error) {
+ if (options === null || options === void 0 ? void 0 : options.isStream) {
+ throw error;
+ }
+ else {
+ return create_rejection_1.default(error, defaults.options.hooks.beforeError, (_b = options === null || options === void 0 ? void 0 : options.hooks) === null || _b === void 0 ? void 0 : _b.beforeError);
+ }
+ }
+ });
+ got.extend = (...instancesOrOptions) => {
+ const optionsArray = [defaults.options];
+ let handlers = [...defaults._rawHandlers];
+ let isMutableDefaults;
+ for (const value of instancesOrOptions) {
+ if (isGotInstance(value)) {
+ optionsArray.push(value.defaults.options);
+ handlers.push(...value.defaults._rawHandlers);
+ isMutableDefaults = value.defaults.mutableDefaults;
+ }
+ else {
+ optionsArray.push(value);
+ if ('handlers' in value) {
+ handlers.push(...value.handlers);
+ }
+ isMutableDefaults = value.mutableDefaults;
+ }
+ }
+ handlers = handlers.filter(handler => handler !== exports.defaultHandler);
+ if (handlers.length === 0) {
+ handlers.push(exports.defaultHandler);
+ }
+ return create({
+ options: mergeOptions(...optionsArray),
+ handlers,
+ mutableDefaults: Boolean(isMutableDefaults)
+ });
+ };
+ // Pagination
+ const paginateEach = (async function* (url, options) {
+ let normalizedOptions = normalizeArguments(url, options, defaults.options);
+ normalizedOptions.resolveBodyOnly = false;
+ const pagination = normalizedOptions.pagination;
+ if (!is_1.default.object(pagination)) {
+ throw new TypeError('`options.pagination` must be implemented');
+ }
+ const all = [];
+ let { countLimit } = pagination;
+ let numberOfRequests = 0;
+ while (numberOfRequests < pagination.requestLimit) {
+ // TODO: Throw when result is not an instance of Response
+ // eslint-disable-next-line no-await-in-loop
+ const result = (await got('', normalizedOptions));
+ // eslint-disable-next-line no-await-in-loop
+ const parsed = await pagination.transform(result);
+ const current = [];
+ for (const item of parsed) {
+ if (pagination.filter(item, all, current)) {
+ if (!pagination.shouldContinue(item, all, current)) {
+ return;
+ }
+ yield item;
+ if (pagination.stackAllItems) {
+ all.push(item);
+ }
+ current.push(item);
+ if (--countLimit <= 0) {
+ return;
+ }
+ }
+ }
+ const optionsToMerge = pagination.paginate(result, all, current);
+ if (optionsToMerge === false) {
+ return;
+ }
+ if (optionsToMerge === result.request.options) {
+ normalizedOptions = result.request.options;
+ }
+ else if (optionsToMerge !== undefined) {
+ normalizedOptions = normalizeArguments(undefined, optionsToMerge, normalizedOptions);
+ }
+ numberOfRequests++;
+ }
+ });
+ got.paginate = ((url, options) => {
+ return paginateEach(url, options);
+ });
+ got.paginate.all = (async (url, options) => {
+ const results = [];
+ for await (const item of got.paginate(url, options)) {
+ results.push(item);
+ }
+ return results;
+ });
+ // For those who like very descriptive names
+ got.paginate.each = paginateEach;
+ // Stream API
+ got.stream = ((url, options) => got(url, { ...options, isStream: true }));
+ // Shortcuts
+ for (const method of aliases) {
+ got[method] = ((url, options) => got(url, { ...options, method }));
+ got.stream[method] = ((url, options) => {
+ return got(url, { ...options, method, isStream: true });
+ });
+ }
+ Object.assign(got, { ...errors, mergeOptions });
+ Object.defineProperty(got, 'defaults', {
+ value: defaults.mutableDefaults ? defaults : deep_freeze_1.default(defaults),
+ writable: defaults.mutableDefaults,
+ configurable: defaults.mutableDefaults,
+ enumerable: true
+ });
+ return got;
+};
+exports.default = create;
+
+
+/***/ }),
+
+/***/ 907:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+/* istanbul ignore file: deprecated */
+const url_1 = __webpack_require__(835);
+const keys = [
+ 'protocol',
+ 'host',
+ 'hostname',
+ 'port',
+ 'pathname',
+ 'search'
+];
+exports.default = (origin, options) => {
+ var _a, _b;
+ if (options.path) {
+ if (options.pathname) {
+ throw new TypeError('Parameters `path` and `pathname` are mutually exclusive.');
+ }
+ if (options.search) {
+ throw new TypeError('Parameters `path` and `search` are mutually exclusive.');
+ }
+ if (options.searchParams) {
+ throw new TypeError('Parameters `path` and `searchParams` are mutually exclusive.');
+ }
+ }
+ if (options.search && options.searchParams) {
+ throw new TypeError('Parameters `search` and `searchParams` are mutually exclusive.');
+ }
+ if (!origin) {
+ if (!options.protocol) {
+ throw new TypeError('No URL protocol specified');
+ }
+ origin = `${options.protocol}//${(_b = (_a = options.hostname) !== null && _a !== void 0 ? _a : options.host) !== null && _b !== void 0 ? _b : ''}`;
+ }
+ const url = new url_1.URL(origin);
+ if (options.path) {
+ const searchIndex = options.path.indexOf('?');
+ if (searchIndex === -1) {
+ options.pathname = options.path;
+ }
+ else {
+ options.pathname = options.path.slice(0, searchIndex);
+ options.search = options.path.slice(searchIndex + 1);
+ }
+ delete options.path;
+ }
+ for (const key of keys) {
+ if (options[key]) {
+ url[key] = options[key].toString();
+ }
+ }
+ return url;
+};
+
+
+/***/ }),
+
+/***/ 910:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = __webpack_require__(36);
+function createRejection(error, ...beforeErrorGroups) {
+ const promise = (async () => {
+ if (error instanceof types_1.RequestError) {
+ try {
+ for (const hooks of beforeErrorGroups) {
+ if (hooks) {
+ for (const hook of hooks) {
+ // eslint-disable-next-line no-await-in-loop
+ error = await hook(error);
+ }
+ }
+ }
+ }
+ catch (error_) {
+ error = error_;
+ }
+ }
+ throw error;
+ })();
+ const returnPromise = () => promise;
+ promise.json = returnPromise;
+ promise.text = returnPromise;
+ promise.buffer = returnPromise;
+ promise.on = returnPromise;
+ return promise;
+}
+exports.default = createRejection;
+
+
/***/ }),
/***/ 916:
@@ -24792,6 +30130,52 @@ exports.requestLog = requestLog;
//# sourceMappingURL=index.js.map
+/***/ }),
+
+/***/ 927:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = __webpack_require__(36);
+const retryAfterStatusCodes = new Set([413, 429, 503]);
+const isErrorWithResponse = (error) => (error instanceof types_1.HTTPError || error instanceof types_1.ParseError || error instanceof types_1.MaxRedirectsError);
+const calculateRetryDelay = ({ attemptCount, retryOptions, error }) => {
+ if (attemptCount > retryOptions.limit) {
+ return 0;
+ }
+ const hasMethod = retryOptions.methods.includes(error.options.method);
+ const hasErrorCode = retryOptions.errorCodes.includes(error.code);
+ const hasStatusCode = isErrorWithResponse(error) && retryOptions.statusCodes.includes(error.response.statusCode);
+ if (!hasMethod || (!hasErrorCode && !hasStatusCode)) {
+ return 0;
+ }
+ if (isErrorWithResponse(error)) {
+ const { response } = error;
+ if (response && 'retry-after' in response.headers && retryAfterStatusCodes.has(response.statusCode)) {
+ let after = Number(response.headers['retry-after']);
+ if (Number.isNaN(after)) {
+ after = Date.parse(response.headers['retry-after']) - Date.now();
+ }
+ else {
+ after *= 1000;
+ }
+ if (retryOptions.maxRetryAfter === undefined || after > retryOptions.maxRetryAfter) {
+ return 0;
+ }
+ return after;
+ }
+ if (response.statusCode === 413) {
+ return 0;
+ }
+ }
+ const noise = Math.random() * 100;
+ return ((2 ** (attemptCount - 1)) * 1000) + noise;
+};
+exports.default = calculateRetryDelay;
+
+
/***/ }),
/***/ 929:
@@ -24808,6 +30192,1223 @@ function hasNextPage (link) {
}
+/***/ }),
+
+/***/ 946:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __webpack_require__(669);
+const stream_1 = __webpack_require__(413);
+const fs_1 = __webpack_require__(747);
+const url_1 = __webpack_require__(835);
+const http = __webpack_require__(605);
+const http_1 = __webpack_require__(605);
+const https = __webpack_require__(211);
+const http_timer_1 = __webpack_require__(490);
+const cacheable_lookup_1 = __webpack_require__(570);
+const CacheableRequest = __webpack_require__(390);
+const decompressResponse = __webpack_require__(861);
+// @ts-ignore Missing types
+const http2wrapper = __webpack_require__(157);
+const lowercaseKeys = __webpack_require__(474);
+const getStream = __webpack_require__(145);
+const is_1 = __webpack_require__(534);
+const get_body_size_1 = __webpack_require__(786);
+const is_form_data_1 = __webpack_require__(460);
+const proxy_events_1 = __webpack_require__(628);
+const timed_out_1 = __webpack_require__(811);
+const url_to_options_1 = __webpack_require__(10);
+const options_to_url_1 = __webpack_require__(907);
+const weakable_map_1 = __webpack_require__(48);
+const dns_ip_version_1 = __webpack_require__(738);
+const deprecation_warning_1 = __webpack_require__(189);
+const kRequest = Symbol('request');
+const kResponse = Symbol('response');
+const kResponseSize = Symbol('responseSize');
+const kDownloadedSize = Symbol('downloadedSize');
+const kBodySize = Symbol('bodySize');
+const kUploadedSize = Symbol('uploadedSize');
+const kServerResponsesPiped = Symbol('serverResponsesPiped');
+const kUnproxyEvents = Symbol('unproxyEvents');
+const kIsFromCache = Symbol('isFromCache');
+const kCancelTimeouts = Symbol('cancelTimeouts');
+const kStartedReading = Symbol('startedReading');
+const kStopReading = Symbol('stopReading');
+const kTriggerRead = Symbol('triggerRead');
+const kBody = Symbol('body');
+const kJobs = Symbol('jobs');
+const kOriginalResponse = Symbol('originalResponse');
+exports.kIsNormalizedAlready = Symbol('isNormalizedAlready');
+const supportsBrotli = is_1.default.string(process.versions.brotli);
+exports.withoutBody = new Set(['GET', 'HEAD']);
+exports.knownHookEvents = ['init', 'beforeRequest', 'beforeRedirect', 'beforeError'];
+function validateSearchParameters(searchParameters) {
+ // eslint-disable-next-line guard-for-in
+ for (const key in searchParameters) {
+ const value = searchParameters[key];
+ if (!is_1.default.string(value) && !is_1.default.number(value) && !is_1.default.boolean(value) && !is_1.default.null_(value)) {
+ throw new TypeError(`The \`searchParams\` value '${String(value)}' must be a string, number, boolean or null`);
+ }
+ }
+}
+function isClientRequest(clientRequest) {
+ return is_1.default.object(clientRequest) && !('statusCode' in clientRequest);
+}
+const cacheableStore = new weakable_map_1.default();
+const waitForOpenFile = async (file) => new Promise((resolve, reject) => {
+ const onError = (error) => {
+ reject(error);
+ };
+ if (!file.pending) {
+ resolve();
+ }
+ file.once('error', onError);
+ file.once('ready', () => {
+ file.off('error', onError);
+ resolve();
+ });
+});
+const redirectCodes = new Set([300, 301, 302, 303, 304, 307, 308]);
+const nonEnumerableProperties = [
+ 'context',
+ 'body',
+ 'json',
+ 'form'
+];
+const setNonEnumerableProperties = (sources, to) => {
+ // Non enumerable properties shall not be merged
+ const properties = {};
+ for (const source of sources) {
+ if (!source) {
+ continue;
+ }
+ for (const name of nonEnumerableProperties) {
+ if (!(name in source)) {
+ continue;
+ }
+ properties[name] = {
+ writable: true,
+ configurable: true,
+ enumerable: false,
+ // @ts-ignore TS doesn't see the check above
+ value: source[name]
+ };
+ }
+ }
+ Object.defineProperties(to, properties);
+};
+class RequestError extends Error {
+ constructor(message, error, self) {
+ var _a;
+ super(message);
+ Error.captureStackTrace(this, this.constructor);
+ this.name = 'RequestError';
+ this.code = error.code;
+ if (self instanceof Request) {
+ Object.defineProperty(this, 'request', {
+ enumerable: false,
+ value: self
+ });
+ Object.defineProperty(this, 'response', {
+ enumerable: false,
+ value: self[kResponse]
+ });
+ Object.defineProperty(this, 'options', {
+ // This fails because of TS 3.7.2 useDefineForClassFields
+ // Ref: https://github.com/microsoft/TypeScript/issues/34972
+ enumerable: false,
+ value: self.options
+ });
+ }
+ else {
+ Object.defineProperty(this, 'options', {
+ // This fails because of TS 3.7.2 useDefineForClassFields
+ // Ref: https://github.com/microsoft/TypeScript/issues/34972
+ enumerable: false,
+ value: self
+ });
+ }
+ this.timings = (_a = this.request) === null || _a === void 0 ? void 0 : _a.timings;
+ // Recover the original stacktrace
+ if (!is_1.default.undefined(error.stack)) {
+ const indexOfMessage = this.stack.indexOf(this.message) + this.message.length;
+ const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').reverse();
+ const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message) + error.message.length).split('\n').reverse();
+ // Remove duplicated traces
+ while (errorStackTrace.length !== 0 && errorStackTrace[0] === thisStackTrace[0]) {
+ thisStackTrace.shift();
+ }
+ this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.reverse().join('\n')}${errorStackTrace.reverse().join('\n')}`;
+ }
+ }
+}
+exports.RequestError = RequestError;
+class MaxRedirectsError extends RequestError {
+ constructor(request) {
+ super(`Redirected ${request.options.maxRedirects} times. Aborting.`, {}, request);
+ this.name = 'MaxRedirectsError';
+ }
+}
+exports.MaxRedirectsError = MaxRedirectsError;
+class HTTPError extends RequestError {
+ constructor(response) {
+ super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, response.request);
+ this.name = 'HTTPError';
+ }
+}
+exports.HTTPError = HTTPError;
+class CacheError extends RequestError {
+ constructor(error, request) {
+ super(error.message, error, request);
+ this.name = 'CacheError';
+ }
+}
+exports.CacheError = CacheError;
+class UploadError extends RequestError {
+ constructor(error, request) {
+ super(error.message, error, request);
+ this.name = 'UploadError';
+ }
+}
+exports.UploadError = UploadError;
+class TimeoutError extends RequestError {
+ constructor(error, timings, request) {
+ super(error.message, error, request);
+ this.name = 'TimeoutError';
+ this.event = error.event;
+ this.timings = timings;
+ }
+}
+exports.TimeoutError = TimeoutError;
+class ReadError extends RequestError {
+ constructor(error, request) {
+ super(error.message, error, request);
+ this.name = 'ReadError';
+ }
+}
+exports.ReadError = ReadError;
+class UnsupportedProtocolError extends RequestError {
+ constructor(options) {
+ super(`Unsupported protocol "${options.url.protocol}"`, {}, options);
+ this.name = 'UnsupportedProtocolError';
+ }
+}
+exports.UnsupportedProtocolError = UnsupportedProtocolError;
+const proxiedRequestEvents = [
+ 'socket',
+ 'connect',
+ 'continue',
+ 'information',
+ 'upgrade',
+ 'timeout'
+];
+class Request extends stream_1.Duplex {
+ constructor(url, options = {}, defaults) {
+ super({
+ // It needs to be zero because we're just proxying the data to another stream
+ highWaterMark: 0
+ });
+ this[kDownloadedSize] = 0;
+ this[kUploadedSize] = 0;
+ this.requestInitialized = false;
+ this[kServerResponsesPiped] = new Set();
+ this.redirects = [];
+ this[kStopReading] = false;
+ this[kTriggerRead] = false;
+ this[kJobs] = [];
+ // TODO: Remove this when targeting Node.js >= 12
+ this._progressCallbacks = [];
+ const unlockWrite = () => this._unlockWrite();
+ const lockWrite = () => this._lockWrite();
+ this.on('pipe', (source) => {
+ source.prependListener('data', unlockWrite);
+ source.on('data', lockWrite);
+ source.prependListener('end', unlockWrite);
+ source.on('end', lockWrite);
+ });
+ this.on('unpipe', (source) => {
+ source.off('data', unlockWrite);
+ source.off('data', lockWrite);
+ source.off('end', unlockWrite);
+ source.off('end', lockWrite);
+ });
+ this.on('pipe', source => {
+ if (source instanceof http_1.IncomingMessage) {
+ this.options.headers = {
+ ...source.headers,
+ ...this.options.headers
+ };
+ }
+ });
+ const { json, body, form } = options;
+ if (json || body || form) {
+ this._lockWrite();
+ }
+ (async (nonNormalizedOptions) => {
+ var _a;
+ try {
+ if (nonNormalizedOptions.body instanceof fs_1.ReadStream) {
+ await waitForOpenFile(nonNormalizedOptions.body);
+ }
+ if (exports.kIsNormalizedAlready in nonNormalizedOptions) {
+ this.options = nonNormalizedOptions;
+ }
+ else {
+ // @ts-ignore Common TypeScript bug saying that `this.constructor` is not accessible
+ this.options = this.constructor.normalizeArguments(url, nonNormalizedOptions, defaults);
+ }
+ const { url: normalizedURL } = this.options;
+ if (!normalizedURL) {
+ throw new TypeError('Missing `url` property');
+ }
+ this.requestUrl = normalizedURL.toString();
+ decodeURI(this.requestUrl);
+ await this._finalizeBody();
+ await this._makeRequest();
+ if (this.destroyed) {
+ (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.destroy();
+ return;
+ }
+ // Queued writes etc.
+ for (const job of this[kJobs]) {
+ job();
+ }
+ this.requestInitialized = true;
+ }
+ catch (error) {
+ if (error instanceof RequestError) {
+ this._beforeError(error);
+ return;
+ }
+ // This is a workaround for https://github.com/nodejs/node/issues/33335
+ if (!this.destroyed) {
+ this.destroy(error);
+ }
+ }
+ })(options);
+ }
+ static normalizeArguments(url, options, defaults) {
+ var _a, _b, _c, _d;
+ const rawOptions = options;
+ if (is_1.default.object(url) && !is_1.default.urlInstance(url)) {
+ options = { ...defaults, ...url, ...options };
+ }
+ else {
+ if (url && options && options.url) {
+ throw new TypeError('The `url` option is mutually exclusive with the `input` argument');
+ }
+ options = { ...defaults, ...options };
+ if (url) {
+ options.url = url;
+ }
+ if (is_1.default.urlInstance(options.url)) {
+ options.url = new url_1.URL(options.url.toString());
+ }
+ }
+ // TODO: Deprecate URL options in Got 12.
+ // Support extend-specific options
+ if (options.cache === false) {
+ options.cache = undefined;
+ }
+ if (options.dnsCache === false) {
+ options.dnsCache = undefined;
+ }
+ // Nice type assertions
+ is_1.assert.any([is_1.default.string, is_1.default.undefined], options.method);
+ is_1.assert.any([is_1.default.object, is_1.default.undefined], options.headers);
+ is_1.assert.any([is_1.default.string, is_1.default.urlInstance, is_1.default.undefined], options.prefixUrl);
+ is_1.assert.any([is_1.default.object, is_1.default.undefined], options.cookieJar);
+ is_1.assert.any([is_1.default.object, is_1.default.string, is_1.default.undefined], options.searchParams);
+ is_1.assert.any([is_1.default.object, is_1.default.string, is_1.default.undefined], options.cache);
+ is_1.assert.any([is_1.default.object, is_1.default.number, is_1.default.undefined], options.timeout);
+ is_1.assert.any([is_1.default.object, is_1.default.undefined], options.context);
+ is_1.assert.any([is_1.default.object, is_1.default.undefined], options.hooks);
+ is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.decompress);
+ is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.ignoreInvalidCookies);
+ is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.followRedirect);
+ is_1.assert.any([is_1.default.number, is_1.default.undefined], options.maxRedirects);
+ is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.throwHttpErrors);
+ is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.http2);
+ is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.allowGetBody);
+ is_1.assert.any([is_1.default.string, is_1.default.undefined], options.localAddress);
+ is_1.assert.any([dns_ip_version_1.isDnsLookupIpVersion, is_1.default.undefined], options.dnsLookupIpVersion);
+ is_1.assert.any([is_1.default.object, is_1.default.undefined], options.https);
+ is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.rejectUnauthorized);
+ if (options.https) {
+ is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.https.rejectUnauthorized);
+ is_1.assert.any([is_1.default.function_, is_1.default.undefined], options.https.checkServerIdentity);
+ is_1.assert.any([is_1.default.string, is_1.default.object, is_1.default.array, is_1.default.undefined], options.https.certificateAuthority);
+ is_1.assert.any([is_1.default.string, is_1.default.object, is_1.default.array, is_1.default.undefined], options.https.key);
+ is_1.assert.any([is_1.default.string, is_1.default.object, is_1.default.array, is_1.default.undefined], options.https.certificate);
+ is_1.assert.any([is_1.default.string, is_1.default.undefined], options.https.passphrase);
+ }
+ // `options.method`
+ if (is_1.default.string(options.method)) {
+ options.method = options.method.toUpperCase();
+ }
+ else {
+ options.method = 'GET';
+ }
+ // `options.headers`
+ if (options.headers === (defaults === null || defaults === void 0 ? void 0 : defaults.headers)) {
+ options.headers = { ...options.headers };
+ }
+ else {
+ options.headers = lowercaseKeys({ ...(defaults === null || defaults === void 0 ? void 0 : defaults.headers), ...options.headers });
+ }
+ // Disallow legacy `url.Url`
+ if ('slashes' in options) {
+ throw new TypeError('The legacy `url.Url` has been deprecated. Use `URL` instead.');
+ }
+ // `options.auth`
+ if ('auth' in options) {
+ throw new TypeError('Parameter `auth` is deprecated. Use `username` / `password` instead.');
+ }
+ // `options.searchParams`
+ if ('searchParams' in options) {
+ if (options.searchParams && options.searchParams !== (defaults === null || defaults === void 0 ? void 0 : defaults.searchParams)) {
+ if (!is_1.default.string(options.searchParams) && !(options.searchParams instanceof url_1.URLSearchParams)) {
+ validateSearchParameters(options.searchParams);
+ }
+ const searchParameters = new url_1.URLSearchParams(options.searchParams);
+ // `normalizeArguments()` is also used to merge options
+ (_a = defaults === null || defaults === void 0 ? void 0 : defaults.searchParams) === null || _a === void 0 ? void 0 : _a.forEach((value, key) => {
+ // Only use default if one isn't already defined
+ if (!searchParameters.has(key)) {
+ searchParameters.append(key, value);
+ }
+ });
+ options.searchParams = searchParameters;
+ }
+ }
+ // `options.username` & `options.password`
+ options.username = (_b = options.username) !== null && _b !== void 0 ? _b : '';
+ options.password = (_c = options.password) !== null && _c !== void 0 ? _c : '';
+ // `options.prefixUrl` & `options.url`
+ if (options.prefixUrl) {
+ options.prefixUrl = options.prefixUrl.toString();
+ if (options.prefixUrl !== '' && !options.prefixUrl.endsWith('/')) {
+ options.prefixUrl += '/';
+ }
+ }
+ else {
+ options.prefixUrl = '';
+ }
+ if (is_1.default.string(options.url)) {
+ if (options.url.startsWith('/')) {
+ throw new Error('`input` must not start with a slash when using `prefixUrl`');
+ }
+ options.url = options_to_url_1.default(options.prefixUrl + options.url, options);
+ }
+ else if ((is_1.default.undefined(options.url) && options.prefixUrl !== '') || options.protocol) {
+ options.url = options_to_url_1.default(options.prefixUrl, options);
+ }
+ if (options.url) {
+ // Make it possible to change `options.prefixUrl`
+ let { prefixUrl } = options;
+ Object.defineProperty(options, 'prefixUrl', {
+ set: (value) => {
+ const url = options.url;
+ if (!url.href.startsWith(value)) {
+ throw new Error(`Cannot change \`prefixUrl\` from ${prefixUrl} to ${value}: ${url.href}`);
+ }
+ options.url = new url_1.URL(value + url.href.slice(prefixUrl.length));
+ prefixUrl = value;
+ },
+ get: () => prefixUrl
+ });
+ // Support UNIX sockets
+ let { protocol } = options.url;
+ if (protocol === 'unix:') {
+ protocol = 'http:';
+ options.url = new url_1.URL(`http://unix${options.url.pathname}${options.url.search}`);
+ }
+ // Set search params
+ if (options.searchParams) {
+ options.url.search = options.searchParams.toString();
+ }
+ // Protocol check
+ if (protocol !== 'http:' && protocol !== 'https:') {
+ throw new UnsupportedProtocolError(options);
+ }
+ // Update `username`
+ if (options.username === '') {
+ options.username = options.url.username;
+ }
+ else {
+ options.url.username = options.username;
+ }
+ // Update `password`
+ if (options.password === '') {
+ options.password = options.url.password;
+ }
+ else {
+ options.url.password = options.password;
+ }
+ }
+ // `options.cookieJar`
+ const { cookieJar } = options;
+ if (cookieJar) {
+ let { setCookie, getCookieString } = cookieJar;
+ is_1.assert.function_(setCookie);
+ is_1.assert.function_(getCookieString);
+ /* istanbul ignore next: Horrible `tough-cookie` v3 check */
+ if (setCookie.length === 4 && getCookieString.length === 0) {
+ setCookie = util_1.promisify(setCookie.bind(options.cookieJar));
+ getCookieString = util_1.promisify(getCookieString.bind(options.cookieJar));
+ options.cookieJar = {
+ setCookie,
+ getCookieString
+ };
+ }
+ }
+ // `options.cache`
+ const { cache } = options;
+ if (cache) {
+ if (!cacheableStore.has(cache)) {
+ cacheableStore.set(cache, new CacheableRequest(((requestOptions, handler) => requestOptions[kRequest](requestOptions, handler)), cache));
+ }
+ }
+ // `options.dnsCache`
+ if (options.dnsCache === true) {
+ options.dnsCache = new cacheable_lookup_1.default();
+ }
+ else if (!is_1.default.undefined(options.dnsCache) && !options.dnsCache.lookup) {
+ throw new TypeError(`Parameter \`dnsCache\` must be a CacheableLookup instance or a boolean, got ${is_1.default(options.dnsCache)}`);
+ }
+ // `options.timeout`
+ if (is_1.default.number(options.timeout)) {
+ options.timeout = { request: options.timeout };
+ }
+ else if (defaults && options.timeout !== defaults.timeout) {
+ options.timeout = {
+ ...defaults.timeout,
+ ...options.timeout
+ };
+ }
+ else {
+ options.timeout = { ...options.timeout };
+ }
+ // `options.context`
+ if (!options.context) {
+ options.context = {};
+ }
+ // `options.hooks`
+ const areHooksDefault = options.hooks === (defaults === null || defaults === void 0 ? void 0 : defaults.hooks);
+ options.hooks = { ...options.hooks };
+ for (const event of exports.knownHookEvents) {
+ if (event in options.hooks) {
+ if (is_1.default.array(options.hooks[event])) {
+ // See https://github.com/microsoft/TypeScript/issues/31445#issuecomment-576929044
+ options.hooks[event] = [...options.hooks[event]];
+ }
+ else {
+ throw new TypeError(`Parameter \`${event}\` must be an Array, got ${is_1.default(options.hooks[event])}`);
+ }
+ }
+ else {
+ options.hooks[event] = [];
+ }
+ }
+ if (defaults && !areHooksDefault) {
+ for (const event of exports.knownHookEvents) {
+ const defaultHooks = defaults.hooks[event];
+ if (defaultHooks.length !== 0) {
+ // See https://github.com/microsoft/TypeScript/issues/31445#issuecomment-576929044
+ options.hooks[event] = [
+ ...defaults.hooks[event],
+ ...options.hooks[event]
+ ];
+ }
+ }
+ }
+ // DNS options
+ if ('family' in options) {
+ deprecation_warning_1.default('"options.family" was never documented, please use "options.dnsLookupIpVersion"');
+ }
+ // HTTPS options
+ if (defaults === null || defaults === void 0 ? void 0 : defaults.https) {
+ options.https = { ...defaults.https, ...options.https };
+ }
+ if ('rejectUnauthorized' in options) {
+ deprecation_warning_1.default('"options.rejectUnauthorized" is now deprecated, please use "options.https.rejectUnauthorized"');
+ }
+ if ('checkServerIdentity' in options) {
+ deprecation_warning_1.default('"options.checkServerIdentity" was never documented, please use "options.https.checkServerIdentity"');
+ }
+ if ('ca' in options) {
+ deprecation_warning_1.default('"options.ca" was never documented, please use "options.https.certificateAuthority"');
+ }
+ if ('key' in options) {
+ deprecation_warning_1.default('"options.key" was never documented, please use "options.https.key"');
+ }
+ if ('cert' in options) {
+ deprecation_warning_1.default('"options.cert" was never documented, please use "options.https.certificate"');
+ }
+ if ('passphrase' in options) {
+ deprecation_warning_1.default('"options.passphrase" was never documented, please use "options.https.passphrase"');
+ }
+ // Other options
+ if ('followRedirects' in options) {
+ throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.');
+ }
+ if (options.agent) {
+ for (const key in options.agent) {
+ if (key !== 'http' && key !== 'https' && key !== 'http2') {
+ throw new TypeError(`Expected the \`options.agent\` properties to be \`http\`, \`https\` or \`http2\`, got \`${key}\``);
+ }
+ }
+ }
+ options.maxRedirects = (_d = options.maxRedirects) !== null && _d !== void 0 ? _d : 0;
+ // Set non-enumerable properties
+ setNonEnumerableProperties([defaults, rawOptions], options);
+ return options;
+ }
+ _lockWrite() {
+ const onLockedWrite = () => {
+ throw new TypeError('The payload has been already provided');
+ };
+ this.write = onLockedWrite;
+ this.end = onLockedWrite;
+ }
+ _unlockWrite() {
+ this.write = super.write;
+ this.end = super.end;
+ }
+ async _finalizeBody() {
+ const { options } = this;
+ const { headers } = options;
+ const isForm = !is_1.default.undefined(options.form);
+ const isJSON = !is_1.default.undefined(options.json);
+ const isBody = !is_1.default.undefined(options.body);
+ const hasPayload = isForm || isJSON || isBody;
+ const cannotHaveBody = exports.withoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody);
+ this._cannotHaveBody = cannotHaveBody;
+ if (hasPayload) {
+ if (cannotHaveBody) {
+ throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
+ }
+ if ([isBody, isForm, isJSON].filter(isTrue => isTrue).length > 1) {
+ throw new TypeError('The `body`, `json` and `form` options are mutually exclusive');
+ }
+ if (isBody &&
+ !(options.body instanceof stream_1.Readable) &&
+ !is_1.default.string(options.body) &&
+ !is_1.default.buffer(options.body) &&
+ !is_form_data_1.default(options.body)) {
+ throw new TypeError('The `body` option must be a stream.Readable, string or Buffer');
+ }
+ if (isForm && !is_1.default.object(options.form)) {
+ throw new TypeError('The `form` option must be an Object');
+ }
+ {
+ // Serialize body
+ const noContentType = !is_1.default.string(headers['content-type']);
+ if (isBody) {
+ // Special case for https://github.com/form-data/form-data
+ if (is_form_data_1.default(options.body) && noContentType) {
+ headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
+ }
+ this[kBody] = options.body;
+ }
+ else if (isForm) {
+ if (noContentType) {
+ headers['content-type'] = 'application/x-www-form-urlencoded';
+ }
+ this[kBody] = (new url_1.URLSearchParams(options.form)).toString();
+ }
+ else {
+ if (noContentType) {
+ headers['content-type'] = 'application/json';
+ }
+ this[kBody] = options.stringifyJson(options.json);
+ }
+ const uploadBodySize = await get_body_size_1.default(this[kBody], options.headers);
+ // See 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. For example, a Content-Length header
+ // field is normally sent in a POST request even when the value is 0
+ // (indicating an empty payload body). 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.
+ if (is_1.default.undefined(headers['content-length']) && is_1.default.undefined(headers['transfer-encoding'])) {
+ if (!cannotHaveBody && !is_1.default.undefined(uploadBodySize)) {
+ headers['content-length'] = String(uploadBodySize);
+ }
+ }
+ }
+ }
+ else if (cannotHaveBody) {
+ this._lockWrite();
+ }
+ else {
+ this._unlockWrite();
+ }
+ this[kBodySize] = Number(headers['content-length']) || undefined;
+ }
+ async _onResponse(response) {
+ const { options } = this;
+ const { url } = options;
+ this[kOriginalResponse] = response;
+ if (options.decompress) {
+ response = decompressResponse(response);
+ }
+ const statusCode = response.statusCode;
+ const typedResponse = response;
+ typedResponse.statusMessage = typedResponse.statusMessage ? typedResponse.statusMessage : http.STATUS_CODES[statusCode];
+ typedResponse.url = options.url.toString();
+ typedResponse.requestUrl = this.requestUrl;
+ typedResponse.redirectUrls = this.redirects;
+ typedResponse.request = this;
+ typedResponse.isFromCache = response.fromCache || false;
+ typedResponse.ip = this.ip;
+ this[kIsFromCache] = typedResponse.isFromCache;
+ this[kResponseSize] = Number(response.headers['content-length']) || undefined;
+ this[kResponse] = response;
+ response.once('end', () => {
+ this[kResponseSize] = this[kDownloadedSize];
+ this.emit('downloadProgress', this.downloadProgress);
+ });
+ response.once('error', (error) => {
+ // Force clean-up, because some packages don't do this.
+ // TODO: Fix decompress-response
+ response.destroy();
+ this._beforeError(new ReadError(error, this));
+ });
+ response.once('aborted', () => {
+ this._beforeError(new ReadError({
+ name: 'Error',
+ message: 'The server aborted the pending request'
+ }, this));
+ });
+ this.emit('downloadProgress', this.downloadProgress);
+ const rawCookies = response.headers['set-cookie'];
+ if (is_1.default.object(options.cookieJar) && rawCookies) {
+ let promises = rawCookies.map(async (rawCookie) => options.cookieJar.setCookie(rawCookie, url.toString()));
+ if (options.ignoreInvalidCookies) {
+ promises = promises.map(async (p) => p.catch(() => { }));
+ }
+ try {
+ await Promise.all(promises);
+ }
+ catch (error) {
+ this._beforeError(error);
+ return;
+ }
+ }
+ if (options.followRedirect && response.headers.location && redirectCodes.has(statusCode)) {
+ // We're being redirected, we don't care about the response.
+ // It'd be besto to abort the request, but we can't because
+ // we would have to sacrifice the TCP connection. We don't want that.
+ response.resume();
+ if (this[kRequest]) {
+ this[kCancelTimeouts]();
+ // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+ delete this[kRequest];
+ this[kUnproxyEvents]();
+ }
+ const shouldBeGet = statusCode === 303 && options.method !== 'GET' && options.method !== 'HEAD';
+ if (shouldBeGet || !options.methodRewriting) {
+ // Server responded with "see other", indicating that the resource exists at another location,
+ // and the client should request it from that location via GET or HEAD.
+ options.method = 'GET';
+ if ('body' in options) {
+ delete options.body;
+ }
+ if ('json' in options) {
+ delete options.json;
+ }
+ if ('form' in options) {
+ delete options.form;
+ }
+ }
+ if (this.redirects.length >= options.maxRedirects) {
+ this._beforeError(new MaxRedirectsError(this));
+ return;
+ }
+ try {
+ // Do not remove. See https://github.com/sindresorhus/got/pull/214
+ const redirectBuffer = Buffer.from(response.headers.location, 'binary').toString();
+ // Handles invalid URLs. See https://github.com/sindresorhus/got/issues/604
+ const redirectUrl = new url_1.URL(redirectBuffer, url);
+ const redirectString = redirectUrl.toString();
+ decodeURI(redirectString);
+ // Redirecting to a different site, clear sensitive data.
+ if (redirectUrl.hostname !== url.hostname) {
+ if ('host' in options.headers) {
+ delete options.headers.host;
+ }
+ if ('cookie' in options.headers) {
+ delete options.headers.cookie;
+ }
+ if ('authorization' in options.headers) {
+ delete options.headers.authorization;
+ }
+ if (options.username || options.password) {
+ delete options.username;
+ delete options.password;
+ }
+ }
+ this.redirects.push(redirectString);
+ options.url = redirectUrl;
+ for (const hook of options.hooks.beforeRedirect) {
+ // eslint-disable-next-line no-await-in-loop
+ await hook(options, typedResponse);
+ }
+ this.emit('redirect', typedResponse, options);
+ await this._makeRequest();
+ }
+ catch (error) {
+ this._beforeError(error);
+ return;
+ }
+ return;
+ }
+ const limitStatusCode = options.followRedirect ? 299 : 399;
+ const isOk = (statusCode >= 200 && statusCode <= limitStatusCode) || statusCode === 304;
+ if (options.throwHttpErrors && !isOk) {
+ await this._beforeError(new HTTPError(typedResponse));
+ if (this.destroyed) {
+ return;
+ }
+ }
+ response.on('readable', () => {
+ if (this[kTriggerRead]) {
+ this._read();
+ }
+ });
+ this.on('resume', () => {
+ response.resume();
+ });
+ this.on('pause', () => {
+ response.pause();
+ });
+ response.once('end', () => {
+ this.push(null);
+ });
+ this.emit('response', response);
+ for (const destination of this[kServerResponsesPiped]) {
+ if (destination.headersSent) {
+ continue;
+ }
+ // eslint-disable-next-line guard-for-in
+ for (const key in response.headers) {
+ const isAllowed = options.decompress ? key !== 'content-encoding' : true;
+ const value = response.headers[key];
+ if (isAllowed) {
+ destination.setHeader(key, value);
+ }
+ }
+ destination.statusCode = statusCode;
+ }
+ }
+ _onRequest(request) {
+ const { options } = this;
+ const { timeout, url } = options;
+ http_timer_1.default(request);
+ this[kCancelTimeouts] = timed_out_1.default(request, timeout, url);
+ const responseEventName = options.cache ? 'cacheableResponse' : 'response';
+ request.once(responseEventName, (response) => {
+ this._onResponse(response);
+ });
+ request.once('error', (error) => {
+ // Force clean-up, because some packages (e.g. nock) don't do this.
+ request.destroy();
+ if (error instanceof timed_out_1.TimeoutError) {
+ error = new TimeoutError(error, this.timings, this);
+ }
+ else {
+ error = new RequestError(error.message, error, this);
+ }
+ this._beforeError(error);
+ });
+ this[kUnproxyEvents] = proxy_events_1.default(request, this, proxiedRequestEvents);
+ this[kRequest] = request;
+ this.emit('uploadProgress', this.uploadProgress);
+ // Send body
+ const body = this[kBody];
+ const currentRequest = this.redirects.length === 0 ? this : request;
+ if (is_1.default.nodeStream(body)) {
+ body.pipe(currentRequest);
+ body.once('error', (error) => {
+ this._beforeError(new UploadError(error, this));
+ });
+ body.once('end', () => {
+ delete options.body;
+ });
+ }
+ else {
+ this._unlockWrite();
+ if (!is_1.default.undefined(body)) {
+ this._writeRequest(body, null, () => { });
+ currentRequest.end();
+ this._lockWrite();
+ }
+ else if (this._cannotHaveBody || this._noPipe) {
+ currentRequest.end();
+ this._lockWrite();
+ }
+ }
+ this.emit('request', request);
+ }
+ async _createCacheableRequest(url, options) {
+ return new Promise((resolve, reject) => {
+ // TODO: Remove `utils/url-to-options.ts` when `cacheable-request` is fixed
+ Object.assign(options, url_to_options_1.default(url));
+ // `http-cache-semantics` checks this
+ delete options.url;
+ // This is ugly
+ const cacheRequest = cacheableStore.get(options.cache)(options, response => {
+ const typedResponse = response;
+ const { req } = typedResponse;
+ // TODO: Fix `cacheable-response`
+ typedResponse._readableState.autoDestroy = false;
+ if (req) {
+ req.emit('cacheableResponse', typedResponse);
+ }
+ resolve(typedResponse);
+ });
+ // Restore options
+ options.url = url;
+ cacheRequest.once('error', reject);
+ cacheRequest.once('request', resolve);
+ });
+ }
+ async _makeRequest() {
+ var _a;
+ const { options } = this;
+ const { headers } = options;
+ for (const key in headers) {
+ if (is_1.default.undefined(headers[key])) {
+ // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+ delete headers[key];
+ }
+ else if (is_1.default.null_(headers[key])) {
+ throw new TypeError(`Use \`undefined\` instead of \`null\` to delete the \`${key}\` header`);
+ }
+ }
+ if (options.decompress && is_1.default.undefined(headers['accept-encoding'])) {
+ headers['accept-encoding'] = supportsBrotli ? 'gzip, deflate, br' : 'gzip, deflate';
+ }
+ // Set cookies
+ if (options.cookieJar) {
+ const cookieString = await options.cookieJar.getCookieString(options.url.toString());
+ if (is_1.default.nonEmptyString(cookieString)) {
+ options.headers.cookie = cookieString;
+ }
+ }
+ for (const hook of options.hooks.beforeRequest) {
+ // eslint-disable-next-line no-await-in-loop
+ const result = await hook(options);
+ if (!is_1.default.undefined(result)) {
+ // @ts-ignore Skip the type mismatch to support abstract responses
+ options.request = () => result;
+ break;
+ }
+ }
+ const { agent, request, timeout, url } = options;
+ if (options.dnsCache && !('lookup' in options)) {
+ options.lookup = options.dnsCache.lookup;
+ }
+ // UNIX sockets
+ if (url.hostname === 'unix') {
+ const matches = /(?.+?):(?.+)/.exec(`${url.pathname}${url.search}`);
+ if (matches === null || matches === void 0 ? void 0 : matches.groups) {
+ const { socketPath, path } = matches.groups;
+ Object.assign(options, {
+ socketPath,
+ path,
+ host: ''
+ });
+ }
+ }
+ const isHttps = url.protocol === 'https:';
+ // Fallback function
+ let fallbackFn;
+ if (options.http2) {
+ fallbackFn = http2wrapper.auto;
+ }
+ else {
+ fallbackFn = isHttps ? https.request : http.request;
+ }
+ const realFn = (_a = options.request) !== null && _a !== void 0 ? _a : fallbackFn;
+ // Cache support
+ const fn = options.cache ? this._createCacheableRequest : realFn;
+ // Pass an agent directly when HTTP2 is disabled
+ if (agent && !options.http2) {
+ options.agent = agent[isHttps ? 'https' : 'http'];
+ }
+ // Prepare plain HTTP request options
+ options[kRequest] = realFn;
+ delete options.request;
+ delete options.timeout;
+ const requestOptions = options;
+ // If `dnsLookupIpVersion` is not present do not override `family`
+ if (options.dnsLookupIpVersion !== undefined) {
+ try {
+ requestOptions.family = dns_ip_version_1.dnsLookupIpVersionToFamily(options.dnsLookupIpVersion);
+ }
+ catch (_b) {
+ throw new Error('Invalid `dnsLookupIpVersion` option value');
+ }
+ }
+ // HTTPS options remapping
+ if (options.https) {
+ if ('rejectUnauthorized' in options.https) {
+ requestOptions.rejectUnauthorized = options.https.rejectUnauthorized;
+ }
+ if (options.https.checkServerIdentity) {
+ requestOptions.checkServerIdentity = options.https.checkServerIdentity;
+ }
+ if (options.https.certificateAuthority) {
+ requestOptions.ca = options.https.certificateAuthority;
+ }
+ if (options.https.certificate) {
+ requestOptions.cert = options.https.certificate;
+ }
+ if (options.https.key) {
+ requestOptions.key = options.https.key;
+ }
+ if (options.https.passphrase) {
+ requestOptions.passphrase = options.https.passphrase;
+ }
+ }
+ try {
+ let requestOrResponse = await fn(url, requestOptions);
+ if (is_1.default.undefined(requestOrResponse)) {
+ requestOrResponse = fallbackFn(url, requestOptions);
+ }
+ // Restore options
+ options.request = request;
+ options.timeout = timeout;
+ options.agent = agent;
+ if (isClientRequest(requestOrResponse)) {
+ this._onRequest(requestOrResponse);
+ // Emit the response after the stream has been ended
+ }
+ else if (this.writable) {
+ this.once('finish', () => {
+ this._onResponse(requestOrResponse);
+ });
+ this._unlockWrite();
+ this.end();
+ this._lockWrite();
+ }
+ else {
+ this._onResponse(requestOrResponse);
+ }
+ }
+ catch (error) {
+ if (error instanceof CacheableRequest.CacheError) {
+ throw new CacheError(error, this);
+ }
+ throw new RequestError(error.message, error, this);
+ }
+ }
+ async _beforeError(error) {
+ if (this.destroyed) {
+ return;
+ }
+ this[kStopReading] = true;
+ if (!(error instanceof RequestError)) {
+ error = new RequestError(error.message, error, this);
+ }
+ try {
+ const { response } = error;
+ if (response) {
+ response.setEncoding(this._readableState.encoding);
+ response.rawBody = await getStream.buffer(response);
+ response.body = response.rawBody.toString();
+ }
+ }
+ catch (_) { }
+ try {
+ for (const hook of this.options.hooks.beforeError) {
+ // eslint-disable-next-line no-await-in-loop
+ error = await hook(error);
+ }
+ }
+ catch (error_) {
+ error = new RequestError(error_.message, error_, this);
+ }
+ this.destroy(error);
+ }
+ _read() {
+ this[kTriggerRead] = true;
+ const response = this[kResponse];
+ if (response && !this[kStopReading]) {
+ // We cannot put this in the `if` above
+ // because `.read()` also triggers the `end` event
+ if (response.readableLength) {
+ this[kTriggerRead] = false;
+ }
+ let data;
+ while ((data = response.read()) !== null) {
+ this[kDownloadedSize] += data.length;
+ this[kStartedReading] = true;
+ const progress = this.downloadProgress;
+ if (progress.percent < 1) {
+ this.emit('downloadProgress', progress);
+ }
+ this.push(data);
+ }
+ }
+ }
+ _write(chunk, encoding, callback) {
+ const write = () => {
+ this._writeRequest(chunk, encoding, callback);
+ };
+ if (this.requestInitialized) {
+ write();
+ }
+ else {
+ this[kJobs].push(write);
+ }
+ }
+ _writeRequest(chunk, encoding, callback) {
+ this._progressCallbacks.push(() => {
+ this[kUploadedSize] += Buffer.byteLength(chunk, encoding);
+ const progress = this.uploadProgress;
+ if (progress.percent < 1) {
+ this.emit('uploadProgress', progress);
+ }
+ });
+ // TODO: What happens if it's from cache? Then this[kRequest] won't be defined.
+ this[kRequest].write(chunk, encoding, (error) => {
+ if (!error && this._progressCallbacks.length !== 0) {
+ this._progressCallbacks.shift()();
+ }
+ callback(error);
+ });
+ }
+ _final(callback) {
+ const endRequest = () => {
+ // FIX: Node.js 10 calls the write callback AFTER the end callback!
+ while (this._progressCallbacks.length !== 0) {
+ this._progressCallbacks.shift()();
+ }
+ // We need to check if `this[kRequest]` is present,
+ // because it isn't when we use cache.
+ if (!(kRequest in this)) {
+ callback();
+ return;
+ }
+ if (this[kRequest].destroyed) {
+ callback();
+ return;
+ }
+ this[kRequest].end((error) => {
+ if (!error) {
+ this[kBodySize] = this[kUploadedSize];
+ this.emit('uploadProgress', this.uploadProgress);
+ this[kRequest].emit('upload-complete');
+ }
+ callback(error);
+ });
+ };
+ if (this.requestInitialized) {
+ endRequest();
+ }
+ else {
+ this[kJobs].push(endRequest);
+ }
+ }
+ _destroy(error, callback) {
+ var _a;
+ if (kRequest in this) {
+ this[kCancelTimeouts]();
+ // TODO: Remove the next `if` when these get fixed:
+ // - https://github.com/nodejs/node/issues/32851
+ if (!((_a = this[kResponse]) === null || _a === void 0 ? void 0 : _a.complete)) {
+ this[kRequest].destroy();
+ }
+ }
+ if (error !== null && !is_1.default.undefined(error) && !(error instanceof RequestError)) {
+ error = new RequestError(error.message, error, this);
+ }
+ callback(error);
+ }
+ get ip() {
+ var _a;
+ return (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.socket.remoteAddress;
+ }
+ get aborted() {
+ var _a, _b, _c;
+ return ((_b = (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.destroyed) !== null && _b !== void 0 ? _b : this.destroyed) && !((_c = this[kOriginalResponse]) === null || _c === void 0 ? void 0 : _c.complete);
+ }
+ get socket() {
+ var _a;
+ return (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.socket;
+ }
+ get downloadProgress() {
+ let percent;
+ if (this[kResponseSize]) {
+ percent = this[kDownloadedSize] / this[kResponseSize];
+ }
+ else if (this[kResponseSize] === this[kDownloadedSize]) {
+ percent = 1;
+ }
+ else {
+ percent = 0;
+ }
+ return {
+ percent,
+ transferred: this[kDownloadedSize],
+ total: this[kResponseSize]
+ };
+ }
+ get uploadProgress() {
+ let percent;
+ if (this[kBodySize]) {
+ percent = this[kUploadedSize] / this[kBodySize];
+ }
+ else if (this[kBodySize] === this[kUploadedSize]) {
+ percent = 1;
+ }
+ else {
+ percent = 0;
+ }
+ return {
+ percent,
+ transferred: this[kUploadedSize],
+ total: this[kBodySize]
+ };
+ }
+ get timings() {
+ var _a;
+ return (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.timings;
+ }
+ get isFromCache() {
+ return this[kIsFromCache];
+ }
+ get _response() {
+ return this[kResponse];
+ }
+ pipe(destination, options) {
+ if (this[kStartedReading]) {
+ throw new Error('Failed to pipe. The response has been emitted already.');
+ }
+ if (destination instanceof http_1.ServerResponse) {
+ this[kServerResponsesPiped].add(destination);
+ }
+ return super.pipe(destination, options);
+ }
+ unpipe(destination) {
+ if (destination instanceof http_1.ServerResponse) {
+ this[kServerResponsesPiped].delete(destination);
+ }
+ super.unpipe(destination);
+ return this;
+ }
+}
+exports.default = Request;
+
+
/***/ }),
/***/ 948:
@@ -24893,6 +31494,236 @@ function checkBypass(reqUrl) {
exports.checkBypass = checkBypass;
+/***/ }),
+
+/***/ 952:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __webpack_require__(614);
+const getStream = __webpack_require__(145);
+const PCancelable = __webpack_require__(557);
+const calculate_retry_delay_1 = __webpack_require__(927);
+const types_1 = __webpack_require__(36);
+const core_1 = __webpack_require__(468);
+exports.PromisableRequest = core_1.default;
+const proxy_events_1 = __webpack_require__(628);
+const proxiedRequestEvents = [
+ 'request',
+ 'response',
+ 'redirect',
+ 'uploadProgress',
+ 'downloadProgress'
+];
+function asPromise(options) {
+ let retryCount = 0;
+ let globalRequest;
+ let globalResponse;
+ const emitter = new events_1.EventEmitter();
+ const promise = new PCancelable((resolve, _reject, onCancel) => {
+ const makeRequest = () => {
+ // Support retries
+ // `options.throwHttpErrors` needs to be always true,
+ // so the HTTP errors are caught and the request is retried.
+ // The error is **eventually** thrown if the user value is true.
+ const { throwHttpErrors } = options;
+ if (!throwHttpErrors) {
+ options.throwHttpErrors = true;
+ }
+ // Note from @szmarczak: I think we should use `request.options` instead of the local options
+ const request = new core_1.default(options.url, options);
+ request._noPipe = true;
+ onCancel(() => request.destroy());
+ const reject = async (error) => {
+ try {
+ for (const hook of options.hooks.beforeError) {
+ // eslint-disable-next-line no-await-in-loop
+ error = await hook(error);
+ }
+ }
+ catch (error_) {
+ _reject(new types_1.RequestError(error_.message, error_, request));
+ return;
+ }
+ _reject(error);
+ };
+ globalRequest = request;
+ const onResponse = async (response) => {
+ response.retryCount = retryCount;
+ if (response.request.aborted) {
+ // Canceled while downloading - will throw a `CancelError` or `TimeoutError` error
+ return;
+ }
+ const isOk = () => {
+ const { statusCode } = response;
+ const limitStatusCode = options.followRedirect ? 299 : 399;
+ return (statusCode >= 200 && statusCode <= limitStatusCode) || statusCode === 304;
+ };
+ // Download body
+ let rawBody;
+ try {
+ rawBody = await getStream.buffer(request);
+ response.rawBody = rawBody;
+ }
+ catch (_) {
+ // The same error is caught below.
+ // See request.once('error')
+ return;
+ }
+ // Parse body
+ try {
+ response.body = core_1.parseBody(response, options.responseType, options.parseJson, options.encoding);
+ }
+ catch (error) {
+ // Fallback to `utf8`
+ response.body = rawBody.toString();
+ if (isOk()) {
+ // TODO: Call `request._beforeError`, see https://github.com/nodejs/node/issues/32995
+ reject(error);
+ return;
+ }
+ }
+ try {
+ for (const [index, hook] of options.hooks.afterResponse.entries()) {
+ // @ts-ignore TS doesn't notice that CancelableRequest is a Promise
+ // eslint-disable-next-line no-await-in-loop
+ response = await hook(response, async (updatedOptions) => {
+ const typedOptions = core_1.default.normalizeArguments(undefined, {
+ ...updatedOptions,
+ retry: {
+ calculateDelay: () => 0
+ },
+ throwHttpErrors: false,
+ resolveBodyOnly: false
+ }, options);
+ // Remove any further hooks for that request, because we'll call them anyway.
+ // The loop continues. We don't want duplicates (asPromise recursion).
+ typedOptions.hooks.afterResponse = typedOptions.hooks.afterResponse.slice(0, index);
+ for (const hook of typedOptions.hooks.beforeRetry) {
+ // eslint-disable-next-line no-await-in-loop
+ await hook(typedOptions);
+ }
+ const promise = asPromise(typedOptions);
+ onCancel(() => {
+ promise.catch(() => { });
+ promise.cancel();
+ });
+ return promise;
+ });
+ }
+ }
+ catch (error) {
+ // TODO: Call `request._beforeError`, see https://github.com/nodejs/node/issues/32995
+ reject(new types_1.RequestError(error.message, error, request));
+ return;
+ }
+ if (throwHttpErrors && !isOk()) {
+ reject(new types_1.HTTPError(response));
+ return;
+ }
+ globalResponse = response;
+ resolve(options.resolveBodyOnly ? response.body : response);
+ };
+ request.once('response', onResponse);
+ request.once('error', async (error) => {
+ if (promise.isCanceled) {
+ return;
+ }
+ if (!request.options) {
+ reject(error);
+ return;
+ }
+ request.off('response', onResponse);
+ let backoff;
+ retryCount++;
+ try {
+ backoff = await options.retry.calculateDelay({
+ attemptCount: retryCount,
+ retryOptions: options.retry,
+ error,
+ computedValue: calculate_retry_delay_1.default({
+ attemptCount: retryCount,
+ retryOptions: options.retry,
+ error,
+ computedValue: 0
+ })
+ });
+ }
+ catch (error_) {
+ // Don't emit the `response` event
+ request.destroy();
+ reject(new types_1.RequestError(error_.message, error, request));
+ return;
+ }
+ if (backoff) {
+ // Don't emit the `response` event
+ request.destroy();
+ const retry = async () => {
+ options.throwHttpErrors = throwHttpErrors;
+ try {
+ for (const hook of options.hooks.beforeRetry) {
+ // eslint-disable-next-line no-await-in-loop
+ await hook(options, error, retryCount);
+ }
+ }
+ catch (error_) {
+ // Don't emit the `response` event
+ request.destroy();
+ reject(new types_1.RequestError(error_.message, error, request));
+ return;
+ }
+ makeRequest();
+ };
+ setTimeout(retry, backoff);
+ return;
+ }
+ // The retry has not been made
+ retryCount--;
+ if (error instanceof types_1.HTTPError) {
+ // The error will be handled by the `response` event
+ onResponse(request._response);
+ return;
+ }
+ // Don't emit the `response` event
+ request.destroy();
+ reject(error);
+ });
+ proxy_events_1.default(request, emitter, proxiedRequestEvents);
+ };
+ makeRequest();
+ });
+ promise.on = (event, fn) => {
+ emitter.on(event, fn);
+ return promise;
+ };
+ const shortcut = (responseType) => {
+ const newPromise = (async () => {
+ // Wait until downloading has ended
+ await promise;
+ return core_1.parseBody(globalResponse, responseType, options.parseJson, options.encoding);
+ })();
+ Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promise));
+ return newPromise;
+ };
+ promise.json = () => {
+ if (!globalRequest.writableFinished && options.headers.accept === undefined) {
+ options.headers.accept = 'application/json';
+ }
+ return shortcut('json');
+ };
+ promise.buffer = () => shortcut('buffer');
+ promise.text = () => shortcut('text');
+ return promise;
+}
+exports.default = asPromise;
+__export(__webpack_require__(36));
+
+
/***/ }),
/***/ 954:
@@ -24934,7 +31765,7 @@ const crossSpawn = __webpack_require__(20);
const stripEof = __webpack_require__(768);
const npmRunPath = __webpack_require__(621);
const isStream = __webpack_require__(323);
-const _getStream = __webpack_require__(145);
+const _getStream = __webpack_require__(79);
const pFinally = __webpack_require__(697);
const onExit = __webpack_require__(260);
const errname = __webpack_require__(427);
@@ -25297,53 +32128,54 @@ module.exports.shellSync = (cmd, opts) => handleShell(module.exports.sync, cmd,
"use strict";
-const {PassThrough} = __webpack_require__(413);
+const {PassThrough: PassThroughStream} = __webpack_require__(413);
module.exports = options => {
- options = Object.assign({}, options);
+ options = {...options};
const {array} = options;
let {encoding} = options;
- const buffer = encoding === 'buffer';
+ const isBuffer = encoding === 'buffer';
let objectMode = false;
if (array) {
- objectMode = !(encoding || buffer);
+ objectMode = !(encoding || isBuffer);
} else {
encoding = encoding || 'utf8';
}
- if (buffer) {
+ if (isBuffer) {
encoding = null;
}
- let len = 0;
- const ret = [];
- const stream = new PassThrough({objectMode});
+ const stream = new PassThroughStream({objectMode});
if (encoding) {
stream.setEncoding(encoding);
}
+ let length = 0;
+ const chunks = [];
+
stream.on('data', chunk => {
- ret.push(chunk);
+ chunks.push(chunk);
if (objectMode) {
- len = ret.length;
+ length = chunks.length;
} else {
- len += chunk.length;
+ length += chunk.length;
}
});
stream.getBufferedValue = () => {
if (array) {
- return ret;
+ return chunks;
}
- return buffer ? Buffer.concat(ret, len) : ret.join('');
+ return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
};
- stream.getBufferedLength = () => len;
+ stream.getBufferedLength = () => length;
return stream;
};
@@ -25398,6 +32230,158 @@ function onceStrict (fn) {
}
+/***/ }),
+
+/***/ 988:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+const http = __webpack_require__(605);
+const https = __webpack_require__(211);
+const resolveALPN = __webpack_require__(524);
+const QuickLRU = __webpack_require__(290);
+const Http2ClientRequest = __webpack_require__(181);
+const calculateServerName = __webpack_require__(751);
+const urlToOptions = __webpack_require__(507);
+
+const cache = new QuickLRU({maxSize: 100});
+const queue = new Map();
+
+const installSocket = (agent, socket, options) => {
+ socket._httpMessage = {shouldKeepAlive: true};
+
+ const onFree = () => {
+ agent.emit('free', socket, options);
+ };
+
+ socket.on('free', onFree);
+
+ const onClose = () => {
+ agent.removeSocket(socket, options);
+ };
+
+ socket.on('close', onClose);
+
+ const onRemove = () => {
+ agent.removeSocket(socket, options);
+ socket.off('close', onClose);
+ socket.off('free', onFree);
+ socket.off('agentRemove', onRemove);
+ };
+
+ socket.on('agentRemove', onRemove);
+
+ agent.emit('free', socket, options);
+};
+
+const resolveProtocol = async options => {
+ const name = `${options.host}:${options.port}:${options.ALPNProtocols.sort()}`;
+
+ if (!cache.has(name)) {
+ if (queue.has(name)) {
+ const result = await queue.get(name);
+ return result.alpnProtocol;
+ }
+
+ const {path, agent} = options;
+ options.path = options.socketPath;
+
+ const resultPromise = resolveALPN(options);
+ queue.set(name, resultPromise);
+
+ try {
+ const {socket, alpnProtocol} = await resultPromise;
+ cache.set(name, alpnProtocol);
+
+ options.path = path;
+
+ if (alpnProtocol === 'h2') {
+ // https://github.com/nodejs/node/issues/33343
+ socket.destroy();
+ } else {
+ const {globalAgent} = https;
+ const defaultCreateConnection = https.Agent.prototype.createConnection;
+
+ if (agent) {
+ if (agent.createConnection === defaultCreateConnection) {
+ installSocket(agent, socket, options);
+ } else {
+ socket.destroy();
+ }
+ } else if (globalAgent.createConnection === defaultCreateConnection) {
+ installSocket(globalAgent, socket, options);
+ } else {
+ socket.destroy();
+ }
+ }
+
+ queue.delete(name);
+
+ return alpnProtocol;
+ } catch (error) {
+ queue.delete(name);
+
+ throw error;
+ }
+ }
+
+ return cache.get(name);
+};
+
+module.exports = async (input, options, callback) => {
+ if (typeof input === 'string' || input instanceof URL) {
+ input = urlToOptions(new URL(input));
+ }
+
+ if (typeof options === 'function') {
+ callback = options;
+ options = undefined;
+ }
+
+ options = {
+ ALPNProtocols: ['h2', 'http/1.1'],
+ protocol: 'https:',
+ ...input,
+ ...options,
+ resolveSocket: true
+ };
+
+ const isHttps = options.protocol === 'https:';
+ const agents = options.agent;
+
+ options.host = options.hostname || options.host || 'localhost';
+ options.session = options.tlsSession;
+ options.servername = options.servername || calculateServerName(options);
+ options.port = options.port || (isHttps ? 443 : 80);
+ options._defaultAgent = isHttps ? https.globalAgent : http.globalAgent;
+
+ if (agents) {
+ if (agents.addRequest) {
+ throw new Error('The `options.agent` object can contain only `http`, `https` or `http2` properties');
+ }
+
+ options.agent = agents[isHttps ? 'https' : 'http'];
+ }
+
+ if (isHttps) {
+ const protocol = await resolveProtocol(options);
+
+ if (protocol === 'h2') {
+ if (agents) {
+ options.agent = agents.http2;
+ }
+
+ return new Http2ClientRequest(options, callback);
+ }
+ }
+
+ return http.request(options, callback);
+};
+
+module.exports.protocolCache = cache;
+
+
/***/ })
/******/ });
\ No newline at end of file
diff --git a/index.js b/index.js
new file mode 100644
index 0000000..c9f3ba6
--- /dev/null
+++ b/index.js
@@ -0,0 +1,7 @@
+const got = require("got");
+
+got.get("https://api.github.com/repos/doitadrian/contreebutors-action/pulls/2/commits", {
+ responseType: "json",
+}).then((response) => {
+ console.log(response.body);
+});
diff --git a/main.ts b/main.ts
index 985fd4e..b34eb81 100644
--- a/main.ts
+++ b/main.ts
@@ -1,25 +1,56 @@
const { context } = require("@actions/github");
const core = require("@actions/core");
+const get = require("lodash.get");
+const got = require("got");
-const isValidCommitMessage = message => message.match(/^[a-z].*:/);
+type Commit = {
+ message: string;
+};
+
+const isValidCommitMessage = (message): boolean => message.match(/^[a-z].*:/);
+
+const extractCommits = async (): Promise => {
+ // For "push" events, commits can be found in the "context.payload.commits".
+ const pushCommits = Array.isArray(get(context, "payload.commits"));
+ if (pushCommits) {
+ return context.payload.commits;
+ }
+
+ // For PRs, we need to get a list of commits via the GH API:
+ const prCommitsUrl = typeof get(context, "payload.pull_request.commits_url");
+ if (prCommitsUrl) {
+ try {
+ const { body } = await got.get(prCommitsUrl, {
+ responseType: "json",
+ });
+
+ if (Array.isArray(body)) {
+ return body.map((item) => item.commit);
+ }
+ return [];
+ } catch {
+ return [];
+ }
+ }
+
+ return [];
+};
async function run() {
core.info(
`ℹ️ Checking if commit messages are following the Conventional Commits specification...`
);
- console.log('context', JSON.stringify(context, null, 2));
-
- const hasCommits = context.payload && Array.isArray(context.payload.commits);
- if (!hasCommits) {
+ const extractedCommits = await extractCommits();
+ if (extractedCommits.length === 0) {
core.info(`No commits to check, skipping...`);
return;
}
let hasErrors;
core.startGroup("Commit messages:");
- for (let i = 0; i < context.payload.commits.length; i++) {
- let commit = context.payload.commits[i];
+ for (let i = 0; i < extractedCommits.length; i++) {
+ let commit = extractedCommits[i];
if (isValidCommitMessage(commit.message)) {
core.info(`✅ ${commit.message}`);
} else {
diff --git a/package.json b/package.json
index ea4ffb3..0673946 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,9 @@
"dependencies": {
"@actions/core": "^1.2.3",
"@actions/exec": "^1.0.3",
- "@actions/github": "^2.1.1"
+ "@actions/github": "^2.1.1",
+ "got": "^11.3.0",
+ "lodash.get": "^4.4.2"
},
"devDependencies": {
"@zeit/ncc": "^0.22.0",