@builderbot/bot 1.0.28-alpha.0 → 1.0.30-alpha.0

package/dist/index.cjs

@@ -854,166 +854,7 @@ var followRedirects = {exports: {}};
 
 var src$1 = {exports: {}};
 
-var node$1 = {exports: {}};
-
-var hasFlag;
-var hasRequiredHasFlag;
-
-function requireHasFlag () {
-	if (hasRequiredHasFlag) return hasFlag;
-	hasRequiredHasFlag = 1;
-
-	hasFlag = (flag, argv = process.argv) => {
-		const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
-		const position = argv.indexOf(prefix + flag);
-		const terminatorPosition = argv.indexOf('--');
-		return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-	};
-	return hasFlag;
-}
-
-var supportsColor_1;
-var hasRequiredSupportsColor;
-
-function requireSupportsColor () {
-	if (hasRequiredSupportsColor) return supportsColor_1;
-	hasRequiredSupportsColor = 1;
-	const os = require$$0$5;
-	const tty = require$$0$4;
-	const hasFlag = requireHasFlag();
-
-	const {env} = process;
-
-	let forceColor;
-	if (hasFlag('no-color') ||
-		hasFlag('no-colors') ||
-		hasFlag('color=false') ||
-		hasFlag('color=never')) {
-		forceColor = 0;
-	} else if (hasFlag('color') ||
-		hasFlag('colors') ||
-		hasFlag('color=true') ||
-		hasFlag('color=always')) {
-		forceColor = 1;
-	}
-
-	if ('FORCE_COLOR' in env) {
-		if (env.FORCE_COLOR === 'true') {
-			forceColor = 1;
-		} else if (env.FORCE_COLOR === 'false') {
-			forceColor = 0;
-		} else {
-			forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
-		}
-	}
-
-	function translateLevel(level) {
-		if (level === 0) {
-			return false;
-		}
-
-		return {
-			level,
-			hasBasic: true,
-			has256: level >= 2,
-			has16m: level >= 3
-		};
-	}
-
-	function supportsColor(haveStream, streamIsTTY) {
-		if (forceColor === 0) {
-			return 0;
-		}
-
-		if (hasFlag('color=16m') ||
-			hasFlag('color=full') ||
-			hasFlag('color=truecolor')) {
-			return 3;
-		}
-
-		if (hasFlag('color=256')) {
-			return 2;
-		}
-
-		if (haveStream && !streamIsTTY && forceColor === undefined) {
-			return 0;
-		}
-
-		const min = forceColor || 0;
-
-		if (env.TERM === 'dumb') {
-			return min;
-		}
-
-		if (process.platform === 'win32') {
-			// Windows 10 build 10586 is the first Windows release that supports 256 colors.
-			// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
-			const osRelease = os.release().split('.');
-			if (
-				Number(osRelease[0]) >= 10 &&
-				Number(osRelease[2]) >= 10586
-			) {
-				return Number(osRelease[2]) >= 14931 ? 3 : 2;
-			}
-
-			return 1;
-		}
-
-		if ('CI' in env) {
-			if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
-				return 1;
-			}
-
-			return min;
-		}
-
-		if ('TEAMCITY_VERSION' in env) {
-			return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-		}
-
-		if (env.COLORTERM === 'truecolor') {
-			return 3;
-		}
-
-		if ('TERM_PROGRAM' in env) {
-			const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
-
-			switch (env.TERM_PROGRAM) {
-				case 'iTerm.app':
-					return version >= 3 ? 3 : 2;
-				case 'Apple_Terminal':
-					return 2;
-				// No default
-			}
-		}
-
-		if (/-256(color)?$/i.test(env.TERM)) {
-			return 2;
-		}
-
-		if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-			return 1;
-		}
-
-		if ('COLORTERM' in env) {
-			return 1;
-		}
-
-		return min;
-	}
-
-	function getSupportLevel(stream) {
-		const level = supportsColor(stream, stream && stream.isTTY);
-		return translateLevel(level);
-	}
-
-	supportsColor_1 = {
-		supportsColor: getSupportLevel,
-		stdout: translateLevel(supportsColor(true, tty.isatty(1))),
-		stderr: translateLevel(supportsColor(true, tty.isatty(2)))
-	};
-	return supportsColor_1;
-}
+var browser$1 = {exports: {}};
 
 /**
  * Helpers.
@@ -1468,308 +1309,33 @@ function requireCommon () {
 	return common;
 }
 
-/**
- * Module dependencies.
- */
+/* eslint-env browser */
 
-var hasRequiredNode$1;
+var hasRequiredBrowser$1;
 
