snyk 1.1236.0 → 1.1237.0

package/dist/cli/245.index.js

@@ -80490,1331 +80490,650 @@ module.exports.MaxBufferError = MaxBufferError;
 
 /***/ }),
 
-/***/ 59844:
-/***/ ((module) => {
+/***/ 93481:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "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 EventEmitter = __webpack_require__(82361);
+const urlLib = __webpack_require__(57310);
+const normalizeUrl = __webpack_require__(40015);
+const getStream = __webpack_require__(50404);
+const CachePolicy = __webpack_require__(26214);
+const Response = __webpack_require__(24259);
+const lowercaseKeys = __webpack_require__(25989);
+const cloneResponse = __webpack_require__(79715);
+const Keyv = __webpack_require__(64958);
 
-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,
-};
+class CacheableRequest {
+	constructor(request, cacheAdapter) {
+		if (typeof request !== 'function') {
+			throw new TypeError('Parameter `request` must be a function');
+		}
 
-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,
-};
+		this.cache = new Keyv({
+			uri: typeof cacheAdapter === 'string' && cacheAdapter,
+			store: typeof cacheAdapter !== 'string' && cacheAdapter,
+			namespace: 'cacheable-request'
+		});
 
-function toNumberOrZero(s) {
-    const n = parseInt(s, 10);
-    return isFinite(n) ? n : 0;
-}
+		return this.createCacheableRequest(request);
+	}
 
-// RFC 5861
-function isErrorResponse(response) {
-    // consider undefined response as faulty
-    if(!response) {
-        return true
-    }
-    return errorStatusCodes.has(response.status);
-}
+	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 });
+			}
 
-function parseCacheControl(header) {
-    const cc = {};
-    if (!header) return cc;
+			opts = {
+				headers: {},
+				method: 'GET',
+				cache: true,
+				strictTtl: false,
+				automaticFailover: false,
+				...opts,
+				...urlObjectToRequestOptions(url)
+			};
+			opts.headers = lowercaseKeys(opts.headers);
 
-    // 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
-    }
+			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;
 
-    return cc;
-}
+			const makeRequest = opts => {
+				madeRequest = true;
+				let requestErrored = false;
+				let requestErrorCallback;
 
-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(', ');
-}
+				const requestErrorPromise = new Promise(resolve => {
+					requestErrorCallback = () => {
+						if (!requestErrored) {
+							requestErrored = true;
+							resolve();
+						}
+					};
+				});
 
-module.exports = class CachePolicy {
-    constructor(
-        req,
-        res,
-        {
-            shared,
-            cacheHeuristic,
-            immutableMinTimeToLive,
-            ignoreCargoCult,
-            _fromObject,
-        } = {}
-    ) {
-        if (_fromObject) {
-            this._fromObject(_fromObject);
-            return;
-        }
+				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 (!res || !res.headers) {
-            throw Error('Response headers missing');
-        }
-        this._assertRequestHasHeaders(req);
+					if (!response.fromCache) {
+						response.cachePolicy = new CachePolicy(opts, response, opts);
+						response.fromCache = false;
+					}
 
-        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;
+					let clonedResponse;
+					if (opts.cache && response.cachePolicy.storable()) {
+						clonedResponse = cloneResponse(response);
 
-        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']);
+						(async () => {
+							try {
+								const bodyPromise = getStream.buffer(response);
 
-        // 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;
-        }
+								await Promise.race([
+									requestErrorPromise,
+									new Promise(resolve => response.once('end', resolve))
+								]);
 
-        // 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;
-        }
-    }
+								if (requestErrored) {
+									return;
+								}
 
-    now() {
-        return Date.now();
-    }
+								const body = await bodyPromise;
 
-    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))
-        );
-    }
+								const value = {
+									cachePolicy: response.cachePolicy.toObject(),
+									url: response.url,
+									statusCode: response.fromCache ? revalidate.statusCode : response.statusCode,
+									body
+								};
 
-    _hasExplicitExpiration() {
-        // 4.2.1 Calculating Freshness Lifetime
-        return (
-            (this._isShared && this._rescc['s-maxage']) ||
-            this._rescc['max-age'] ||
-            this._resHeaders.expires
-        );
-    }
+								let ttl = opts.strictTtl ? response.cachePolicy.timeToLive() : undefined;
+								if (opts.maxTtl) {
+									ttl = ttl ? Math.min(ttl, opts.maxTtl) : opts.maxTtl;
+								}
 
-    _assertRequestHasHeaders(req) {
-        if (!req || !req.headers) {
-            throw Error('Request headers missing');
-        }
-    }
+								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));
+							}
+						})();
+					}
 
-    satisfiesWithoutRevalidation(req) {
-        this._assertRequestHasHeaders(req);
+					ee.emit('response', clonedResponse || response);
+					if (typeof cb === 'function') {
+						cb(clonedResponse || response);
+					}
+				};
 
-        // 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;
-        }
+				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));
+				}
+			};
 
-        if (requestCC['max-age'] && this.age() > requestCC['max-age']) {
-            return false;
-        }
+			(async () => {
+				const get = async opts => {
+					await Promise.resolve();
 
-        if (
-            requestCC['min-fresh'] &&
-            this.timeToLive() < 1000 * requestCC['min-fresh']
-        ) {
-            return false;
-        }
+					const cacheEntry = opts.cache ? await this.cache.get(key) : undefined;
+					if (typeof cacheEntry === 'undefined') {
+						return makeRequest(opts);
+					}
 
-        // 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;
-            }
-        }
+					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;
 
-        return this._requestMatches(req, false);
-    }
+						ee.emit('response', response);
+						if (typeof cb === 'function') {
+							cb(response);
+						}
+					} else {
+						revalidate = cacheEntry;
+						opts.headers = policy.revalidationHeaders(opts);
+						makeRequest(opts);
+					}
+				};
 
-    _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)
-        );
-    }
+				const errorHandler = error => ee.emit('error', new CacheableRequest.CacheError(error));
+				this.cache.once('error', errorHandler);
+				ee.on('response', () => this.cache.removeListener('error', errorHandler));
 
-    _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']
-        );
-    }
+				try {
+					await get(opts);
+				} catch (error) {
+					if (opts.automaticFailover && !madeRequest) {
+						makeRequest(opts);
+					}
 
-    _varyMatches(req) {
-        if (!this._resHeaders.vary) {
-            return true;
-        }
+					ee.emit('error', new CacheableRequest.CacheError(error));
+				}
+			})();
 
-        // A Vary header field-value of "*" always fails to match
-        if (this._resHeaders.vary === '*') {
-            return false;
-        }
+			return ee;
+		};
+	}
+}
 
-        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;
-    }
+function urlObjectToRequestOptions(url) {
+	const options = { ...url };
+	options.path = `${url.pathname || '/'}${url.search || ''}`;
+	delete options.pathname;
+	delete options.search;
+	return options;
+}
 
-    _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;
-    }
+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
+	};
+}
 
-    responseHeaders() {
-        const headers = this._copyWithoutHopByHopHeaders(this._resHeaders);
-        const age = this.age();
+CacheableRequest.RequestError = class extends Error {
+	constructor(error) {
+		super(error.message);
+		this.name = 'RequestError';
+		Object.assign(this, error);
+	}
+};
 
-        // 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;
-    }
+CacheableRequest.CacheError = class extends Error {
+	constructor(error) {
+		super(error.message);
+		this.name = 'CacheError';
+		Object.assign(this, error);
+	}
+};
 