-function requireNode$1 () {
-	if (hasRequiredNode$1) return node$1.exports;
-	hasRequiredNode$1 = 1;
+function requireBrowser$1 () {
+	if (hasRequiredBrowser$1) return browser$1.exports;
+	hasRequiredBrowser$1 = 1;
 	(function (module, exports) {
-		const tty = require$$0$4;
-		const util = require$$1$1;
-
 		/**
-		 * This is the Node.js implementation of `debug()`.
+		 * This is the web browser implementation of `debug()`.
 		 */
 
-		exports.init = init;
-		exports.log = log;
 		exports.formatArgs = formatArgs;
 		exports.save = save;
 		exports.load = load;
 		exports.useColors = useColors;
-		exports.destroy = util.deprecate(
-			() => {},
-			'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
-		);
-
-		/**
-		 * Colors.
-		 */
-
-		exports.colors = [6, 2, 3, 4, 5, 1];
-
-		try {
-			// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
-			// eslint-disable-next-line import/no-extraneous-dependencies
-			const supportsColor = requireSupportsColor();
-
-			if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
-				exports.colors = [
-					20,
-					21,
-					26,
-					27,
-					32,
-					33,
-					38,
-					39,
-					40,
-					41,
-					42,
-					43,
-					44,
-					45,
-					56,
-					57,
-					62,
-					63,
-					68,
-					69,
-					74,
-					75,
-					76,
-					77,
-					78,
-					79,
-					80,
-					81,
-					92,
-					93,
-					98,
-					99,
-					112,
-					113,
-					128,
-					129,
-					134,
-					135,
-					148,
-					149,
-					160,
-					161,
-					162,
-					163,
-					164,
-					165,
-					166,
-					167,
-					168,
-					169,
-					170,
-					171,
-					172,
-					173,
-					178,
-					179,
-					184,
-					185,
-					196,
-					197,
-					198,
-					199,
-					200,
-					201,
-					202,
-					203,
-					204,
-					205,
-					206,
-					207,
-					208,
-					209,
-					214,
-					215,
-					220,
-					221
-				];
-			}
-		} catch (error) {
-			// Swallow - we only care if `supports-color` is available; it doesn't have to be.
-		}
-
-		/**
-		 * Build up the default `inspectOpts` object from the environment variables.
-		 *
-		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
-		 */
-
-		exports.inspectOpts = Object.keys(process.env).filter(key => {
-			return /^debug_/i.test(key);
-		}).reduce((obj, key) => {
-			// Camel-case
-			const prop = key
-				.substring(6)
-				.toLowerCase()
-				.replace(/_([a-z])/g, (_, k) => {
-					return k.toUpperCase();
-				});
-
-			// Coerce string value into JS value
-			let val = process.env[key];
-			if (/^(yes|on|true|enabled)$/i.test(val)) {
-				val = true;
-			} else if (/^(no|off|false|disabled)$/i.test(val)) {
-				val = false;
-			} else if (val === 'null') {
-				val = null;
-			} else {
-				val = Number(val);
-			}
-
-			obj[prop] = val;
-			return obj;
-		}, {});
-
-		/**
-		 * Is stdout a TTY? Colored output is enabled when `true`.
-		 */
-
-		function useColors() {
-			return 'colors' in exports.inspectOpts ?
-				Boolean(exports.inspectOpts.colors) :
-				tty.isatty(process.stderr.fd);
-		}
-
-		/**
-		 * Adds ANSI color escape codes if enabled.
-		 *
-		 * @api public
-		 */
-
-		function formatArgs(args) {
-			const {namespace: name, useColors} = this;
-
-			if (useColors) {
-				const c = this.color;
-				const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
-				const prefix = `  ${colorCode};1m${name} \u001B[0m`;
-
-				args[0] = prefix + args[0].split('\n').join('\n' + prefix);
-				args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
-			} else {
-				args[0] = getDate() + name + ' ' + args[0];
-			}
-		}
-
-		function getDate() {
-			if (exports.inspectOpts.hideDate) {
-				return '';
-			}
-			return new Date().toISOString() + ' ';
-		}
-
-		/**
-		 * Invokes `util.format()` with the specified arguments and writes to stderr.
-		 */
-
-		function log(...args) {
-			return process.stderr.write(util.format(...args) + '\n');
-		}
-
-		/**
-		 * Save `namespaces`.
-		 *
-		 * @param {String} namespaces
-		 * @api private
-		 */
-		function save(namespaces) {
-			if (namespaces) {
-				process.env.DEBUG = namespaces;
-			} else {
-				// If you set a process.env field to null or undefined, it gets cast to the
-				// string 'null' or 'undefined'. Just delete instead.
-				delete process.env.DEBUG;
-			}
-		}
-
-		/**
-		 * Load `namespaces`.
-		 *
-		 * @return {String} returns the previously persisted debug modes
-		 * @api private
-		 */
-
-		function load() {
-			return process.env.DEBUG;
-		}
-
-		/**
-		 * Init logic for `debug` instances.
-		 *
-		 * Create a new `inspectOpts` object in case `useColors` is set
-		 * differently for a particular `debug` instance.
-		 */
-
-		function init(debug) {
-			debug.inspectOpts = {};
-
-			const keys = Object.keys(exports.inspectOpts);
-			for (let i = 0; i < keys.length; i++) {
-				debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
-			}
-		}
-
-		module.exports = requireCommon()(exports);
-
-		const {formatters} = module.exports;
-
-		/**
-		 * Map %o to `util.inspect()`, all on a single line.
-		 */
-
-		formatters.o = function (v) {
-			this.inspectOpts.colors = this.useColors;
-			return util.inspect(v, this.inspectOpts)
-				.split('\n')
-				.map(str => str.trim())
-				.join(' ');
-		};
-
-		/**
-		 * Map %O to `util.inspect()`, allowing multiple lines if needed.
-		 */
-
-		formatters.O = function (v) {
-			this.inspectOpts.colors = this.useColors;
-			return util.inspect(v, this.inspectOpts);
-		}; 
-	} (node$1, node$1.exports));
-	return node$1.exports;
-}
-
-var browser$1 = {exports: {}};
-
-/* eslint-env browser */
-
-var hasRequiredBrowser$1;
-
-function requireBrowser$1 () {
-	if (hasRequiredBrowser$1) return browser$1.exports;
-	hasRequiredBrowser$1 = 1;
-	(function (module, exports) {
-		/**
-		 * This is the web browser implementation of `debug()`.
-		 */
-
-		exports.formatArgs = formatArgs;
-		exports.save = save;
-		exports.load = load;
-		exports.useColors = useColors;
-		exports.storage = localstorage();
-		exports.destroy = (() => {
-			let warned = false;
-
-			return () => {
-				if (!warned) {
-					warned = true;
-					console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
-				}
-			};
-		})();
+		exports.storage = localstorage();
+		exports.destroy = (() => {
+			let warned = false;
+
+			return () => {
+				if (!warned) {
+					warned = true;
+					console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+				}
+			};
+		})();
 
 		/**
 		 * Colors.
@@ -2022,37 +1588,471 @@ function requireBrowser$1 () {
 	return browser$1.exports;
 }
 
-/**
- * Detect Electron renderer / nwjs process, which is node, but we should
- * treat as a browser.
- */
+var node$1 = {exports: {}};
 
-var hasRequiredSrc$1;
+var hasFlag;
+var hasRequiredHasFlag;
 
-function requireSrc$1 () {
-	if (hasRequiredSrc$1) return src$1.exports;
-	hasRequiredSrc$1 = 1;
-	if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
-		src$1.exports = requireBrowser$1();
-	} else {
-		src$1.exports = requireNode$1();
-	}
-	return src$1.exports;
+function requireHasFlag () {
+	if (hasRequiredHasFlag) return hasFlag;
+	hasRequiredHasFlag = 1;
+
+	hasFlag = (flag, argv = process.argv) => {
+		const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+		const position = argv.indexOf(prefix + flag);
+		const terminatorPosition = argv.indexOf('--');
+		return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+	};
+	return hasFlag;
 }
 
-var debug$2;
+var supportsColor_1;
+var hasRequiredSupportsColor;
 
-var debug_1 = function () {
-  if (!debug$2) {
-    try {
-      /* eslint global-require: off */
-      debug$2 = requireSrc$1()("follow-redirects");
-    }
-    catch (error) { /* */ }
-    if (typeof debug$2 !== "function") {
-      debug$2 = function () { /* */ };
-    }
-  }
+function requireSupportsColor () {
+	if (hasRequiredSupportsColor) return supportsColor_1;
+	hasRequiredSupportsColor = 1;
+	const os = require$$0$5;
+	const tty = require$$0$4;
+	const hasFlag = requireHasFlag();
+
+	const {env} = process;
+
+	let forceColor;
+	if (hasFlag('no-color') ||
+		hasFlag('no-colors') ||
+		hasFlag('color=false') ||
+		hasFlag('color=never')) {
+		forceColor = 0;
+	} else if (hasFlag('color') ||
+		hasFlag('colors') ||
+		hasFlag('color=true') ||
+		hasFlag('color=always')) {
+		forceColor = 1;
+	}
+
+	if ('FORCE_COLOR' in env) {
+		if (env.FORCE_COLOR === 'true') {
+			forceColor = 1;
+		} else if (env.FORCE_COLOR === 'false') {
+			forceColor = 0;
+		} else {
+			forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+		}
+	}
+
+	function translateLevel(level) {
+		if (level === 0) {
+			return false;
+		}
+
+		return {
+			level,
+			hasBasic: true,
+			has256: level >= 2,
+			has16m: level >= 3
+		};
+	}
+
+	function supportsColor(haveStream, streamIsTTY) {
+		if (forceColor === 0) {
+			return 0;
+		}
+
+		if (hasFlag('color=16m') ||
+			hasFlag('color=full') ||
+			hasFlag('color=truecolor')) {
+			return 3;
+		}
+
+		if (hasFlag('color=256')) {
+			return 2;
+		}
+
+		if (haveStream && !streamIsTTY && forceColor === undefined) {
+			return 0;
+		}
+
+		const min = forceColor || 0;
+
+		if (env.TERM === 'dumb') {
+			return min;
+		}
+
+		if (process.platform === 'win32') {
+			// Windows 10 build 10586 is the first Windows release that supports 256 colors.
+			// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+			const osRelease = os.release().split('.');
+			if (
+				Number(osRelease[0]) >= 10 &&
+				Number(osRelease[2]) >= 10586
+			) {
+				return Number(osRelease[2]) >= 14931 ? 3 : 2;
+			}
+
+			return 1;
+		}
+
+		if ('CI' in env) {
+			if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+				return 1;
+			}
+
+			return min;
+		}
+
+		if ('TEAMCITY_VERSION' in env) {
+			return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+		}
+
+		if (env.COLORTERM === 'truecolor') {
+			return 3;
+		}
+
+		if ('TERM_PROGRAM' in env) {
+			const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+			switch (env.TERM_PROGRAM) {
+				case 'iTerm.app':
+					return version >= 3 ? 3 : 2;
+				case 'Apple_Terminal':
+					return 2;
+				// No default
+			}
+		}
+
+		if (/-256(color)?$/i.test(env.TERM)) {
+			return 2;
+		}
+
+		if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+			return 1;
+		}
+
+		if ('COLORTERM' in env) {
+			return 1;
+		}
+
+		return min;
+	}
+
+	function getSupportLevel(stream) {
+		const level = supportsColor(stream, stream && stream.isTTY);
+		return translateLevel(level);
+	}
+
+	supportsColor_1 = {
+		supportsColor: getSupportLevel,
+		stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+		stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+	};
+	return supportsColor_1;
+}
+
+/**
+ * Module dependencies.
+ */
+
+var hasRequiredNode$1;
+
+function requireNode$1 () {
+	if (hasRequiredNode$1) return node$1.exports;
+	hasRequiredNode$1 = 1;
+	(function (module, exports) {
+		const tty = require$$0$4;
+		const util = require$$1$1;
+
+		/**
+		 * This is the Node.js implementation of `debug()`.
+		 */
+
+		exports.init = init;
+		exports.log = log;
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.destroy = util.deprecate(
+			() => {},
+			'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
+		);
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [6, 2, 3, 4, 5, 1];
+
+		try {
+			// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+			// eslint-disable-next-line import/no-extraneous-dependencies
+			const supportsColor = requireSupportsColor();
+
+			if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+				exports.colors = [
+					20,
+					21,
+					26,
+					27,
+					32,
+					33,
+					38,
+					39,
+					40,
+					41,
+					42,
+					43,
+					44,
+					45,
+					56,
+					57,
+					62,
+					63,
+					68,
+					69,
+					74,
+					75,
+					76,
+					77,
+					78,
+					79,
+					80,
+					81,
+					92,
+					93,
+					98,
+					99,
+					112,
+					113,
+					128,
+					129,
+					134,
+					135,
+					148,
+					149,
+					160,
+					161,
+					162,
+					163,
+					164,
+					165,
+					166,
+					167,
+					168,
+					169,
+					170,
+					171,
+					172,
+					173,
+					178,
+					179,
+					184,
+					185,
+					196,
+					197,
+					198,
+					199,
+					200,
+					201,
+					202,
+					203,
+					204,
+					205,
+					206,
+					207,
+					208,
+					209,
+					214,
+					215,
+					220,
+					221
+				];
+			}
+		} catch (error) {
+			// Swallow - we only care if `supports-color` is available; it doesn't have to be.
+		}
+
+		/**
+		 * Build up the default `inspectOpts` object from the environment variables.
+		 *
+		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+		 */
+
+		exports.inspectOpts = Object.keys(process.env).filter(key => {
+			return /^debug_/i.test(key);
+		}).reduce((obj, key) => {
+			// Camel-case
+			const prop = key
+				.substring(6)
+				.toLowerCase()
+				.replace(/_([a-z])/g, (_, k) => {
+					return k.toUpperCase();
+				});
+
+			// Coerce string value into JS value
+			let val = process.env[key];
+			if (/^(yes|on|true|enabled)$/i.test(val)) {
+				val = true;
+			} else if (/^(no|off|false|disabled)$/i.test(val)) {
+				val = false;
+			} else if (val === 'null') {
+				val = null;
+			} else {
+				val = Number(val);
+			}
+
+			obj[prop] = val;
+			return obj;
+		}, {});
+
+		/**
+		 * Is stdout a TTY? Colored output is enabled when `true`.
+		 */
+
+		function useColors() {
+			return 'colors' in exports.inspectOpts ?
+				Boolean(exports.inspectOpts.colors) :
+				tty.isatty(process.stderr.fd);
+		}
+
+		/**
+		 * Adds ANSI color escape codes if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+			const {namespace: name, useColors} = this;
+
+			if (useColors) {
+				const c = this.color;
+				const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+				const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+
+				args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+				args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
+			} else {
+				args[0] = getDate() + name + ' ' + args[0];
+			}
+		}
+
+		function getDate() {
+			if (exports.inspectOpts.hideDate) {
+				return '';
+			}
+			return new Date().toISOString() + ' ';
+		}
+
+		/**
+		 * Invokes `util.format()` with the specified arguments and writes to stderr.
+		 */
+
+		function log(...args) {
+			return process.stderr.write(util.format(...args) + '\n');
+		}
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+		function save(namespaces) {
+			if (namespaces) {
+				process.env.DEBUG = namespaces;
+			} else {
+				// If you set a process.env field to null or undefined, it gets cast to the
+				// string 'null' or 'undefined'. Just delete instead.
+				delete process.env.DEBUG;
+			}
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+
+		function load() {
+			return process.env.DEBUG;
+		}
+
+		/**
+		 * Init logic for `debug` instances.
+		 *
+		 * Create a new `inspectOpts` object in case `useColors` is set
+		 * differently for a particular `debug` instance.
+		 */
+
+		function init(debug) {
+			debug.inspectOpts = {};
+
+			const keys = Object.keys(exports.inspectOpts);
+			for (let i = 0; i < keys.length; i++) {
+				debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+			}
+		}
+
+		module.exports = requireCommon()(exports);
+
+		const {formatters} = module.exports;
+
+		/**
+		 * Map %o to `util.inspect()`, all on a single line.
+		 */
+
+		formatters.o = function (v) {
+			this.inspectOpts.colors = this.useColors;
+			return util.inspect(v, this.inspectOpts)
+				.split('\n')
+				.map(str => str.trim())
+				.join(' ');
+		};
+
+		/**
+		 * Map %O to `util.inspect()`, allowing multiple lines if needed.
+		 */
+
+		formatters.O = function (v) {
+			this.inspectOpts.colors = this.useColors;
+			return util.inspect(v, this.inspectOpts);
+		}; 
+	} (node$1, node$1.exports));
+	return node$1.exports;
+}
+
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+
+var hasRequiredSrc$1;
+
+function requireSrc$1 () {
+	if (hasRequiredSrc$1) return src$1.exports;
+	hasRequiredSrc$1 = 1;
+	if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+		src$1.exports = requireBrowser$1();
+	} else {
+		src$1.exports = requireNode$1();
+	}
+	return src$1.exports;
+}
+
+var debug$2;
+
+var debug_1 = function () {
+  if (!debug$2) {
+    try {
+      /* eslint global-require: off */
+      debug$2 = requireSrc$1()("follow-redirects");
+    }
+    catch (error) { /* */ }
+    if (typeof debug$2 !== "function") {
+      debug$2 = function () { /* */ };
+    }
+  }
   debug$2.apply(null, arguments);
 };
 
@@ -2519,7 +2519,7 @@ RedirectableRequest.prototype._processResponse = function (response) {
      redirectUrl.protocol !== "https:" ||
      redirectUrl.host !== currentHost &&
      !isSubdomain(redirectUrl.host, currentHost)) {
-    removeMatchingHeaders(/^(?:authorization|cookie)$/i, this._options.headers);
+    removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
   }
 
   // Evaluate the beforeRedirect callback
@@ -16116,7 +16116,7 @@ function requireHttpErrors () {
 
 var src = {exports: {}};
 
-var node = {exports: {}};
+var browser = {exports: {}};
 
 var debug = {exports: {}};
 
@@ -16278,480 +16278,220 @@ function requireMs () {
 	  }
 	  return Math.ceil(ms / n) + ' ' + name + 's';
 	}
-	return ms;
-}
-
-var hasRequiredDebug;
-
-function requireDebug () {
-	if (hasRequiredDebug) return debug.exports;
-	hasRequiredDebug = 1;
-	(function (module, exports) {
-		/**
-		 * This is the common logic for both the Node.js and web browser
-		 * implementations of `debug()`.
-		 *
-		 * Expose `debug()` as the module.
-		 */
-
-		exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
-		exports.coerce = coerce;
-		exports.disable = disable;
-		exports.enable = enable;
-		exports.enabled = enabled;
-		exports.humanize = requireMs();
-
-		/**
-		 * The currently active debug mode names, and names to skip.
-		 */
-
-		exports.names = [];
-		exports.skips = [];
-
-		/**
-		 * Map of special "%n" handling functions, for the debug "format" argument.
-		 *
-		 * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
-		 */
-
-		exports.formatters = {};
-
-		/**
-		 * Previous log timestamp.
-		 */
-
-		var prevTime;
-
-		/**
-		 * Select a color.
-		 * @param {String} namespace
-		 * @return {Number}
-		 * @api private
-		 */
-
-		function selectColor(namespace) {
-		  var hash = 0, i;
-
-		  for (i in namespace) {
-		    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);
-		    hash |= 0; // Convert to 32bit integer
-		  }
-
-		  return exports.colors[Math.abs(hash) % exports.colors.length];
-		}
-
-		/**
-		 * Create a debugger with the given `namespace`.
-		 *
-		 * @param {String} namespace
-		 * @return {Function}
-		 * @api public
-		 */
-
-		function createDebug(namespace) {
-
-		  function debug() {
-		    // disabled?
-		    if (!debug.enabled) return;
-
-		    var self = debug;
-
-		    // set `diff` timestamp
-		    var curr = +new Date();
-		    var ms = curr - (prevTime || curr);
-		    self.diff = ms;
-		    self.prev = prevTime;
-		    self.curr = curr;
-		    prevTime = curr;
-
-		    // turn the `arguments` into a proper Array
-		    var args = new Array(arguments.length);
-		    for (var i = 0; i < args.length; i++) {
-		      args[i] = arguments[i];
-		    }
-
-		    args[0] = exports.coerce(args[0]);
-
-		    if ('string' !== typeof args[0]) {
-		      // anything else let's inspect with %O
-		      args.unshift('%O');
-		    }
-
-		    // apply any `formatters` transformations
-		    var index = 0;
-		    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
-		      // if we encounter an escaped % then don't increase the array index
-		      if (match === '%%') return match;
-		      index++;
-		      var formatter = exports.formatters[format];
-		      if ('function' === typeof formatter) {
-		        var val = args[index];
-		        match = formatter.call(self, val);
-
-		        // now we need to remove `args[index]` since it's inlined in the `format`
-		        args.splice(index, 1);
-		        index--;
-		      }
-		      return match;
-		    });
-
-		    // apply env-specific formatting (colors, etc.)
-		    exports.formatArgs.call(self, args);
-
-		    var logFn = debug.log || exports.log || console.log.bind(console);
-		    logFn.apply(self, args);
-		  }
-
-		  debug.namespace = namespace;
-		  debug.enabled = exports.enabled(namespace);
-		  debug.useColors = exports.useColors();
-		  debug.color = selectColor(namespace);
-
-		  // env-specific initialization logic for debug instances
-		  if ('function' === typeof exports.init) {
-		    exports.init(debug);
-		  }
-
-		  return debug;
-		}
-
-		/**
-		 * Enables a debug mode by namespaces. This can include modes
-		 * separated by a colon and wildcards.
-		 *
-		 * @param {String} namespaces
-		 * @api public
-		 */
-
-		function enable(namespaces) {
-		  exports.save(namespaces);
-
-		  exports.names = [];
-		  exports.skips = [];
-
-		  var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
-		  var len = split.length;
-
-		  for (var i = 0; i < len; i++) {
-		    if (!split[i]) continue; // ignore empty strings
-		    namespaces = split[i].replace(/\*/g, '.*?');
-		    if (namespaces[0] === '-') {
-		      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
-		    } else {
-		      exports.names.push(new RegExp('^' + namespaces + '$'));
-		    }
-		  }
-		}
-
-		/**
-		 * Disable debug output.
-		 *
-		 * @api public
-		 */
-
-		function disable() {
-		  exports.enable('');
-		}
-
-		/**
-		 * Returns true if the given mode name is enabled, false otherwise.
-		 *
-		 * @param {String} name
-		 * @return {Boolean}
-		 * @api public
-		 */
-
-		function enabled(name) {
-		  var i, len;
-		  for (i = 0, len = exports.skips.length; i < len; i++) {
-		    if (exports.skips[i].test(name)) {
-		      return false;
-		    }
-		  }
-		  for (i = 0, len = exports.names.length; i < len; i++) {
-		    if (exports.names[i].test(name)) {
-		      return true;
-		    }
-		  }
-		  return false;
-		}
-
-		/**
-		 * Coerce `val`.
-		 *
-		 * @param {Mixed} val
-		 * @return {Mixed}
-		 * @api private
-		 */
-
-		function coerce(val) {
-		  if (val instanceof Error) return val.stack || val.message;
-		  return val;
-		} 
-	} (debug, debug.exports));
-	return debug.exports;
-}
-
-/**
- * Module dependencies.
- */
-
-var hasRequiredNode;
-
-function requireNode () {
-	if (hasRequiredNode) return node.exports;
-	hasRequiredNode = 1;
-	(function (module, exports) {
-		var tty = require$$0$4;
-		var util = require$$1$1;
-
-		/**
-		 * This is the Node.js implementation of `debug()`.
-		 *
-		 * Expose `debug()` as the module.
-		 */
-
-		exports = module.exports = requireDebug();
-		exports.init = init;
-		exports.log = log;
-		exports.formatArgs = formatArgs;
-		exports.save = save;
-		exports.load = load;
-		exports.useColors = useColors;
-
-		/**
-		 * Colors.
-		 */
+	return ms;
+}
 
-		exports.colors = [6, 2, 3, 4, 5, 1];
+var hasRequiredDebug;
 
+function requireDebug () {
+	if (hasRequiredDebug) return debug.exports;
+	hasRequiredDebug = 1;
+	(function (module, exports) {
 		/**
-		 * Build up the default `inspectOpts` object from the environment variables.
+		 * This is the common logic for both the Node.js and web browser
+		 * implementations of `debug()`.
 		 *
-		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+		 * Expose `debug()` as the module.
 		 */
 
-		exports.inspectOpts = Object.keys(process.env).filter(function (key) {
-		  return /^debug_/i.test(key);
-		}).reduce(function (obj, key) {
-		  // camel-case
-		  var prop = key
-		    .substring(6)
-		    .toLowerCase()
-		    .replace(/_([a-z])/g, function (_, k) { return k.toUpperCase() });
+		exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
+		exports.coerce = coerce;
+		exports.disable = disable;
+		exports.enable = enable;
+		exports.enabled = enabled;
+		exports.humanize = requireMs();
 
-		  // coerce string value into JS value
-		  var val = process.env[key];
-		  if (/^(yes|on|true|enabled)$/i.test(val)) val = true;
-		  else if (/^(no|off|false|disabled)$/i.test(val)) val = false;
-		  else if (val === 'null') val = null;
-		  else val = Number(val);
+		/**
+		 * The currently active debug mode names, and names to skip.
+		 */
 
-		  obj[prop] = val;
-		  return obj;
-		}, {});
+		exports.names = [];
+		exports.skips = [];
 
 		/**
-		 * The file descriptor to write the `debug()` calls to.
-		 * Set the `DEBUG_FD` env variable to override with another value. i.e.:
+		 * Map of special "%n" handling functions, for the debug "format" argument.
 		 *
-		 *   $ DEBUG_FD=3 node script.js 3>debug.log
+		 * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
 		 */
 
-		var fd = parseInt(process.env.DEBUG_FD, 10) || 2;
-
-		if (1 !== fd && 2 !== fd) {
-		  util.deprecate(function(){}, 'except for stderr(2) and stdout(1), any other usage of DEBUG_FD is deprecated. Override debug.log if you want to use a different log function (https://git.io/debug_fd)')();
-		}
-
-		var stream = 1 === fd ? process.stdout :
-		             2 === fd ? process.stderr :
-		             createWritableStdioStream(fd);
+		exports.formatters = {};
 
 		/**
-		 * Is stdout a TTY? Colored output is enabled when `true`.
+		 * Previous log timestamp.
 		 */
 
-		function useColors() {
-		  return 'colors' in exports.inspectOpts
-		    ? Boolean(exports.inspectOpts.colors)
-		    : tty.isatty(fd);
-		}
+		var prevTime;
 
 		/**
-		 * Map %o to `util.inspect()`, all on a single line.
+		 * Select a color.
+		 * @param {String} namespace
+		 * @return {Number}
+		 * @api private
 		 */
 
-		exports.formatters.o = function(v) {
-		  this.inspectOpts.colors = this.useColors;
-		  return util.inspect(v, this.inspectOpts)
-		    .split('\n').map(function(str) {
-		      return str.trim()
-		    }).join(' ');
-		};
+		function selectColor(namespace) {
+		  var hash = 0, i;
 
-		/**
-		 * Map %o to `util.inspect()`, allowing multiple lines if needed.
-		 */
+		  for (i in namespace) {
+		    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);
+		    hash |= 0; // Convert to 32bit integer
+		  }
 
-		exports.formatters.O = function(v) {
-		  this.inspectOpts.colors = this.useColors;
-		  return util.inspect(v, this.inspectOpts);
-		};
+		  return exports.colors[Math.abs(hash) % exports.colors.length];
+		}
 
 		/**
-		 * Adds ANSI color escape codes if enabled.
+		 * Create a debugger with the given `namespace`.
 		 *
+		 * @param {String} namespace
+		 * @return {Function}
 		 * @api public
 		 */
 
-		function formatArgs(args) {
-		  var name = this.namespace;
-		  var useColors = this.useColors;
+		function createDebug(namespace) {
 
-		  if (useColors) {
-		    var c = this.color;
-		    var prefix = '  \u001b[3' + c + ';1m' + name + ' ' + '\u001b[0m';
+		  function debug() {
+		    // disabled?
+		    if (!debug.enabled) return;
 
-		    args[0] = prefix + args[0].split('\n').join('\n' + prefix);
-		    args.push('\u001b[3' + c + 'm+' + exports.humanize(this.diff) + '\u001b[0m');
-		  } else {
-		    args[0] = new Date().toUTCString()
-		      + ' ' + name + ' ' + args[0];
-		  }
-		}
+		    var self = debug;
 
-		/**
-		 * Invokes `util.format()` with the specified arguments and writes to `stream`.
-		 */
+		    // set `diff` timestamp
+		    var curr = +new Date();
+		    var ms = curr - (prevTime || curr);
+		    self.diff = ms;
+		    self.prev = prevTime;
+		    self.curr = curr;
+		    prevTime = curr;
 
-		function log() {
-		  return stream.write(util.format.apply(util, arguments) + '\n');
-		}
+		    // turn the `arguments` into a proper Array
+		    var args = new Array(arguments.length);
+		    for (var i = 0; i < args.length; i++) {
+		      args[i] = arguments[i];
+		    }
 
-		/**
-		 * Save `namespaces`.
-		 *
-		 * @param {String} namespaces
-		 * @api private
-		 */
+		    args[0] = exports.coerce(args[0]);
 
-		function save(namespaces) {
-		  if (null == namespaces) {
-		    // If you set a process.env field to null or undefined, it gets cast to the
-		    // string 'null' or 'undefined'. Just delete instead.
-		    delete process.env.DEBUG;
-		  } else {
-		    process.env.DEBUG = namespaces;
-		  }
-		}
+		    if ('string' !== typeof args[0]) {
+		      // anything else let's inspect with %O
+		      args.unshift('%O');
+		    }
 
-		/**
-		 * Load `namespaces`.
-		 *
-		 * @return {String} returns the previously persisted debug modes
-		 * @api private
-		 */
+		    // apply any `formatters` transformations
+		    var index = 0;
+		    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
+		      // if we encounter an escaped % then don't increase the array index
+		      if (match === '%%') return match;
+		      index++;
+		      var formatter = exports.formatters[format];
+		      if ('function' === typeof formatter) {
+		        var val = args[index];
+		        match = formatter.call(self, val);
 
-		function load() {
-		  return process.env.DEBUG;
-		}
+		        // now we need to remove `args[index]` since it's inlined in the `format`
+		        args.splice(index, 1);
+		        index--;
+		      }
+		      return match;
+		    });
 
-		/**
-		 * Copied from `node/src/node.js`.
-		 *
-		 * XXX: It's lame that node doesn't expose this API out-of-the-box. It also
-		 * relies on the undocumented `tty_wrap.guessHandleType()` which is also lame.
-		 */
+		    // apply env-specific formatting (colors, etc.)
+		    exports.formatArgs.call(self, args);
 
-		function createWritableStdioStream (fd) {
-		  var stream;
-		  var tty_wrap = process.binding('tty_wrap');
+		    var logFn = debug.log || exports.log || console.log.bind(console);
+		    logFn.apply(self, args);
+		  }
 
-		  // Note stream._type is used for test-module-load-list.js
+		  debug.namespace = namespace;
+		  debug.enabled = exports.enabled(namespace);
+		  debug.useColors = exports.useColors();
+		  debug.color = selectColor(namespace);
 
-		  switch (tty_wrap.guessHandleType(fd)) {
-		    case 'TTY':
-		      stream = new tty.WriteStream(fd);
-		      stream._type = 'tty';
+		  // env-specific initialization logic for debug instances
+		  if ('function' === typeof exports.init) {
+		    exports.init(debug);
+		  }
 
-		      // Hack to have stream not keep the event loop alive.
-		      // See https://github.com/joyent/node/issues/1726
-		      if (stream._handle && stream._handle.unref) {
-		        stream._handle.unref();
-		      }
-		      break;
+		  return debug;
+		}
 
-		    case 'FILE':
-		      var fs = require$$3$1;
-		      stream = new fs.SyncWriteStream(fd, { autoClose: false });
-		      stream._type = 'fs';
-		      break;
+		/**
+		 * Enables a debug mode by namespaces. This can include modes
+		 * separated by a colon and wildcards.
+		 *
+		 * @param {String} namespaces
+		 * @api public
+		 */
 
-		    case 'PIPE':
-		    case 'TCP':
-		      var net = require$$4$2;
-		      stream = new net.Socket({
-		        fd: fd,
-		        readable: false,
-		        writable: true
-		      });
+		function enable(namespaces) {
+		  exports.save(namespaces);
 
-		      // FIXME Should probably have an option in net.Socket to create a
-		      // stream from an existing fd which is writable only. But for now
-		      // we'll just add this hack and set the `readable` member to false.
-		      // Test: ./node test/fixtures/echo.js < /etc/passwd
-		      stream.readable = false;
-		      stream.read = null;
-		      stream._type = 'pipe';
+		  exports.names = [];
+		  exports.skips = [];
 
-		      // FIXME Hack to have stream not keep the event loop alive.
-		      // See https://github.com/joyent/node/issues/1726
-		      if (stream._handle && stream._handle.unref) {
-		        stream._handle.unref();
-		      }
-		      break;
+		  var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+		  var len = split.length;
 
-		    default:
-		      // Probably an error on in uv_guess_handle()
-		      throw new Error('Implement me. Unknown stream file type!');
+		  for (var i = 0; i < len; i++) {
+		    if (!split[i]) continue; // ignore empty strings
+		    namespaces = split[i].replace(/\*/g, '.*?');
+		    if (namespaces[0] === '-') {
+		      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+		    } else {
+		      exports.names.push(new RegExp('^' + namespaces + '$'));
+		    }
 		  }
+		}
 
-		  // For supporting legacy API we put the FD here.
-		  stream.fd = fd;
-
-		  stream._isStdio = true;
+		/**
+		 * Disable debug output.
+		 *
+		 * @api public
+		 */
 
-		  return stream;
+		function disable() {
+		  exports.enable('');
 		}
 
 		/**
-		 * Init logic for `debug` instances.
+		 * Returns true if the given mode name is enabled, false otherwise.
 		 *
-		 * Create a new `inspectOpts` object in case `useColors` is set
-		 * differently for a particular `debug` instance.
+		 * @param {String} name
+		 * @return {Boolean}
+		 * @api public
 		 */
 
-		function init (debug) {
-		  debug.inspectOpts = {};
-
-		  var keys = Object.keys(exports.inspectOpts);
-		  for (var i = 0; i < keys.length; i++) {
-		    debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+		function enabled(name) {
+		  var i, len;
+		  for (i = 0, len = exports.skips.length; i < len; i++) {
+		    if (exports.skips[i].test(name)) {
+		      return false;
+		    }
+		  }
+		  for (i = 0, len = exports.names.length; i < len; i++) {
+		    if (exports.names[i].test(name)) {
+		      return true;
+		    }
 		  }
+		  return false;
 		}
 
 		/**
-		 * Enable namespaces listed in `process.env.DEBUG` initially.
+		 * Coerce `val`.
+		 *
+		 * @param {Mixed} val
+		 * @return {Mixed}
+		 * @api private
 		 */
 
-		exports.enable(load()); 
-	} (node, node.exports));
-	return node.exports;
+		function coerce(val) {
+		  if (val instanceof Error) return val.stack || val.message;
+		  return val;
+		} 
+	} (debug, debug.exports));
+	return debug.exports;
 }
 
-var browser = {exports: {}};
-
 /**
  * This is the web browser implementation of `debug()`.
  *
@@ -16865,22 +16605,225 @@ function requireBrowser () {
 		    }
 		  });
 
-		  args.splice(lastC, 0, c);
+		  args.splice(lastC, 0, c);
+		}
+
+		/**
+		 * Invokes `console.log()` when available.
+		 * No-op when `console.log` is not a "function".
+		 *
+		 * @api public
+		 */
+
+		function log() {
+		  // this hackery is required for IE8/9, where
+		  // the `console.log` function doesn't have 'apply'
+		  return 'object' === typeof console
+		    && console.log
+		    && Function.prototype.apply.call(console.log, console, arguments);
+		}
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+
+		function save(namespaces) {
+		  try {
+		    if (null == namespaces) {
+		      exports.storage.removeItem('debug');
+		    } else {
+		      exports.storage.debug = namespaces;
+		    }
+		  } catch(e) {}
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+
+		function load() {
+		  var r;
+		  try {
+		    r = exports.storage.debug;
+		  } catch(e) {}
+
+		  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+		  if (!r && typeof process !== 'undefined' && 'env' in process) {
+		    r = process.env.DEBUG;
+		  }
+
+		  return r;
+		}
+
+		/**
+		 * Enable namespaces listed in `localStorage.debug` initially.
+		 */
+
+		exports.enable(load());
+
+		/**
+		 * Localstorage attempts to return the localstorage.
+		 *
+		 * This is necessary because safari throws
+		 * when a user disables cookies/localstorage
+		 * and you attempt to access it.
+		 *
+		 * @return {LocalStorage}
+		 * @api private
+		 */
+
+		function localstorage() {
+		  try {
+		    return window.localStorage;
+		  } catch (e) {}
+		} 
+	} (browser, browser.exports));
+	return browser.exports;
+}
+
+var node = {exports: {}};
+
+/**
+ * Module dependencies.
+ */
+
+var hasRequiredNode;
+
+function requireNode () {
+	if (hasRequiredNode) return node.exports;
+	hasRequiredNode = 1;
+	(function (module, exports) {
+		var tty = require$$0$4;
+		var util = require$$1$1;
+
+		/**
+		 * This is the Node.js implementation of `debug()`.
+		 *
+		 * Expose `debug()` as the module.
+		 */
+
+		exports = module.exports = requireDebug();
+		exports.init = init;
+		exports.log = log;
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [6, 2, 3, 4, 5, 1];
+
+		/**
+		 * Build up the default `inspectOpts` object from the environment variables.
+		 *
+		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+		 */
+
+		exports.inspectOpts = Object.keys(process.env).filter(function (key) {
+		  return /^debug_/i.test(key);
+		}).reduce(function (obj, key) {
+		  // camel-case
+		  var prop = key
+		    .substring(6)
+		    .toLowerCase()
+		    .replace(/_([a-z])/g, function (_, k) { return k.toUpperCase() });
+
+		  // coerce string value into JS value
+		  var val = process.env[key];
+		  if (/^(yes|on|true|enabled)$/i.test(val)) val = true;
+		  else if (/^(no|off|false|disabled)$/i.test(val)) val = false;
+		  else if (val === 'null') val = null;
+		  else val = Number(val);
+
+		  obj[prop] = val;
+		  return obj;
+		}, {});
+
+		/**
+		 * The file descriptor to write the `debug()` calls to.
+		 * Set the `DEBUG_FD` env variable to override with another value. i.e.:
+		 *
+		 *   $ DEBUG_FD=3 node script.js 3>debug.log
+		 */
+
+		var fd = parseInt(process.env.DEBUG_FD, 10) || 2;
+
+		if (1 !== fd && 2 !== fd) {
+		  util.deprecate(function(){}, 'except for stderr(2) and stdout(1), any other usage of DEBUG_FD is deprecated. Override debug.log if you want to use a different log function (https://git.io/debug_fd)')();
+		}
+
+		var stream = 1 === fd ? process.stdout :
+		             2 === fd ? process.stderr :
+		             createWritableStdioStream(fd);
+
+		/**
+		 * Is stdout a TTY? Colored output is enabled when `true`.
+		 */
+
+		function useColors() {
+		  return 'colors' in exports.inspectOpts
+		    ? Boolean(exports.inspectOpts.colors)
+		    : tty.isatty(fd);
+		}
+
+		/**
+		 * Map %o to `util.inspect()`, all on a single line.
+		 */
+
+		exports.formatters.o = function(v) {
+		  this.inspectOpts.colors = this.useColors;
+		  return util.inspect(v, this.inspectOpts)
+		    .split('\n').map(function(str) {
+		      return str.trim()
+		    }).join(' ');
+		};
+
+		/**
+		 * Map %o to `util.inspect()`, allowing multiple lines if needed.
+		 */
+
+		exports.formatters.O = function(v) {
+		  this.inspectOpts.colors = this.useColors;
+		  return util.inspect(v, this.inspectOpts);
+		};
+
+		/**
+		 * Adds ANSI color escape codes if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+		  var name = this.namespace;
+		  var useColors = this.useColors;
+
+		  if (useColors) {
+		    var c = this.color;
+		    var prefix = '  \u001b[3' + c + ';1m' + name + ' ' + '\u001b[0m';
+
+		    args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+		    args.push('\u001b[3' + c + 'm+' + exports.humanize(this.diff) + '\u001b[0m');
+		  } else {
+		    args[0] = new Date().toUTCString()
+		      + ' ' + name + ' ' + args[0];
+		  }
 		}
 
 		/**
-		 * Invokes `console.log()` when available.
-		 * No-op when `console.log` is not a "function".
-		 *
-		 * @api public
+		 * Invokes `util.format()` with the specified arguments and writes to `stream`.
 		 */
 
 		function log() {
-		  // this hackery is required for IE8/9, where
-		  // the `console.log` function doesn't have 'apply'
-		  return 'object' === typeof console
-		    && console.log
-		    && Function.prototype.apply.call(console.log, console, arguments);
+		  return stream.write(util.format.apply(util, arguments) + '\n');
 		}
 
 		/**
@@ -16891,13 +16834,13 @@ function requireBrowser () {
 		 */
 
 		function save(namespaces) {
-		  try {
-		    if (null == namespaces) {
-		      exports.storage.removeItem('debug');
-		    } else {
-		      exports.storage.debug = namespaces;
-		    }
-		  } catch(e) {}
+		  if (null == namespaces) {
+		    // If you set a process.env field to null or undefined, it gets cast to the
+		    // string 'null' or 'undefined'. Just delete instead.
+		    delete process.env.DEBUG;
+		  } else {
+		    process.env.DEBUG = namespaces;
+		  }
 		}
 
 		/**
@@ -16908,43 +16851,100 @@ function requireBrowser () {
 		 */
 
 		function load() {
-		  var r;
-		  try {
-		    r = exports.storage.debug;
-		  } catch(e) {}
+		  return process.env.DEBUG;
+		}
 
-		  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
-		  if (!r && typeof process !== 'undefined' && 'env' in process) {
-		    r = process.env.DEBUG;
+		/**
+		 * Copied from `node/src/node.js`.
+		 *
+		 * XXX: It's lame that node doesn't expose this API out-of-the-box. It also
+		 * relies on the undocumented `tty_wrap.guessHandleType()` which is also lame.
+		 */
+
+		function createWritableStdioStream (fd) {
+		  var stream;
+		  var tty_wrap = process.binding('tty_wrap');
+
+		  // Note stream._type is used for test-module-load-list.js
+
+		  switch (tty_wrap.guessHandleType(fd)) {
+		    case 'TTY':
+		      stream = new tty.WriteStream(fd);
+		      stream._type = 'tty';
+
+		      // Hack to have stream not keep the event loop alive.
+		      // See https://github.com/joyent/node/issues/1726
+		      if (stream._handle && stream._handle.unref) {
+		        stream._handle.unref();
+		      }
+		      break;
+
+		    case 'FILE':
+		      var fs = require$$3$1;
+		      stream = new fs.SyncWriteStream(fd, { autoClose: false });
+		      stream._type = 'fs';
+		      break;
+
+		    case 'PIPE':
+		    case 'TCP':
+		      var net = require$$4$2;
+		      stream = new net.Socket({
+		        fd: fd,
+		        readable: false,
+		        writable: true
+		      });
+
+		      // FIXME Should probably have an option in net.Socket to create a
+		      // stream from an existing fd which is writable only. But for now
+		      // we'll just add this hack and set the `readable` member to false.
+		      // Test: ./node test/fixtures/echo.js < /etc/passwd
+		      stream.readable = false;
+		      stream.read = null;
+		      stream._type = 'pipe';
+
+		      // FIXME Hack to have stream not keep the event loop alive.
+		      // See https://github.com/joyent/node/issues/1726
+		      if (stream._handle && stream._handle.unref) {
+		        stream._handle.unref();
+		      }
+		      break;
+
+		    default:
+		      // Probably an error on in uv_guess_handle()
+		      throw new Error('Implement me. Unknown stream file type!');
 		  }
 
-		  return r;
+		  // For supporting legacy API we put the FD here.
+		  stream.fd = fd;
+
+		  stream._isStdio = true;
+
+		  return stream;
 		}
 
 		/**
-		 * Enable namespaces listed in `localStorage.debug` initially.
+		 * Init logic for `debug` instances.
+		 *
+		 * Create a new `inspectOpts` object in case `useColors` is set
+		 * differently for a particular `debug` instance.
 		 */
 
-		exports.enable(load());
+		function init (debug) {
+		  debug.inspectOpts = {};
+
+		  var keys = Object.keys(exports.inspectOpts);
+		  for (var i = 0; i < keys.length; i++) {
+		    debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+		  }
+		}
 
 		/**
-		 * Localstorage attempts to return the localstorage.
-		 *
-		 * This is necessary because safari throws
-		 * when a user disables cookies/localstorage
-		 * and you attempt to access it.
-		 *
-		 * @return {LocalStorage}
-		 * @api private
+		 * Enable namespaces listed in `process.env.DEBUG` initially.
 		 */
 
-		function localstorage() {
-		  try {
-		    return window.localStorage;
-		  } catch (e) {}
-		} 
-	} (browser, browser.exports));
-	return browser.exports;
+		exports.enable(load()); 
+	} (node, node.exports));
+	return node.exports;
 }
 
 /**
@@ -30317,6 +30317,90 @@ function requireText () {
 	return text_1;
 }
 
+var esErrors;
+var hasRequiredEsErrors;
+
+function requireEsErrors () {
+	if (hasRequiredEsErrors) return esErrors;
+	hasRequiredEsErrors = 1;
+
+	/** @type {import('.')} */
+	esErrors = Error;
+	return esErrors;
+}
+
+var _eval;
+var hasRequired_eval;
+
+function require_eval () {
+	if (hasRequired_eval) return _eval;
+	hasRequired_eval = 1;
+
+	/** @type {import('./eval')} */
+	_eval = EvalError;
+	return _eval;
+}
+
+var range;
+var hasRequiredRange;
+
+function requireRange () {
+	if (hasRequiredRange) return range;
+	hasRequiredRange = 1;
+
+	/** @type {import('./range')} */
+	range = RangeError;
+	return range;
+}
+
+var ref;
+var hasRequiredRef;
+
+function requireRef () {
+	if (hasRequiredRef) return ref;
+	hasRequiredRef = 1;
+
+	/** @type {import('./ref')} */
+	ref = ReferenceError;
+	return ref;
+}
+
+var syntax;
+var hasRequiredSyntax;
+
+function requireSyntax () {
+	if (hasRequiredSyntax) return syntax;
+	hasRequiredSyntax = 1;
+
+	/** @type {import('./syntax')} */
+	syntax = SyntaxError;
+	return syntax;
+}
+
+var type;
+var hasRequiredType;
+
+function requireType () {
+	if (hasRequiredType) return type;
+	hasRequiredType = 1;
+
+	/** @type {import('./type')} */
+	type = TypeError;
+	return type;
+}
+
+var uri;
+var hasRequiredUri;
+
+function requireUri () {
+	if (hasRequiredUri) return uri;
+	hasRequiredUri = 1;
+
+	/** @type {import('./uri')} */
+	uri = URIError;
+	return uri;
+}
+
 var shams;
 var hasRequiredShams;
 