-    /**
-     * 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;
-    }
+module.exports = CacheableRequest;
 
-    /**
-     * 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);
-    }
+/***/ 75281:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-    /**
-     * 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;
-        }
+"use strict";
 
-        // 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;
-        }
+const os = __webpack_require__(22037);
 
-        if (this._resHeaders.vary === '*') {
-            return 0;
-        }
+const extractPathRegex = /\s+at.*(?:\(|\s)(.*)\)?/;
+const pathRegex = /^(?:(?:(?:node|(?:internal\/[\w/]*|.*node_modules\/(?:babel-polyfill|pirates)\/.*)?\w+)\.js:\d+:\d+)|native)/;
+const homeDir = typeof os.homedir === 'undefined' ? '' : os.homedir();
 
-        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']);
-            }
-        }
+module.exports = (stack, options) => {
+	options = Object.assign({pretty: false}, options);
 
-        // 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']);
-        }
+	return stack.replace(/\\/g, '/')
+		.split('\n')
+		.filter(line => {
+			const pathMatches = line.match(extractPathRegex);
+			if (pathMatches === null || !pathMatches[1]) {
+				return true;
+			}
 
-        const defaultMinTtl = this._rescc.immutable ? this._immutableMinTtl : 0;
+			const match = pathMatches[1];
 
-        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);
-        }
+			// Electron
+			if (
+				match.includes('.app/Contents/Resources/electron.asar') ||
+				match.includes('.app/Contents/Resources/default_app.asar')
+			) {
+				return false;
+			}
 
-        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 !pathRegex.test(match);
+		})
+		.filter(line => line.trim() !== '')
+		.map(line => {
+			if (options.pretty) {
+				return line.replace(extractPathRegex, (m, p1) => m.replace(p1, p1.replace(homeDir, '~')));
+			}
 
-        return defaultMinTtl;
-    }
+			return line;
+		})
+		.join('\n');
+};
 
-    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();
-    }
+/***/ 87730:
+/***/ ((__unused_webpack_module, exports) => {
 
-    useStaleWhileRevalidate() {
-        return this.maxAge() + toNumberOrZero(this._rescc['stale-while-revalidate']) > this.age();
-    }
+"use strict";
 
-    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');
+Object.defineProperty(exports, "__esModule", ({ value: true }));
 
-        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;
-    }
+const NODE_INITIAL = 0;
+const NODE_SUCCESS = 1;
+const NODE_ERRORED = 2;
+const START_OF_INPUT = `\u0001`;
+const END_OF_INPUT = `\u0000`;
+const HELP_COMMAND_INDEX = -1;
+const HELP_REGEX = /^(-h|--help)(?:=([0-9]+))?$/;
+const OPTION_REGEX = /^(--[a-z]+(?:-[a-z]+)*|-[a-zA-Z]+)$/;
+const BATCH_REGEX = /^-[a-zA-Z]{2,}$/;
+const BINDING_REGEX = /^([^=]+)=([\s\S]*)$/;
+const DEBUG = process.env.DEBUG_CLI === `1`;
 
-    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,
-        };
+/**
+ * A generic usage error with the name `UsageError`.
+ *
+ * It should be used over `Error` only when it's the user's fault.
+ */
+class UsageError extends Error {
+    constructor(message) {
+        super(message);
+        this.clipanion = { type: `usage` };
+        this.name = `UsageError`;
     }
-
-    /**
-     * 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;
+}
+class UnknownSyntaxError extends Error {
+    constructor(input, candidates) {
+        super();
+        this.input = input;
+        this.candidates = candidates;
+        this.clipanion = { type: `none` };
+        this.name = `UnknownSyntaxError`;
+        if (this.candidates.length === 0) {
+            this.message = `Command not found, but we're not sure what's the alternative.`;
         }
-
-        /* 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;
+        else if (this.candidates.length === 1 && this.candidates[0].reason !== null) {
+            const [{ usage, reason }] = this.candidates;
+            this.message = `${reason}\n\n$ ${usage}`;
         }
+        else if (this.candidates.length === 1) {
+            const [{ usage }] = this.candidates;
+            this.message = `Command not found; did you mean:\n\n$ ${usage}\n${whileRunning(input)}`;
+        }
+        else {
+            this.message = `Command not found; did you mean one of:\n\n${this.candidates.map(({ usage }, index) => {
+                return `${`${index}.`.padStart(4)} ${usage}`;
+            }).join(`\n`)}\n\n${whileRunning(input)}`;
+        }
+    }
+}
+class AmbiguousSyntaxError extends Error {
+    constructor(input, usages) {
+        super();
+        this.input = input;
+        this.usages = usages;
+        this.clipanion = { type: `none` };
+        this.name = `AmbiguousSyntaxError`;
+        this.message = `Cannot find who to pick amongst the following alternatives:\n\n${this.usages.map((usage, index) => {
+            return `${`${index}.`.padStart(4)} ${usage}`;
+        }).join(`\n`)}\n\n${whileRunning(input)}`;
+    }
+}
+const whileRunning = (input) => `While running ${input.filter(token => {
+    return token !== END_OF_INPUT;
+}).map(token => {
+    const json = JSON.stringify(token);
+    if (token.match(/\s/) || token.length === 0 || json !== `"${token}"`) {
+        return json;
+    }
+    else {
+        return token;
+    }
+}).join(` `)}`;
 
-        // 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();
+// ------------------------------------------------------------------------
+function debug(str) {
+    if (DEBUG) {
+        console.log(str);
+    }
+}
+const basicHelpState = {
+    candidateUsage: null,
+    errorMessage: null,
+    ignoreOptions: false,
+    path: [],
+    positionals: [],
+    options: [],
+    remainder: null,
+    selectedIndex: HELP_COMMAND_INDEX
+};
+function makeStateMachine() {
+    return {
+        nodes: [makeNode(), makeNode(), makeNode()],
+    };
+}
+function makeAnyOfMachine(inputs) {
+    const output = makeStateMachine();
+    const heads = [];
+    let offset = output.nodes.length;
+    for (const input of inputs) {
+        heads.push(offset);
+        for (let t = 0; t < input.nodes.length; ++t)
+            if (!isTerminalNode(t))
+                output.nodes.push(cloneNode(input.nodes[t], offset));
+        offset += input.nodes.length - 2;
+    }
+    for (const head of heads)
+        registerShortcut(output, NODE_INITIAL, head);
+    return output;
+}
+function injectNode(machine, node) {
+    machine.nodes.push(node);
+    return machine.nodes.length - 1;
+}
+function simplifyMachine(input) {
+    const visited = new Set();
+    const process = (node) => {
+        if (visited.has(node))
+            return;
+        visited.add(node);
+        const nodeDef = input.nodes[node];
+        for (const transitions of Object.values(nodeDef.statics))
+            for (const { to } of transitions)
+                process(to);
+        for (const [, { to }] of nodeDef.dynamics)
+            process(to);
+        for (const { to } of nodeDef.shortcuts)
+            process(to);
+        const shortcuts = new Set(nodeDef.shortcuts.map(({ to }) => to));
+        while (nodeDef.shortcuts.length > 0) {
+            const { to } = nodeDef.shortcuts.shift();
+            const toDef = input.nodes[to];
+            for (const [segment, transitions] of Object.entries(toDef.statics)) {
+                let store = !Object.prototype.hasOwnProperty.call(nodeDef.statics, segment)
+                    ? nodeDef.statics[segment] = []
+                    : nodeDef.statics[segment];
+                for (const transition of transitions) {
+                    if (!store.some(({ to }) => transition.to === to)) {
+                        store.push(transition);
+                    }
+                }
+            }
+            for (const [test, transition] of toDef.dynamics)
+                if (!nodeDef.dynamics.some(([otherTest, { to }]) => test === otherTest && transition.to === to))
+                    nodeDef.dynamics.push([test, transition]);
+            for (const transition of toDef.shortcuts) {
+                if (!shortcuts.has(transition.to)) {
+                    nodeDef.shortcuts.push(transition);
+                    shortcuts.add(transition.to);
                 }
             }
-        } else if (
-            this._resHeaders['last-modified'] &&
-            !headers['if-modified-since']
-        ) {
-            headers['if-modified-since'] = this._resHeaders['last-modified'];
         }
-
-        return headers;
+    };
+    process(NODE_INITIAL);
+}
+function debugMachine(machine, { prefix = `` } = {}) {
+    debug(`${prefix}Nodes are:`);
+    for (let t = 0; t < machine.nodes.length; ++t) {
+        debug(`${prefix}  ${t}: ${JSON.stringify(machine.nodes[t])}`);
     }
-
-    /**
-     * 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,
-          };
+}
+function runMachineInternal(machine, input, partial = false) {
+    debug(`Running a vm on ${JSON.stringify(input)}`);
+    let branches = [{ node: NODE_INITIAL, state: {
+                candidateUsage: null,
+                errorMessage: null,
+                ignoreOptions: false,
+                options: [],
+                path: [],
+                positionals: [],
+                remainder: null,
+                selectedIndex: null,
+            } }];
+    debugMachine(machine, { prefix: `  ` });
+    const tokens = [START_OF_INPUT, ...input];
+    for (let t = 0; t < tokens.length; ++t) {
+        const segment = tokens[t];
+        debug(`  Processing ${JSON.stringify(segment)}`);
+        const nextBranches = [];
+        for (const { node, state } of branches) {
+            debug(`    Current node is ${node}`);
+            const nodeDef = machine.nodes[node];
+            if (node === NODE_ERRORED) {
+                nextBranches.push({ node, state });
+                continue;
+            }
+            console.assert(nodeDef.shortcuts.length === 0, `Shortcuts should have been eliminated by now`);
+            const hasExactMatch = Object.prototype.hasOwnProperty.call(nodeDef.statics, segment);
+            if (!partial || t < tokens.length - 1 || hasExactMatch) {
+                if (hasExactMatch) {
+                    const transitions = nodeDef.statics[segment];
+                    for (const { to, reducer } of transitions) {
+                        nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
+                        debug(`      Static transition to ${to} found`);
+                    }
+                }
+                else {
+                    debug(`      No static transition found`);
+                }
+            }
+            else {
+                let hasMatches = false;
+                for (const candidate of Object.keys(nodeDef.statics)) {
+                    if (!candidate.startsWith(segment))
+                        continue;
+                    if (segment === candidate) {
+                        for (const { to, reducer } of nodeDef.statics[candidate]) {
+                            nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
+                            debug(`      Static transition to ${to} found`);
+                        }
+                    }
+                    else {
+                        for (const { to, reducer } of nodeDef.statics[candidate]) {
+                            nextBranches.push({ node: to, state: Object.assign(Object.assign({}, state), { remainder: candidate.slice(segment.length) }) });
+                            debug(`      Static transition to ${to} found (partial match)`);
+                        }
+                    }
+                    hasMatches = true;
+                }
+                if (!hasMatches) {
+                    debug(`      No partial static transition found`);
+                }
+            }
+            if (segment !== END_OF_INPUT) {
+                for (const [test, { to, reducer }] of nodeDef.dynamics) {
+                    if (execute(tests, test, state, segment)) {
+                        nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
+                        debug(`      Dynamic transition to ${to} found (via ${test})`);
+                    }
+                }
+            }
         }
-        if (!response || !response.headers) {
-            throw Error('Response headers missing');
+        if (nextBranches.length === 0 && segment === END_OF_INPUT && input.length === 1) {
+            return [{
+                    node: NODE_INITIAL,
+                    state: basicHelpState,
+                }];
         }
-
-        // 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 (nextBranches.length === 0) {
+            throw new UnknownSyntaxError(input, branches.filter(({ node }) => {
+                return node !== NODE_ERRORED;
+            }).map(({ state }) => {
+                return { usage: state.candidateUsage, reason: null };
+            }));
         }
-
-        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,
-            };
+        if (nextBranches.every(({ node }) => node === NODE_ERRORED)) {
+            throw new UnknownSyntaxError(input, nextBranches.map(({ state }) => {
+                return { usage: state.candidateUsage, reason: state.errorMessage };
+            }));
         }
-
-        // 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];
+        branches = trimSmallerBranches(nextBranches);
+    }
+    if (branches.length > 0) {
+        debug(`  Results:`);
+        for (const branch of branches) {
+            debug(`    - ${branch.node} -> ${JSON.stringify(branch.state)}`);
         }
-
-        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,
-        };
     }
-};
-
-
-/***/ }),
-
-/***/ 93481:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-
-const EventEmitter = __webpack_require__(82361);
-const urlLib = __webpack_require__(57310);
-const normalizeUrl = __webpack_require__(40015);
-const getStream = __webpack_require__(50404);
-const CachePolicy = __webpack_require__(59844);
-const Response = __webpack_require__(24259);
-const lowercaseKeys = __webpack_require__(25989);
-const cloneResponse = __webpack_require__(79715);
-const Keyv = __webpack_require__(64958);
-
-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;
-
-
-/***/ }),
-
-/***/ 75281:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-const os = __webpack_require__(22037);
-
-const extractPathRegex = /\s+at.*(?:\(|\s)(.*)\)?/;
-const pathRegex = /^(?:(?:(?:node|(?:internal\/[\w/]*|.*node_modules\/(?:babel-polyfill|pirates)\/.*)?\w+)\.js:\d+:\d+)|native)/;
-const homeDir = typeof os.homedir === 'undefined' ? '' : os.homedir();
-
-module.exports = (stack, options) => {
-	options = Object.assign({pretty: false}, options);
-
-	return stack.replace(/\\/g, '/')
-		.split('\n')
-		.filter(line => {
-			const pathMatches = line.match(extractPathRegex);
-			if (pathMatches === null || !pathMatches[1]) {
-				return true;
-			}
-
-			const match = pathMatches[1];
-
-			// Electron
-			if (
-				match.includes('.app/Contents/Resources/electron.asar') ||
-				match.includes('.app/Contents/Resources/default_app.asar')
-			) {
-				return false;
-			}
-
-			return !pathRegex.test(match);
-		})
-		.filter(line => line.trim() !== '')
-		.map(line => {
-			if (options.pretty) {
-				return line.replace(extractPathRegex, (m, p1) => m.replace(p1, p1.replace(homeDir, '~')));
-			}
-
-			return line;
-		})
-		.join('\n');
-};
-
-
-/***/ }),
-
-/***/ 87730:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-
-const NODE_INITIAL = 0;
-const NODE_SUCCESS = 1;
-const NODE_ERRORED = 2;
-const START_OF_INPUT = `\u0001`;
-const END_OF_INPUT = `\u0000`;
-const HELP_COMMAND_INDEX = -1;
-const HELP_REGEX = /^(-h|--help)(?:=([0-9]+))?$/;
-const OPTION_REGEX = /^(--[a-z]+(?:-[a-z]+)*|-[a-zA-Z]+)$/;
-const BATCH_REGEX = /^-[a-zA-Z]{2,}$/;
-const BINDING_REGEX = /^([^=]+)=([\s\S]*)$/;
-const DEBUG = process.env.DEBUG_CLI === `1`;
-
-/**
- * A generic usage error with the name `UsageError`.
- *
- * It should be used over `Error` only when it's the user's fault.
- */
-class UsageError extends Error {
-    constructor(message) {
-        super(message);
-        this.clipanion = { type: `usage` };
-        this.name = `UsageError`;
+    else {
+        debug(`  No results`);
     }
+    return branches;
 }
-class UnknownSyntaxError extends Error {
-    constructor(input, candidates) {
-        super();
-        this.input = input;
-        this.candidates = candidates;
-        this.clipanion = { type: `none` };
-        this.name = `UnknownSyntaxError`;
-        if (this.candidates.length === 0) {
-            this.message = `Command not found, but we're not sure what's the alternative.`;
-        }
-        else if (this.candidates.length === 1 && this.candidates[0].reason !== null) {
-            const [{ usage, reason }] = this.candidates;
-            this.message = `${reason}\n\n$ ${usage}`;
+function checkIfNodeIsFinished(node, state) {
+    if (state.selectedIndex !== null)
+        return true;
+    if (Object.prototype.hasOwnProperty.call(node.statics, END_OF_INPUT))
+        for (const { to } of node.statics[END_OF_INPUT])
+            if (to === NODE_SUCCESS)
+                return true;
+    return false;
+}
+function suggestMachine(machine, input, partial) {
+    // If we're accepting partial matches, then exact matches need to be
+    // prefixed with an extra space.
+    const prefix = partial && input.length > 0 ? [``] : [];
+    const branches = runMachineInternal(machine, input, partial);
+    const suggestions = [];
+    const suggestionsJson = new Set();
+    const traverseSuggestion = (suggestion, node, skipFirst = true) => {
+        let nextNodes = [node];
+        while (nextNodes.length > 0) {
+            const currentNodes = nextNodes;
+            nextNodes = [];
+            for (const node of currentNodes) {
+                const nodeDef = machine.nodes[node];
+                const keys = Object.keys(nodeDef.statics);
+                for (const key of Object.keys(nodeDef.statics)) {
+                    const segment = keys[0];
+                    for (const { to, reducer } of nodeDef.statics[segment]) {
+                        if (reducer !== `pushPath`)
+                            continue;
+                        if (!skipFirst)
+                            suggestion.push(segment);
+                        nextNodes.push(to);
+                    }
+                }
+            }
+            skipFirst = false;
         }
-        else if (this.candidates.length === 1) {
-            const [{ usage }] = this.candidates;
-            this.message = `Command not found; did you mean:\n\n$ ${usage}\n${whileRunning(input)}`;
+        const json = JSON.stringify(suggestion);
+        if (suggestionsJson.has(json))
+            return;
+        suggestions.push(suggestion);
+        suggestionsJson.add(json);
+    };
+    for (const { node, state } of branches) {
+        if (state.remainder !== null) {
+            traverseSuggestion([state.remainder], node);
+            continue;
         }
-        else {
-            this.message = `Command not found; did you mean one of:\n\n${this.candidates.map(({ usage }, index) => {
-                return `${`${index}.`.padStart(4)} ${usage}`;
-            }).join(`\n`)}\n\n${whileRunning(input)}`;
+        const nodeDef = machine.nodes[node];
+        const isFinished = checkIfNodeIsFinished(nodeDef, state);
+        for (const [candidate, transitions] of Object.entries(nodeDef.statics))
+            if ((isFinished && candidate !== END_OF_INPUT) || (!candidate.startsWith(`-`) && transitions.some(({ reducer }) => reducer === `pushPath`)))
+                traverseSuggestion([...prefix, candidate], node);
+        if (!isFinished)
+            continue;
+        for (const [test, { to }] of nodeDef.dynamics) {
+            if (to === NODE_ERRORED)
+                continue;
+            const tokens = suggest(test, state);
+            if (tokens === null)
+                continue;
+            for (const token of tokens) {
+                traverseSuggestion([...prefix, token], node);
+            }
         }
     }
-}
-class AmbiguousSyntaxError extends Error {
-    constructor(input, usages) {
-        super();
-        this.input = input;
-        this.usages = usages;
-        this.clipanion = { type: `none` };
-        this.name = `AmbiguousSyntaxError`;
-        this.message = `Cannot find who to pick amongst the following alternatives:\n\n${this.usages.map((usage, index) => {
-            return `${`${index}.`.padStart(4)} ${usage}`;
-        }).join(`\n`)}\n\n${whileRunning(input)}`;
-    }
-}
-const whileRunning = (input) => `While running ${input.filter(token => {
-    return token !== END_OF_INPUT;
-}).map(token => {
-    const json = JSON.stringify(token);
-    if (token.match(/\s/) || token.length === 0 || json !== `"${token}"`) {
-        return json;
-    }
-    else {
-        return token;
-    }
-}).join(` `)}`;
-
-// ------------------------------------------------------------------------
-function debug(str) {
-    if (DEBUG) {
-        console.log(str);
-    }
-}
-const basicHelpState = {
-    candidateUsage: null,
-    errorMessage: null,
-    ignoreOptions: false,
-    path: [],
-    positionals: [],
-    options: [],
-    remainder: null,
-    selectedIndex: HELP_COMMAND_INDEX
-};
-function makeStateMachine() {
-    return {
-        nodes: [makeNode(), makeNode(), makeNode()],
-    };
-}
-function makeAnyOfMachine(inputs) {
-    const output = makeStateMachine();
-    const heads = [];
-    let offset = output.nodes.length;
-    for (const input of inputs) {
-        heads.push(offset);
-        for (let t = 0; t < input.nodes.length; ++t)
-            if (!isTerminalNode(t))
-                output.nodes.push(cloneNode(input.nodes[t], offset));
-        offset += input.nodes.length - 2;
-    }
-    for (const head of heads)
-        registerShortcut(output, NODE_INITIAL, head);
-    return output;
-}
-function injectNode(machine, node) {
-    machine.nodes.push(node);
-    return machine.nodes.length - 1;
-}
-function simplifyMachine(input) {
-    const visited = new Set();
-    const process = (node) => {
-        if (visited.has(node))
-            return;
-        visited.add(node);
-        const nodeDef = input.nodes[node];
-        for (const transitions of Object.values(nodeDef.statics))
-            for (const { to } of transitions)
-                process(to);
-        for (const [, { to }] of nodeDef.dynamics)
-            process(to);
-        for (const { to } of nodeDef.shortcuts)
-            process(to);
-        const shortcuts = new Set(nodeDef.shortcuts.map(({ to }) => to));
-        while (nodeDef.shortcuts.length > 0) {
-            const { to } = nodeDef.shortcuts.shift();
-            const toDef = input.nodes[to];
-            for (const [segment, transitions] of Object.entries(toDef.statics)) {
-                let store = !Object.prototype.hasOwnProperty.call(nodeDef.statics, segment)
-                    ? nodeDef.statics[segment] = []
-                    : nodeDef.statics[segment];
-                for (const transition of transitions) {
-                    if (!store.some(({ to }) => transition.to === to)) {
-                        store.push(transition);
-                    }
-                }
-            }
-            for (const [test, transition] of toDef.dynamics)
-                if (!nodeDef.dynamics.some(([otherTest, { to }]) => test === otherTest && transition.to === to))
-                    nodeDef.dynamics.push([test, transition]);
-            for (const transition of toDef.shortcuts) {
-                if (!shortcuts.has(transition.to)) {
-                    nodeDef.shortcuts.push(transition);
-                    shortcuts.add(transition.to);
-                }
-            }
-        }
-    };
-    process(NODE_INITIAL);
-}
-function debugMachine(machine, { prefix = `` } = {}) {
-    debug(`${prefix}Nodes are:`);
-    for (let t = 0; t < machine.nodes.length; ++t) {
-        debug(`${prefix}  ${t}: ${JSON.stringify(machine.nodes[t])}`);
-    }
-}
-function runMachineInternal(machine, input, partial = false) {
-    debug(`Running a vm on ${JSON.stringify(input)}`);
-    let branches = [{ node: NODE_INITIAL, state: {
-                candidateUsage: null,
-                errorMessage: null,
-                ignoreOptions: false,
-                options: [],
-                path: [],
-                positionals: [],
-                remainder: null,
-                selectedIndex: null,
-            } }];
-    debugMachine(machine, { prefix: `  ` });
-    const tokens = [START_OF_INPUT, ...input];
-    for (let t = 0; t < tokens.length; ++t) {
-        const segment = tokens[t];
-        debug(`  Processing ${JSON.stringify(segment)}`);
-        const nextBranches = [];
-        for (const { node, state } of branches) {
-            debug(`    Current node is ${node}`);
-            const nodeDef = machine.nodes[node];
-            if (node === NODE_ERRORED) {
-                nextBranches.push({ node, state });
-                continue;
-            }
-            console.assert(nodeDef.shortcuts.length === 0, `Shortcuts should have been eliminated by now`);
-            const hasExactMatch = Object.prototype.hasOwnProperty.call(nodeDef.statics, segment);
-            if (!partial || t < tokens.length - 1 || hasExactMatch) {
-                if (hasExactMatch) {
-                    const transitions = nodeDef.statics[segment];
-                    for (const { to, reducer } of transitions) {
-                        nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
-                        debug(`      Static transition to ${to} found`);
-                    }
-                }
-                else {
-                    debug(`      No static transition found`);
-                }
-            }
-            else {
-                let hasMatches = false;
-                for (const candidate of Object.keys(nodeDef.statics)) {
-                    if (!candidate.startsWith(segment))
-                        continue;
-                    if (segment === candidate) {
-                        for (const { to, reducer } of nodeDef.statics[candidate]) {
-                            nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
-                            debug(`      Static transition to ${to} found`);
-                        }
-                    }
-                    else {
-                        for (const { to, reducer } of nodeDef.statics[candidate]) {
-                            nextBranches.push({ node: to, state: Object.assign(Object.assign({}, state), { remainder: candidate.slice(segment.length) }) });
-                            debug(`      Static transition to ${to} found (partial match)`);
-                        }
-                    }
-                    hasMatches = true;
-                }
-                if (!hasMatches) {
-                    debug(`      No partial static transition found`);
-                }
-            }
-            if (segment !== END_OF_INPUT) {
-                for (const [test, { to, reducer }] of nodeDef.dynamics) {
-                    if (execute(tests, test, state, segment)) {
-                        nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
-                        debug(`      Dynamic transition to ${to} found (via ${test})`);
-                    }
-                }
-            }
-        }
-        if (nextBranches.length === 0 && segment === END_OF_INPUT && input.length === 1) {
-            return [{
-                    node: NODE_INITIAL,
-                    state: basicHelpState,
-                }];
-        }
-        if (nextBranches.length === 0) {
-            throw new UnknownSyntaxError(input, branches.filter(({ node }) => {
-                return node !== NODE_ERRORED;
-            }).map(({ state }) => {
-                return { usage: state.candidateUsage, reason: null };
-            }));
-        }
-        if (nextBranches.every(({ node }) => node === NODE_ERRORED)) {
-            throw new UnknownSyntaxError(input, nextBranches.map(({ state }) => {
-                return { usage: state.candidateUsage, reason: state.errorMessage };
-            }));
-        }
-        branches = trimSmallerBranches(nextBranches);
-    }
-    if (branches.length > 0) {
-        debug(`  Results:`);
-        for (const branch of branches) {
-            debug(`    - ${branch.node} -> ${JSON.stringify(branch.state)}`);
-        }
-    }
-    else {
-        debug(`  No results`);
-    }
-    return branches;
-}
-function checkIfNodeIsFinished(node, state) {
-    if (state.selectedIndex !== null)
-        return true;
-    if (Object.prototype.hasOwnProperty.call(node.statics, END_OF_INPUT))
-        for (const { to } of node.statics[END_OF_INPUT])
-            if (to === NODE_SUCCESS)
-                return true;
-    return false;
-}
-function suggestMachine(machine, input, partial) {
-    // If we're accepting partial matches, then exact matches need to be
-    // prefixed with an extra space.
-    const prefix = partial && input.length > 0 ? [``] : [];
-    const branches = runMachineInternal(machine, input, partial);
-    const suggestions = [];
-    const suggestionsJson = new Set();
-    const traverseSuggestion = (suggestion, node, skipFirst = true) => {
-        let nextNodes = [node];
-        while (nextNodes.length > 0) {
-            const currentNodes = nextNodes;
-            nextNodes = [];
-            for (const node of currentNodes) {
-                const nodeDef = machine.nodes[node];
-                const keys = Object.keys(nodeDef.statics);
-                for (const key of Object.keys(nodeDef.statics)) {
-                    const segment = keys[0];
-                    for (const { to, reducer } of nodeDef.statics[segment]) {
-                        if (reducer !== `pushPath`)
-                            continue;
-                        if (!skipFirst)
-                            suggestion.push(segment);
-                        nextNodes.push(to);
-                    }
-                }
-            }
-            skipFirst = false;
-        }
-        const json = JSON.stringify(suggestion);
-        if (suggestionsJson.has(json))
-            return;
-        suggestions.push(suggestion);
-        suggestionsJson.add(json);
-    };
-    for (const { node, state } of branches) {
-        if (state.remainder !== null) {
-            traverseSuggestion([state.remainder], node);
-            continue;
-        }
-        const nodeDef = machine.nodes[node];
-        const isFinished = checkIfNodeIsFinished(nodeDef, state);
-        for (const [candidate, transitions] of Object.entries(nodeDef.statics))
-            if ((isFinished && candidate !== END_OF_INPUT) || (!candidate.startsWith(`-`) && transitions.some(({ reducer }) => reducer === `pushPath`)))
-                traverseSuggestion([...prefix, candidate], node);
-        if (!isFinished)
-            continue;
-        for (const [test, { to }] of nodeDef.dynamics) {
-            if (to === NODE_ERRORED)
-                continue;
-            const tokens = suggest(test, state);
-            if (tokens === null)
-                continue;
-            for (const token of tokens) {
-                traverseSuggestion([...prefix, token], node);
-            }
-        }
-    }
-    return [...suggestions].sort();
+    return [...suggestions].sort();
 }
 function runMachine(machine, input) {
     const branches = runMachineInternal(machine, [...input, END_OF_INPUT]);
@@ -101110,6 +100429,688 @@ var gunzip = function (maxRecursion) {
 module.exports = gunzip
 
 
+/***/ }),
+
+/***/ 26214:
+/***/ ((module) => {
+
+"use strict";
+
+// rfc7231 6.1
+const statusCodeCacheableByDefault = new Set([
+    200,
+    203,
+    204,
+    206,
+    300,
+    301,
+    308,
+    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(/,/);
+    for (const part of parts) {
+        const [k, v] = part.split(/=/, 2);
+        cc[k.trim()] = v === undefined ? true : v.trim().replace(/^"|"$/g, '');
+    }
+
+    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,
+        };
+    }
+};
+
+
 /***/ }),
 
 /***/ 21354:
@@ -176230,7 +176231,7 @@ if ( true && module.exports) {
 /* module decorator */ module = __webpack_require__.nmd(module);
 
 try {
-  process.dlopen(module, __dirname + __webpack_require__(71017).sep + __webpack_require__.p + "eb317cf9255f67c17789c294700ceae7.node");
+  process.dlopen(module, __dirname + __webpack_require__(71017).sep + __webpack_require__.p + "17fed5a77894e71b805c3fa99ec729cf.node");
 } catch (error) {
   throw new Error('node-loader:\n' + error);
 }
@@ -176244,7 +176245,7 @@ try {
 /* module decorator */ module = __webpack_require__.nmd(module);
 
 try {
-  process.dlopen(module, __dirname + __webpack_require__(71017).sep + __webpack_require__.p + "92eff85f9573c780002e035fccee4980.node");
+  process.dlopen(module, __dirname + __webpack_require__(71017).sep + __webpack_require__.p + "64a3fccd81dc83aaf074ed7d2cf31fdf.node");
 } catch (error) {
   throw new Error('node-loader:\n' + error);
 }