@@ -30396,13 +30480,17 @@ function requireHasProto () {
 	hasRequiredHasProto = 1;
 
 	var test = {
+		__proto__: null,
 		foo: {}
 	};
 
 	var $Object = Object;
 
+	/** @type {import('.')} */
 	hasProto = function hasProto() {
-		return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object);
+		// @ts-expect-error: TS errors on an inherited property for some reason
+		return { __proto__: test }.foo === test.foo
+			&& !(test instanceof $Object);
 	};
 	return hasProto;
 }
@@ -30523,7 +30611,7 @@ function requireHasown () {
 	var $hasOwn = Object.prototype.hasOwnProperty;
 	var bind = requireFunctionBind();
 
-	/** @type {(o: {}, p: PropertyKey) => p is keyof o} */
+	/** @type {import('.')} */
 	hasown = bind.call(call, $hasOwn);
 	return hasown;
 }
@@ -30537,9 +30625,15 @@ function requireGetIntrinsic () {
 
 	var undefined$1;
 
-	var $SyntaxError = SyntaxError;
+	var $Error = requireEsErrors();
+	var $EvalError = require_eval();
+	var $RangeError = requireRange();
+	var $ReferenceError = requireRef();
+	var $SyntaxError = requireSyntax();
+	var $TypeError = requireType();
+	var $URIError = requireUri();
+
 	var $Function = Function;
-	var $TypeError = TypeError;
 
 	// eslint-disable-next-line consistent-return
 	var getEvalledConstructor = function (expressionSyntax) {
@@ -30591,6 +30685,7 @@ function requireGetIntrinsic () {
 	var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined$1 : getProto(Uint8Array);
 
 	var INTRINSICS = {
+		__proto__: null,
 		'%AggregateError%': typeof AggregateError === 'undefined' ? undefined$1 : AggregateError,
 		'%Array%': Array,
 		'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined$1 : ArrayBuffer,
@@ -30611,9 +30706,9 @@ function requireGetIntrinsic () {
 		'%decodeURIComponent%': decodeURIComponent,
 		'%encodeURI%': encodeURI,
 		'%encodeURIComponent%': encodeURIComponent,
-		'%Error%': Error,
+		'%Error%': $Error,
 		'%eval%': eval, // eslint-disable-line no-eval
-		'%EvalError%': EvalError,
+		'%EvalError%': $EvalError,
 		'%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
 		'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
 		'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
@@ -30635,8 +30730,8 @@ function requireGetIntrinsic () {
 		'%parseInt%': parseInt,
 		'%Promise%': typeof Promise === 'undefined' ? undefined$1 : Promise,
 		'%Proxy%': typeof Proxy === 'undefined' ? undefined$1 : Proxy,
-		'%RangeError%': RangeError,
-		'%ReferenceError%': ReferenceError,
+		'%RangeError%': $RangeError,
+		'%ReferenceError%': $ReferenceError,
 		'%Reflect%': typeof Reflect === 'undefined' ? undefined$1 : Reflect,
 		'%RegExp%': RegExp,
 		'%Set%': typeof Set === 'undefined' ? undefined$1 : Set,
@@ -30653,7 +30748,7 @@ function requireGetIntrinsic () {
 		'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray,
 		'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array,
 		'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array,
-		'%URIError%': URIError,
+		'%URIError%': $URIError,
 		'%WeakMap%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap,
 		'%WeakRef%': typeof WeakRef === 'undefined' ? undefined$1 : WeakRef,
 		'%WeakSet%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet
@@ -30695,6 +30790,7 @@ function requireGetIntrinsic () {
 	};
 
 	var LEGACY_ALIASES = {
+		__proto__: null,
 		'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
 		'%ArrayPrototype%': ['Array', 'prototype'],
 		'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
@@ -30889,45 +30985,28 @@ function requireGetIntrinsic () {
 
 var callBind = {exports: {}};
 
-var hasPropertyDescriptors_1;
-var hasRequiredHasPropertyDescriptors;
+var esDefineProperty;
+var hasRequiredEsDefineProperty;
 
-function requireHasPropertyDescriptors () {
-	if (hasRequiredHasPropertyDescriptors) return hasPropertyDescriptors_1;
-	hasRequiredHasPropertyDescriptors = 1;
+function requireEsDefineProperty () {
+	if (hasRequiredEsDefineProperty) return esDefineProperty;
+	hasRequiredEsDefineProperty = 1;
 
 	var GetIntrinsic = requireGetIntrinsic();
 
-	var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
-
-	var hasPropertyDescriptors = function hasPropertyDescriptors() {
-		if ($defineProperty) {
-			try {
-				$defineProperty({}, 'a', { value: 1 });
-				return true;
-			} catch (e) {
-				// IE 8 has a broken defineProperty
-				return false;
-			}
-		}
-		return false;
-	};
-
-	hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
-		// node v0.6 has a bug where array lengths can be Set but not Defined
-		if (!hasPropertyDescriptors()) {
-			return null;
-		}
+	/** @type {import('.')} */
+	var $defineProperty = GetIntrinsic('%Object.defineProperty%', true) || false;
+	if ($defineProperty) {
 		try {
-			return $defineProperty([], 'length', { value: 1 }).length !== 1;
+			$defineProperty({}, 'a', { value: 1 });
 		} catch (e) {
-			// In Firefox 4-22, defining length on an array throws an exception.
-			return true;
+			// IE 8 has a broken defineProperty
+			$defineProperty = false;
 		}
-	};
+	}
 
-	hasPropertyDescriptors_1 = hasPropertyDescriptors;
-	return hasPropertyDescriptors_1;
+	esDefineProperty = $defineProperty;
+	return esDefineProperty;
 }
 
 var gopd;
@@ -30961,26 +31040,14 @@ function requireDefineDataProperty () {
 	if (hasRequiredDefineDataProperty) return defineDataProperty;
 	hasRequiredDefineDataProperty = 1;
 
-	var hasPropertyDescriptors = requireHasPropertyDescriptors()();
+	var $defineProperty = requireEsDefineProperty();
 
-	var GetIntrinsic = requireGetIntrinsic();
-
-	var $defineProperty = hasPropertyDescriptors && GetIntrinsic('%Object.defineProperty%', true);
-	if ($defineProperty) {
-		try {
-			$defineProperty({}, 'a', { value: 1 });
-		} catch (e) {
-			// IE 8 has a broken defineProperty
-			$defineProperty = false;
-		}
-	}
-
-	var $SyntaxError = GetIntrinsic('%SyntaxError%');
-	var $TypeError = GetIntrinsic('%TypeError%');
+	var $SyntaxError = requireSyntax();
+	var $TypeError = requireType();
 
 	var gopd = requireGopd();
 
-	/** @type {(obj: Record<PropertyKey, unknown>, property: PropertyKey, value: unknown, nonEnumerable?: boolean | null, nonWritable?: boolean | null, nonConfigurable?: boolean | null, loose?: boolean) => void} */
+	/** @type {import('.')} */
 	defineDataProperty = function defineDataProperty(
 		obj,
 		property,
@@ -31030,6 +31097,36 @@ function requireDefineDataProperty () {
 	return defineDataProperty;
 }
 
+var hasPropertyDescriptors_1;
+var hasRequiredHasPropertyDescriptors;
+
+function requireHasPropertyDescriptors () {
+	if (hasRequiredHasPropertyDescriptors) return hasPropertyDescriptors_1;
+	hasRequiredHasPropertyDescriptors = 1;
+
+	var $defineProperty = requireEsDefineProperty();
+
+	var hasPropertyDescriptors = function hasPropertyDescriptors() {
+		return !!$defineProperty;
+	};
+
+	hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
+		// node v0.6 has a bug where array lengths can be Set but not Defined
+		if (!$defineProperty) {
+			return null;
+		}
+		try {
+			return $defineProperty([], 'length', { value: 1 }).length !== 1;
+		} catch (e) {
+			// In Firefox 4-22, defining length on an array throws an exception.
+			return true;
+		}
+	};
+
+	hasPropertyDescriptors_1 = hasPropertyDescriptors;
+	return hasPropertyDescriptors_1;
+}
+
 var setFunctionLength;
 var hasRequiredSetFunctionLength;
 
@@ -31042,9 +31139,10 @@ function requireSetFunctionLength () {
 	var hasDescriptors = requireHasPropertyDescriptors()();
 	var gOPD = requireGopd();
 
-	var $TypeError = GetIntrinsic('%TypeError%');
+	var $TypeError = requireType();
 	var $floor = GetIntrinsic('%Math.floor%');
 
+	/** @type {import('.')} */
 	setFunctionLength = function setFunctionLength(fn, length) {
 		if (typeof fn !== 'function') {
 			throw new $TypeError('`fn` is not a function');
@@ -31069,9 +31167,9 @@ function requireSetFunctionLength () {
 
 		if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
 			if (hasDescriptors) {
-				define(fn, 'length', length, true, true);
+				define(/** @type {Parameters<define>[0]} */ (fn), 'length', length, true, true);
 			} else {
-				define(fn, 'length', length);
+				define(/** @type {Parameters<define>[0]} */ (fn), 'length', length);
 			}
 		}
 		return fn;
@@ -31090,23 +31188,14 @@ function requireCallBind () {
 		var GetIntrinsic = requireGetIntrinsic();
 		var setFunctionLength = requireSetFunctionLength();
 
-		var $TypeError = GetIntrinsic('%TypeError%');
+		var $TypeError = requireType();
 		var $apply = GetIntrinsic('%Function.prototype.apply%');
 		var $call = GetIntrinsic('%Function.prototype.call%');
 		var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);
 
-		var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
+		var $defineProperty = requireEsDefineProperty();
 		var $max = GetIntrinsic('%Math.max%');
 
-		if ($defineProperty) {
-			try {
-				$defineProperty({}, 'a', { value: 1 });
-			} catch (e) {
-				// IE 8 has a broken defineProperty
-				$defineProperty = null;
-			}
-		}
-
 		module.exports = function callBind(originalFunction) {
 			if (typeof originalFunction !== 'function') {
 				throw new $TypeError('a function is required');
@@ -31709,7 +31798,7 @@ function requireSideChannel () {
 	var callBound = requireCallBound();
 	var inspect = requireObjectInspect();
 
-	var $TypeError = GetIntrinsic('%TypeError%');
+	var $TypeError = requireType();
 	var $WeakMap = GetIntrinsic('%WeakMap%', true);
 	var $Map = GetIntrinsic('%Map%', true);
 
@@ -31721,49 +31810,58 @@ function requireSideChannel () {
 	var $mapHas = callBound('Map.prototype.has', true);
 
 	/*
-	 * This function traverses the list returning the node corresponding to the
-	 * given key.
-	 *
-	 * That node is also moved to the head of the list, so that if it's accessed
-	 * again we don't need to traverse the whole list. By doing so, all the recently
-	 * used nodes can be accessed relatively quickly.
-	 */
+	* This function traverses the list returning the node corresponding to the given key.
+	*
+	* That node is also moved to the head of the list, so that if it's accessed again we don't need to traverse the whole list. By doing so, all the recently used nodes can be accessed relatively quickly.
+	*/
+	/** @type {import('.').listGetNode} */
 	var listGetNode = function (list, key) { // eslint-disable-line consistent-return
-		for (var prev = list, curr; (curr = prev.next) !== null; prev = curr) {
+		/** @type {typeof list | NonNullable<(typeof list)['next']>} */
+		var prev = list;
+		/** @type {(typeof list)['next']} */
+		var curr;
+		for (; (curr = prev.next) !== null; prev = curr) {
 			if (curr.key === key) {
 				prev.next = curr.next;
-				curr.next = list.next;
+				// eslint-disable-next-line no-extra-parens
+				curr.next = /** @type {NonNullable<typeof list.next>} */ (list.next);
 				list.next = curr; // eslint-disable-line no-param-reassign
 				return curr;
 			}
 		}
 	};
 
+	/** @type {import('.').listGet} */
 	var listGet = function (objects, key) {
 		var node = listGetNode(objects, key);
 		return node && node.value;
 	};
+	/** @type {import('.').listSet} */
 	var listSet = function (objects, key, value) {
 		var node = listGetNode(objects, key);
 		if (node) {
 			node.value = value;
 		} else {
 			// Prepend the new node to the beginning of the list
-			objects.next = { // eslint-disable-line no-param-reassign
+			objects.next = /** @type {import('.').ListNode<typeof value>} */ ({ // eslint-disable-line no-param-reassign, no-extra-parens
 				key: key,
 				next: objects.next,
 				value: value
-			};
+			});
 		}
 	};
+	/** @type {import('.').listHas} */
 	var listHas = function (objects, key) {
 		return !!listGetNode(objects, key);
 	};
 
+	/** @type {import('.')} */
 	sideChannel = function getSideChannel() {
-		var $wm;
-		var $m;
-		var $o;
+		/** @type {WeakMap<object, unknown>} */ var $wm;
+		/** @type {Map<object, unknown>} */ var $m;
+		/** @type {import('.').RootNode<unknown>} */ var $o;
+
+		/** @type {import('.').Channel} */
 		var channel = {
 			assert: function (key) {
 				if (!channel.has(key)) {
@@ -31814,11 +31912,7 @@ function requireSideChannel () {
 					$mapSet($m, key, value);
 				} else {
 					if (!$o) {
-						/*
-						 * Initialize the linked list as an empty node, so that we don't have
-						 * to special-case handling of the first node: we can always refer to
-						 * it as (previous node).next, instead of something like (list).head
-						 */
+						// Initialize the linked list as an empty node, so that we don't have to special-case handling of the first node: we can always refer to it as (previous node).next, instead of something like (list).head
 						$o = { key: {}, next: null };
 					}
 					listSet($o, key, value);