@venos-inc/venos 0.1.5 → 0.1.7

package/etc/mcp-server/node_modules/vite/dist/node-cjs/publicUtils.cjs

@@ -1,32 +1,54 @@
 'use strict';
 
-var path$3 = require('node:path');
+var path$1 = require('node:path');
 var node_url = require('node:url');
 var fs$1 = require('node:fs');
 var esbuild = require('esbuild');
+var node_child_process = require('node:child_process');
 var node_module = require('node:module');
 var require$$0 = require('tty');
 var require$$1 = require('util');
-var require$$0$1 = require('path');
-var require$$0$2 = require('crypto');
-var fs$2 = require('fs');
+var require$$1$1 = require('path');
+var pm = require('picomatch');
+var require$$0$1 = require('crypto');
+var require$$1$2 = require('fs');
 var readline = require('node:readline');
 var require$$2 = require('os');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 const { version: version$2 } = JSON.parse(
-  fs$1.readFileSync(new URL("../../package.json", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))).toString()
+  fs$1.readFileSync(new URL("../../package.json", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))).toString()
 );
 const VERSION = version$2;
+const DEFAULT_MAIN_FIELDS = [
+  "browser",
+  "module",
+  "jsnext:main",
+  // moment still uses this...
+  "jsnext"
+];
+const DEFAULT_CLIENT_MAIN_FIELDS = Object.freeze(DEFAULT_MAIN_FIELDS);
+const DEFAULT_SERVER_MAIN_FIELDS = Object.freeze(
+  DEFAULT_MAIN_FIELDS.filter((f) => f !== "browser")
+);
+const DEV_PROD_CONDITION = `development|production`;
+const DEFAULT_CONDITIONS = ["module", "browser", "node", DEV_PROD_CONDITION];
+const DEFAULT_CLIENT_CONDITIONS = Object.freeze(
+  DEFAULT_CONDITIONS.filter((c) => c !== "node")
+);
+const DEFAULT_SERVER_CONDITIONS = Object.freeze(
+  DEFAULT_CONDITIONS.filter((c) => c !== "browser")
+);
 const FS_PREFIX = `/@fs/`;
-const VITE_PACKAGE_DIR = path$3.resolve(
+const VITE_PACKAGE_DIR = path$1.resolve(
   // import.meta.url is `dist/node/constants.js` after bundle
-  node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))),
+  node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))),
   "../../.."
 );
-const CLIENT_ENTRY = path$3.resolve(VITE_PACKAGE_DIR, "dist/client/client.mjs");
-path$3.resolve(VITE_PACKAGE_DIR, "dist/client/env.mjs");
-path$3.dirname(CLIENT_ENTRY);
+const CLIENT_ENTRY = path$1.resolve(VITE_PACKAGE_DIR, "dist/client/client.mjs");
+path$1.resolve(VITE_PACKAGE_DIR, "dist/client/env.mjs");
+path$1.dirname(CLIENT_ENTRY);
+const defaultAllowedOrigins = /^https?:\/\/(?:(?:[^:]+\.)?localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/;
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -125,35 +147,21 @@ function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-function commonjsRequire(path) {
-	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
-
 var picocolors = {exports: {}};
 
-let argv = process.argv || [],
-	env = process.env;
+let p = process || {}, argv = p.argv || [], env = p.env || {};
 let isColorSupported =
-	!("NO_COLOR" in env || argv.includes("--no-color")) &&
-	("FORCE_COLOR" in env ||
-		argv.includes("--color") ||
-		process.platform === "win32" ||
-		(commonjsRequire != null && require$$0.isatty(1) && env.TERM !== "dumb") ||
-		"CI" in env);
-
-let formatter =
-	(open, close, replace = open) =>
+	!(!!env.NO_COLOR || argv.includes("--no-color")) &&
+	(!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || ((p.stdout || {}).isTTY && env.TERM !== "dumb") || !!env.CI);
+
+let formatter = (open, close, replace = open) =>
 	input => {
-		let string = "" + input;
-		let index = string.indexOf(close, open.length);
-		return ~index
-			? open + replaceClose(string, close, replace, index) + close
-			: open + string + close
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close
 	};
 
 let replaceClose = (string, close, replace, index) => {
-	let result = "";
-	let cursor = 0;
+	let result = "", cursor = 0;
 	do {
 		result += string.substring(cursor, index) + replace;
 		cursor = index + close.length;
@@ -163,34 +171,54 @@ let replaceClose = (string, close, replace, index) => {
 };
 
 let createColors = (enabled = isColorSupported) => {
-	let init = enabled ? formatter : () => String;
+	let f = enabled ? formatter : () => String;
 	return {
 		isColorSupported: enabled,
-		reset: init("\x1b[0m", "\x1b[0m"),
-		bold: init("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
-		dim: init("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
-		italic: init("\x1b[3m", "\x1b[23m"),
-		underline: init("\x1b[4m", "\x1b[24m"),
-		inverse: init("\x1b[7m", "\x1b[27m"),
-		hidden: init("\x1b[8m", "\x1b[28m"),
-		strikethrough: init("\x1b[9m", "\x1b[29m"),
-		black: init("\x1b[30m", "\x1b[39m"),
-		red: init("\x1b[31m", "\x1b[39m"),
-		green: init("\x1b[32m", "\x1b[39m"),
-		yellow: init("\x1b[33m", "\x1b[39m"),
-		blue: init("\x1b[34m", "\x1b[39m"),
-		magenta: init("\x1b[35m", "\x1b[39m"),
-		cyan: init("\x1b[36m", "\x1b[39m"),
-		white: init("\x1b[37m", "\x1b[39m"),
-		gray: init("\x1b[90m", "\x1b[39m"),
-		bgBlack: init("\x1b[40m", "\x1b[49m"),
-		bgRed: init("\x1b[41m", "\x1b[49m"),
-		bgGreen: init("\x1b[42m", "\x1b[49m"),
-		bgYellow: init("\x1b[43m", "\x1b[49m"),
-		bgBlue: init("\x1b[44m", "\x1b[49m"),
-		bgMagenta: init("\x1b[45m", "\x1b[49m"),
-		bgCyan: init("\x1b[46m", "\x1b[49m"),
-		bgWhite: init("\x1b[47m", "\x1b[49m"),
+		reset: f("\x1b[0m", "\x1b[0m"),
+		bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+		dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+		italic: f("\x1b[3m", "\x1b[23m"),
+		underline: f("\x1b[4m", "\x1b[24m"),
+		inverse: f("\x1b[7m", "\x1b[27m"),
+		hidden: f("\x1b[8m", "\x1b[28m"),
+		strikethrough: f("\x1b[9m", "\x1b[29m"),
+
+		black: f("\x1b[30m", "\x1b[39m"),
+		red: f("\x1b[31m", "\x1b[39m"),
+		green: f("\x1b[32m", "\x1b[39m"),
+		yellow: f("\x1b[33m", "\x1b[39m"),
+		blue: f("\x1b[34m", "\x1b[39m"),
+		magenta: f("\x1b[35m", "\x1b[39m"),
+		cyan: f("\x1b[36m", "\x1b[39m"),
+		white: f("\x1b[37m", "\x1b[39m"),
+		gray: f("\x1b[90m", "\x1b[39m"),
+
+		bgBlack: f("\x1b[40m", "\x1b[49m"),
+		bgRed: f("\x1b[41m", "\x1b[49m"),
+		bgGreen: f("\x1b[42m", "\x1b[49m"),
+		bgYellow: f("\x1b[43m", "\x1b[49m"),
+		bgBlue: f("\x1b[44m", "\x1b[49m"),
+		bgMagenta: f("\x1b[45m", "\x1b[49m"),
+		bgCyan: f("\x1b[46m", "\x1b[49m"),
+		bgWhite: f("\x1b[47m", "\x1b[49m"),
+
+		blackBright: f("\x1b[90m", "\x1b[39m"),
+		redBright: f("\x1b[91m", "\x1b[39m"),
+		greenBright: f("\x1b[92m", "\x1b[39m"),
+		yellowBright: f("\x1b[93m", "\x1b[39m"),
+		blueBright: f("\x1b[94m", "\x1b[39m"),
+		magentaBright: f("\x1b[95m", "\x1b[39m"),
+		cyanBright: f("\x1b[96m", "\x1b[39m"),
+		whiteBright: f("\x1b[97m", "\x1b[39m"),
+
+		bgBlackBright: f("\x1b[100m", "\x1b[49m"),
+		bgRedBright: f("\x1b[101m", "\x1b[49m"),
+		bgGreenBright: f("\x1b[102m", "\x1b[49m"),
+		bgYellowBright: f("\x1b[103m", "\x1b[49m"),
+		bgBlueBright: f("\x1b[104m", "\x1b[49m"),
+		bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
+		bgCyanBright: f("\x1b[106m", "\x1b[49m"),
+		bgWhiteBright: f("\x1b[107m", "\x1b[49m"),
 	}
 };
 
@@ -200,9 +228,7 @@ picocolors.exports.createColors = createColors;
 var picocolorsExports = picocolors.exports;
 var colors = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
 
-var src = {exports: {}};
-
-var browser$1 = {exports: {}};
+var node = {exports: {}};
 
 /**
  * Helpers.
@@ -235,7 +261,7 @@ function requireMs () {
 	 * @api public
 	 */
 
-	ms = function(val, options) {
+	ms = function (val, options) {
 	  options = options || {};
 	  var type = typeof val;
 	  if (type === 'string' && val.length > 0) {
@@ -548,24 +574,62 @@ function requireCommon () {
 			createDebug.names = [];
 			createDebug.skips = [];
 
-			let i;
-			const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
-			const len = split.length;
+			const split = (typeof namespaces === 'string' ? namespaces : '')
+				.trim()
+				.replace(' ', ',')
+				.split(',')
+				.filter(Boolean);
 
-			for (i = 0; i < len; i++) {
-				if (!split[i]) {
-					// ignore empty strings
-					continue;
+			for (const ns of split) {
+				if (ns[0] === '-') {
+					createDebug.skips.push(ns.slice(1));
+				} else {
+					createDebug.names.push(ns);
 				}
+			}
+		}
 
-				namespaces = split[i].replace(/\*/g, '.*?');
-
-				if (namespaces[0] === '-') {
-					createDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));
+		/**
+		 * Checks if the given string matches a namespace template, honoring
+		 * asterisks as wildcards.
+		 *
+		 * @param {String} search
+		 * @param {String} template
+		 * @return {Boolean}
+		 */
+		function matchesTemplate(search, template) {
+			let searchIndex = 0;
+			let templateIndex = 0;
+			let starIndex = -1;
+			let matchIndex = 0;
+
+			while (searchIndex < search.length) {
+				if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === '*')) {
+					// Match character or proceed with wildcard
+					if (template[templateIndex] === '*') {
+						starIndex = templateIndex;
+						matchIndex = searchIndex;
+						templateIndex++; // Skip the '*'
+					} else {
+						searchIndex++;
+						templateIndex++;
+					}
+				} else if (starIndex !== -1) { // eslint-disable-line no-negated-condition
+					// Backtrack to the last '*' and try to match more characters
+					templateIndex = starIndex + 1;
+					matchIndex++;
+					searchIndex = matchIndex;
 				} else {
-					createDebug.names.push(new RegExp('^' + namespaces + '$'));
+					return false; // No match
 				}
 			}
+
+			// Handle trailing '*' in template
+			while (templateIndex < template.length && template[templateIndex] === '*') {
+				templateIndex++;
+			}
+
+			return templateIndex === template.length;
 		}
 
 		/**
@@ -576,8 +640,8 @@ function requireCommon () {
 		*/
 		function disable() {
 			const namespaces = [
-				...createDebug.names.map(toNamespace),
-				...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
+				...createDebug.names,
+				...createDebug.skips.map(namespace => '-' + namespace)
 			].join(',');
 			createDebug.enable('');
 			return namespaces;
@@ -591,21 +655,14 @@ function requireCommon () {
 		* @api public
 		*/
 		function enabled(name) {
-			if (name[name.length - 1] === '*') {
-				return true;
-			}
-
-			let i;
-			let len;
-
-			for (i = 0, len = createDebug.skips.length; i < len; i++) {
-				if (createDebug.skips[i].test(name)) {
+			for (const skip of createDebug.skips) {
+				if (matchesTemplate(name, skip)) {
 					return false;
 				}
 			}
 
-			for (i = 0, len = createDebug.names.length; i < len; i++) {
-				if (createDebug.names[i].test(name)) {
+			for (const ns of createDebug.names) {
+				if (matchesTemplate(name, ns)) {
 					return true;
 				}
 			}
@@ -613,19 +670,6 @@ function requireCommon () {
 			return false;
 		}
 
-		/**
-		* Convert regexp to namespace
-		*
-		* @param {RegExp} regxep
-		* @return {String} namespace
-		* @api private
-		*/
-		function toNamespace(regexp) {
-			return regexp.toString()
-				.substring(2, regexp.toString().length - 2)
-				.replace(/\.\*\?$/, '*');
-		}
-
 		/**
 		* Coerce `val`.
 		*
@@ -637,2659 +681,294 @@ function requireCommon () {
 			if (val instanceof Error) {
 				return val.stack || val.message;
 			}
-			return val;
-		}
-
-		/**
-		* XXX DO NOT USE. This is a temporary stub function.
-		* XXX It WILL be removed in the next major release.
-		*/
-		function destroy() {
-			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
-		}
-
-		createDebug.enable(createDebug.load());
-
-		return createDebug;
-	}
-
-	common = setup;
-	return common;
-}
-
-/* eslint-env browser */
-
-var hasRequiredBrowser;
-
-function requireBrowser () {
-	if (hasRequiredBrowser) return browser$1.exports;
-	hasRequiredBrowser = 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`.');
-				}
-			};
-		})();
-
-		/**
-		 * Colors.
-		 */
-
-		exports.colors = [
-			'#0000CC',
-			'#0000FF',
-			'#0033CC',
-			'#0033FF',
-			'#0066CC',
-			'#0066FF',
-			'#0099CC',
-			'#0099FF',
-			'#00CC00',
-			'#00CC33',
-			'#00CC66',
-			'#00CC99',
-			'#00CCCC',
-			'#00CCFF',
-			'#3300CC',
-			'#3300FF',
-			'#3333CC',
-			'#3333FF',
-			'#3366CC',
-			'#3366FF',
-			'#3399CC',
-			'#3399FF',
-			'#33CC00',
-			'#33CC33',
-			'#33CC66',
-			'#33CC99',
-			'#33CCCC',
-			'#33CCFF',
-			'#6600CC',
-			'#6600FF',
-			'#6633CC',
-			'#6633FF',
-			'#66CC00',
-			'#66CC33',
-			'#9900CC',
-			'#9900FF',
-			'#9933CC',
-			'#9933FF',
-			'#99CC00',
-			'#99CC33',
-			'#CC0000',
-			'#CC0033',
-			'#CC0066',
-			'#CC0099',
-			'#CC00CC',
-			'#CC00FF',
-			'#CC3300',
-			'#CC3333',
-			'#CC3366',
-			'#CC3399',
-			'#CC33CC',
-			'#CC33FF',
-			'#CC6600',
-			'#CC6633',
-			'#CC9900',
-			'#CC9933',
-			'#CCCC00',
-			'#CCCC33',
-			'#FF0000',
-			'#FF0033',
-			'#FF0066',
-			'#FF0099',
-			'#FF00CC',
-			'#FF00FF',
-			'#FF3300',
-			'#FF3333',
-			'#FF3366',
-			'#FF3399',
-			'#FF33CC',
-			'#FF33FF',
-			'#FF6600',
-			'#FF6633',
-			'#FF9900',
-			'#FF9933',
-			'#FFCC00',
-			'#FFCC33'
-		];
-
-		/**
-		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
-		 * and the Firebug extension (any Firefox version) are known
-		 * to support "%c" CSS customizations.
-		 *
-		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
-		 */
-
-		// eslint-disable-next-line complexity
-		function useColors() {
-			// NB: In an Electron preload script, document will be defined but not fully
-			// initialized. Since we know we're in Chrome, we'll just detect this case
-			// explicitly
-			if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
-				return true;
-			}
-
-			// Internet Explorer and Edge do not support colors.
-			if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
-				return false;
-			}
-
-			let m;
-
-			// Is webkit? http://stackoverflow.com/a/16459606/376773
-			// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
-			return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
-				// Is firebug? http://stackoverflow.com/a/398120/376773
-				(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
-				// Is firefox >= v31?
-				// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
-				(typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
-				// Double check webkit in userAgent just in case we are in a worker
-				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
-		}
-
-		/**
-		 * Colorize log arguments if enabled.
-		 *
-		 * @api public
-		 */
-
-		function formatArgs(args) {
-			args[0] = (this.useColors ? '%c' : '') +
-				this.namespace +
-				(this.useColors ? ' %c' : ' ') +
-				args[0] +
-				(this.useColors ? '%c ' : ' ') +
-				'+' + module.exports.humanize(this.diff);
-
-			if (!this.useColors) {
-				return;
-			}
-
-			const c = 'color: ' + this.color;
-			args.splice(1, 0, c, 'color: inherit');
-
-			// The final "%c" is somewhat tricky, because there could be other
-			// arguments passed either before or after the %c, so we need to
-			// figure out the correct index to insert the CSS into
-			let index = 0;
-			let lastC = 0;
-			args[0].replace(/%[a-zA-Z%]/g, match => {
-				if (match === '%%') {
-					return;
-				}
-				index++;
-				if (match === '%c') {
-					// We only are interested in the *last* %c
-					// (the user may have provided their own)
-					lastC = index;
-				}
-			});
-
-			args.splice(lastC, 0, c);
-		}
-
-		/**
-		 * Invokes `console.debug()` when available.
-		 * No-op when `console.debug` is not a "function".
-		 * If `console.debug` is not available, falls back
-		 * to `console.log`.
-		 *
-		 * @api public
-		 */
-		exports.log = console.debug || console.log || (() => {});
-
-		/**
-		 * Save `namespaces`.
-		 *
-		 * @param {String} namespaces
-		 * @api private
-		 */
-		function save(namespaces) {
-			try {
-				if (namespaces) {
-					exports.storage.setItem('debug', namespaces);
-				} else {
-					exports.storage.removeItem('debug');
-				}
-			} catch (error) {
-				// Swallow
-				// XXX (@Qix-) should we be logging these?
-			}
-		}
-
-		/**
-		 * Load `namespaces`.
-		 *
-		 * @return {String} returns the previously persisted debug modes
-		 * @api private
-		 */
-		function load() {
-			let r;
-			try {
-				r = exports.storage.getItem('debug');
-			} catch (error) {
-				// Swallow
-				// XXX (@Qix-) should we be logging these?
-			}
-
-			// 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;
-		}
-
-		/**
-		 * 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 {
-				// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
-				// The Browser also has localStorage in the global context.
-				return localStorage;
-			} catch (error) {
-				// Swallow
-				// XXX (@Qix-) should we be logging these?
-			}
-		}
-
-		module.exports = requireCommon()(exports);
-
-		const {formatters} = module.exports;
-
-		/**
-		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
-		 */
-
-		formatters.j = function (v) {
-			try {
-				return JSON.stringify(v);
-			} catch (error) {
-				return '[UnexpectedJSONParseError]: ' + error.message;
-			}
-		}; 
-	} (browser$1, browser$1.exports));
-	return browser$1.exports;
-}
-
-var node = {exports: {}};
-
-/**
- * Module dependencies.
- */
-
-var hasRequiredNode;
-
-function requireNode () {
-	if (hasRequiredNode) return node.exports;
-	hasRequiredNode = 1;
-	(function (module, exports) {
-		const tty = require$$0;
-		const util = require$$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 = require('supports-color');
-
-			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.formatWithOptions()` with the specified arguments and writes to stderr.
-		 */
-
-		function log(...args) {
-			return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...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, node.exports));
-	return node.exports;
-}
-
-/**
- * Detect Electron renderer / nwjs process, which is node, but we should
- * treat as a browser.
- */
-
-if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
-	src.exports = requireBrowser();
-} else {
-	src.exports = requireNode();
-}
-
-var srcExports = src.exports;
-var debug$2 = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
-
-var utils$3 = {};
-
-const path$2 = require$$0$1;
-const WIN_SLASH = '\\\\/';
-const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
-
-/**
- * Posix glob regex
- */
-
-const DOT_LITERAL = '\\.';
-const PLUS_LITERAL = '\\+';
-const QMARK_LITERAL = '\\?';
-const SLASH_LITERAL = '\\/';
-const ONE_CHAR = '(?=.)';
-const QMARK = '[^/]';
-const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
-const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
-const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
-const NO_DOT = `(?!${DOT_LITERAL})`;
-const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
-const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
-const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
-const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
-const STAR = `${QMARK}*?`;
-
-const POSIX_CHARS = {
-  DOT_LITERAL,
-  PLUS_LITERAL,
-  QMARK_LITERAL,
-  SLASH_LITERAL,
-  ONE_CHAR,
-  QMARK,
-  END_ANCHOR,
-  DOTS_SLASH,
-  NO_DOT,
-  NO_DOTS,
-  NO_DOT_SLASH,
-  NO_DOTS_SLASH,
-  QMARK_NO_DOT,
-  STAR,
-  START_ANCHOR
-};
-
-/**
- * Windows glob regex
- */
-
-const WINDOWS_CHARS = {
-  ...POSIX_CHARS,
-
-  SLASH_LITERAL: `[${WIN_SLASH}]`,
-  QMARK: WIN_NO_SLASH,
-  STAR: `${WIN_NO_SLASH}*?`,
-  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
-  NO_DOT: `(?!${DOT_LITERAL})`,
-  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
-  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
-  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
-  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
-};
-
-/**
- * POSIX Bracket Regex
- */
-
-const POSIX_REGEX_SOURCE$1 = {
-  alnum: 'a-zA-Z0-9',
-  alpha: 'a-zA-Z',
-  ascii: '\\x00-\\x7F',
-  blank: ' \\t',
-  cntrl: '\\x00-\\x1F\\x7F',
-  digit: '0-9',
-  graph: '\\x21-\\x7E',
-  lower: 'a-z',
-  print: '\\x20-\\x7E ',
-  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
-  space: ' \\t\\r\\n\\v\\f',
-  upper: 'A-Z',
-  word: 'A-Za-z0-9_',
-  xdigit: 'A-Fa-f0-9'
-};
-
-var constants$2 = {
-  MAX_LENGTH: 1024 * 64,
-  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
-
-  // regular expressions
-  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
-  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
-  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
-  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
-  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
-  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
-
-  // Replace globs with equivalent patterns to reduce parsing time.
-  REPLACEMENTS: {
-    '***': '*',
-    '**/**': '**',
-    '**/**/**': '**'
-  },
-
-  // Digits
-  CHAR_0: 48, /* 0 */
-  CHAR_9: 57, /* 9 */
-
-  // Alphabet chars.
-  CHAR_UPPERCASE_A: 65, /* A */
-  CHAR_LOWERCASE_A: 97, /* a */
-  CHAR_UPPERCASE_Z: 90, /* Z */
-  CHAR_LOWERCASE_Z: 122, /* z */
-
-  CHAR_LEFT_PARENTHESES: 40, /* ( */
-  CHAR_RIGHT_PARENTHESES: 41, /* ) */
-
-  CHAR_ASTERISK: 42, /* * */
-
-  // Non-alphabetic chars.
-  CHAR_AMPERSAND: 38, /* & */
-  CHAR_AT: 64, /* @ */
-  CHAR_BACKWARD_SLASH: 92, /* \ */
-  CHAR_CARRIAGE_RETURN: 13, /* \r */
-  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
-  CHAR_COLON: 58, /* : */
-  CHAR_COMMA: 44, /* , */
-  CHAR_DOT: 46, /* . */
-  CHAR_DOUBLE_QUOTE: 34, /* " */
-  CHAR_EQUAL: 61, /* = */
-  CHAR_EXCLAMATION_MARK: 33, /* ! */
-  CHAR_FORM_FEED: 12, /* \f */
-  CHAR_FORWARD_SLASH: 47, /* / */
-  CHAR_GRAVE_ACCENT: 96, /* ` */
-  CHAR_HASH: 35, /* # */
-  CHAR_HYPHEN_MINUS: 45, /* - */
-  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
-  CHAR_LEFT_CURLY_BRACE: 123, /* { */
-  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
-  CHAR_LINE_FEED: 10, /* \n */
-  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
-  CHAR_PERCENT: 37, /* % */
-  CHAR_PLUS: 43, /* + */
-  CHAR_QUESTION_MARK: 63, /* ? */
-  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
-  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
-  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
-  CHAR_SEMICOLON: 59, /* ; */
-  CHAR_SINGLE_QUOTE: 39, /* ' */
-  CHAR_SPACE: 32, /*   */
-  CHAR_TAB: 9, /* \t */
-  CHAR_UNDERSCORE: 95, /* _ */
-  CHAR_VERTICAL_LINE: 124, /* | */
-  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
-
-  SEP: path$2.sep,
-
-  /**
-   * Create EXTGLOB_CHARS
-   */
-
-  extglobChars(chars) {
-    return {
-      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
-      '?': { type: 'qmark', open: '(?:', close: ')?' },
-      '+': { type: 'plus', open: '(?:', close: ')+' },
-      '*': { type: 'star', open: '(?:', close: ')*' },
-      '@': { type: 'at', open: '(?:', close: ')' }
-    };
-  },
-
-  /**
-   * Create GLOB_CHARS
-   */
-
-  globChars(win32) {
-    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
-  }
-};
-
-(function (exports) {
-
-	const path = require$$0$1;
-	const win32 = process.platform === 'win32';
-	const {
-	  REGEX_BACKSLASH,
-	  REGEX_REMOVE_BACKSLASH,
-	  REGEX_SPECIAL_CHARS,
-	  REGEX_SPECIAL_CHARS_GLOBAL
-	} = constants$2;
-
-	exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
-	exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
-	exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
-	exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
-	exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
-
-	exports.removeBackslashes = str => {
-	  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
-	    return match === '\\' ? '' : match;
-	  });
-	};
-
-	exports.supportsLookbehinds = () => {
-	  const segs = process.version.slice(1).split('.').map(Number);
-	  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
-	    return true;
-	  }
-	  return false;
-	};
-
-	exports.isWindows = options => {
-	  if (options && typeof options.windows === 'boolean') {
-	    return options.windows;
-	  }
-	  return win32 === true || path.sep === '\\';
-	};
-
-	exports.escapeLast = (input, char, lastIdx) => {
-	  const idx = input.lastIndexOf(char, lastIdx);
-	  if (idx === -1) return input;
-	  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
-	  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
-	};
-
-	exports.removePrefix = (input, state = {}) => {
-	  let output = input;
-	  if (output.startsWith('./')) {
-	    output = output.slice(2);
-	    state.prefix = './';
-	  }
-	  return output;
-	};
-
-	exports.wrapOutput = (input, state = {}, options = {}) => {
-	  const prepend = options.contains ? '' : '^';
-	  const append = options.contains ? '' : '$';
-
-	  let output = `${prepend}(?:${input})${append}`;
-	  if (state.negated === true) {
-	    output = `(?:^(?!${output}).*$)`;
-	  }
-	  return output;
-	}; 
-} (utils$3));
-
-const utils$2 = utils$3;
-const {
-  CHAR_ASTERISK,             /* * */
-  CHAR_AT,                   /* @ */
-  CHAR_BACKWARD_SLASH,       /* \ */
-  CHAR_COMMA,                /* , */
-  CHAR_DOT,                  /* . */
-  CHAR_EXCLAMATION_MARK,     /* ! */
-  CHAR_FORWARD_SLASH,        /* / */
-  CHAR_LEFT_CURLY_BRACE,     /* { */
-  CHAR_LEFT_PARENTHESES,     /* ( */
-  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
-  CHAR_PLUS,                 /* + */
-  CHAR_QUESTION_MARK,        /* ? */
-  CHAR_RIGHT_CURLY_BRACE,    /* } */
-  CHAR_RIGHT_PARENTHESES,    /* ) */
-  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
-} = constants$2;
-
-const isPathSeparator = code => {
-  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
-};
-
-const depth = token => {
-  if (token.isPrefix !== true) {
-    token.depth = token.isGlobstar ? Infinity : 1;
-  }
-};
-
-/**
- * Quickly scans a glob pattern and returns an object with a handful of
- * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
- * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
- * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
- *
- * ```js
- * const pm = require('picomatch');
- * console.log(pm.scan('foo/bar/*.js'));
- * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
- * ```
- * @param {String} `str`
- * @param {Object} `options`
- * @return {Object} Returns an object with tokens and regex source string.
- * @api public
- */
-
-const scan$1 = (input, options) => {
-  const opts = options || {};
-
-  const length = input.length - 1;
-  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
-  const slashes = [];
-  const tokens = [];
-  const parts = [];
-
-  let str = input;
-  let index = -1;
-  let start = 0;
-  let lastIndex = 0;
-  let isBrace = false;
-  let isBracket = false;
-  let isGlob = false;
-  let isExtglob = false;
-  let isGlobstar = false;
-  let braceEscaped = false;
-  let backslashes = false;
-  let negated = false;
-  let negatedExtglob = false;
-  let finished = false;
-  let braces = 0;
-  let prev;
-  let code;
-  let token = { value: '', depth: 0, isGlob: false };
-
-  const eos = () => index >= length;
-  const peek = () => str.charCodeAt(index + 1);
-  const advance = () => {
-    prev = code;
-    return str.charCodeAt(++index);
-  };
-
-  while (index < length) {
-    code = advance();
-    let next;
-
-    if (code === CHAR_BACKWARD_SLASH) {
-      backslashes = token.backslashes = true;
-      code = advance();
-
-      if (code === CHAR_LEFT_CURLY_BRACE) {
-        braceEscaped = true;
-      }
-      continue;
-    }
-
-    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
-      braces++;
-
-      while (eos() !== true && (code = advance())) {
-        if (code === CHAR_BACKWARD_SLASH) {
-          backslashes = token.backslashes = true;
-          advance();
-          continue;
-        }
-
-        if (code === CHAR_LEFT_CURLY_BRACE) {
-          braces++;
-          continue;
-        }
-
-        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
-          isBrace = token.isBrace = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-
-          if (scanToEnd === true) {
-            continue;
-          }
-
-          break;
-        }
-
-        if (braceEscaped !== true && code === CHAR_COMMA) {
-          isBrace = token.isBrace = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-
-          if (scanToEnd === true) {
-            continue;
-          }
-
-          break;
-        }
-
-        if (code === CHAR_RIGHT_CURLY_BRACE) {
-          braces--;
-
-          if (braces === 0) {
-            braceEscaped = false;
-            isBrace = token.isBrace = true;
-            finished = true;
-            break;
-          }
-        }
-      }
-
-      if (scanToEnd === true) {
-        continue;
-      }
-
-      break;
-    }
-
-    if (code === CHAR_FORWARD_SLASH) {
-      slashes.push(index);
-      tokens.push(token);
-      token = { value: '', depth: 0, isGlob: false };
-
-      if (finished === true) continue;
-      if (prev === CHAR_DOT && index === (start + 1)) {
-        start += 2;
-        continue;
-      }
-
-      lastIndex = index + 1;
-      continue;
-    }
-
-    if (opts.noext !== true) {
-      const isExtglobChar = code === CHAR_PLUS
-        || code === CHAR_AT
-        || code === CHAR_ASTERISK
-        || code === CHAR_QUESTION_MARK
-        || code === CHAR_EXCLAMATION_MARK;
-
-      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
-        isGlob = token.isGlob = true;
-        isExtglob = token.isExtglob = true;
-        finished = true;
-        if (code === CHAR_EXCLAMATION_MARK && index === start) {
-          negatedExtglob = true;
-        }
-
-        if (scanToEnd === true) {
-          while (eos() !== true && (code = advance())) {
-            if (code === CHAR_BACKWARD_SLASH) {
-              backslashes = token.backslashes = true;
-              code = advance();
-              continue;
-            }
-
-            if (code === CHAR_RIGHT_PARENTHESES) {
-              isGlob = token.isGlob = true;
-              finished = true;
-              break;
-            }
-          }
-          continue;
-        }
-        break;
-      }
-    }
-
-    if (code === CHAR_ASTERISK) {
-      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
-      isGlob = token.isGlob = true;
-      finished = true;
-
-      if (scanToEnd === true) {
-        continue;
-      }
-      break;
-    }
-
-    if (code === CHAR_QUESTION_MARK) {
-      isGlob = token.isGlob = true;
-      finished = true;
-
-      if (scanToEnd === true) {
-        continue;
-      }
-      break;
-    }
-
-    if (code === CHAR_LEFT_SQUARE_BRACKET) {
-      while (eos() !== true && (next = advance())) {
-        if (next === CHAR_BACKWARD_SLASH) {
-          backslashes = token.backslashes = true;
-          advance();
-          continue;
-        }
-
-        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
-          isBracket = token.isBracket = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-          break;
-        }
-      }
-
-      if (scanToEnd === true) {
-        continue;
-      }
-
-      break;
-    }
-
-    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
-      negated = token.negated = true;
-      start++;
-      continue;
-    }
-
-    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
-      isGlob = token.isGlob = true;
-
-      if (scanToEnd === true) {
-        while (eos() !== true && (code = advance())) {
-          if (code === CHAR_LEFT_PARENTHESES) {
-            backslashes = token.backslashes = true;
-            code = advance();
-            continue;
-          }
-
-          if (code === CHAR_RIGHT_PARENTHESES) {
-            finished = true;
-            break;
-          }
-        }
-        continue;
-      }
-      break;
-    }
-
-    if (isGlob === true) {
-      finished = true;
-
-      if (scanToEnd === true) {
-        continue;
-      }
-
-      break;
-    }
-  }
-
-  if (opts.noext === true) {
-    isExtglob = false;
-    isGlob = false;
-  }
-
-  let base = str;
-  let prefix = '';
-  let glob = '';
-
-  if (start > 0) {
-    prefix = str.slice(0, start);
-    str = str.slice(start);
-    lastIndex -= start;
-  }
-
-  if (base && isGlob === true && lastIndex > 0) {
-    base = str.slice(0, lastIndex);
-    glob = str.slice(lastIndex);
-  } else if (isGlob === true) {
-    base = '';
-    glob = str;
-  } else {
-    base = str;
-  }
-
-  if (base && base !== '' && base !== '/' && base !== str) {
-    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
-      base = base.slice(0, -1);
-    }
-  }
-
-  if (opts.unescape === true) {
-    if (glob) glob = utils$2.removeBackslashes(glob);
-
-    if (base && backslashes === true) {
-      base = utils$2.removeBackslashes(base);
-    }
-  }
-
-  const state = {
-    prefix,
-    input,
-    start,
-    base,
-    glob,
-    isBrace,
-    isBracket,
-    isGlob,
-    isExtglob,
-    isGlobstar,
-    negated,
-    negatedExtglob
-  };
-
-  if (opts.tokens === true) {
-    state.maxDepth = 0;
-    if (!isPathSeparator(code)) {
-      tokens.push(token);
-    }
-    state.tokens = tokens;
-  }
-
-  if (opts.parts === true || opts.tokens === true) {
-    let prevIndex;
-
-    for (let idx = 0; idx < slashes.length; idx++) {
-      const n = prevIndex ? prevIndex + 1 : start;
-      const i = slashes[idx];
-      const value = input.slice(n, i);
-      if (opts.tokens) {
-        if (idx === 0 && start !== 0) {
-          tokens[idx].isPrefix = true;
-          tokens[idx].value = prefix;
-        } else {
-          tokens[idx].value = value;
-        }
-        depth(tokens[idx]);
-        state.maxDepth += tokens[idx].depth;
-      }
-      if (idx !== 0 || value !== '') {
-        parts.push(value);
-      }
-      prevIndex = i;
-    }
-
-    if (prevIndex && prevIndex + 1 < input.length) {
-      const value = input.slice(prevIndex + 1);
-      parts.push(value);
-
-      if (opts.tokens) {
-        tokens[tokens.length - 1].value = value;
-        depth(tokens[tokens.length - 1]);
-        state.maxDepth += tokens[tokens.length - 1].depth;
-      }
-    }
-
-    state.slashes = slashes;
-    state.parts = parts;
-  }
-
-  return state;
-};
-
-var scan_1 = scan$1;
-
-const constants$1 = constants$2;
-const utils$1 = utils$3;
-
-/**
- * Constants
- */
-
-const {
-  MAX_LENGTH,
-  POSIX_REGEX_SOURCE,
-  REGEX_NON_SPECIAL_CHARS,
-  REGEX_SPECIAL_CHARS_BACKREF,
-  REPLACEMENTS
-} = constants$1;
-
-/**
- * Helpers
- */
-
-const expandRange = (args, options) => {
-  if (typeof options.expandRange === 'function') {
-    return options.expandRange(...args, options);
-  }
-
-  args.sort();
-  const value = `[${args.join('-')}]`;
-
-  return value;
-};
-
-/**
- * Create the message for a syntax error
- */
-
-const syntaxError = (type, char) => {
-  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
-};
-
-/**
- * Parse the given input string.
- * @param {String} input
- * @param {Object} options
- * @return {Object}
- */
-
-const parse$2 = (input, options) => {
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected a string');
-  }
-
-  input = REPLACEMENTS[input] || input;
-
-  const opts = { ...options };
-  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-
-  let len = input.length;
-  if (len > max) {
-    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-  }
-
-  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
-  const tokens = [bos];
-
-  const capture = opts.capture ? '' : '?:';
-  const win32 = utils$1.isWindows(options);
-
-  // create constants based on platform, for windows or posix
-  const PLATFORM_CHARS = constants$1.globChars(win32);
-  const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
-
-  const {
-    DOT_LITERAL,
-    PLUS_LITERAL,
-    SLASH_LITERAL,
-    ONE_CHAR,
-    DOTS_SLASH,
-    NO_DOT,
-    NO_DOT_SLASH,
-    NO_DOTS_SLASH,
-    QMARK,
-    QMARK_NO_DOT,
-    STAR,
-    START_ANCHOR
-  } = PLATFORM_CHARS;
-
-  const globstar = opts => {
-    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
-  };
-
-  const nodot = opts.dot ? '' : NO_DOT;
-  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
-  let star = opts.bash === true ? globstar(opts) : STAR;
-
-  if (opts.capture) {
-    star = `(${star})`;
-  }
-
-  // minimatch options support
-  if (typeof opts.noext === 'boolean') {
-    opts.noextglob = opts.noext;
-  }
-
-  const state = {
-    input,
-    index: -1,
-    start: 0,
-    dot: opts.dot === true,
-    consumed: '',
-    output: '',
-    prefix: '',
-    backtrack: false,
-    negated: false,
-    brackets: 0,
-    braces: 0,
-    parens: 0,
-    quotes: 0,
-    globstar: false,
-    tokens
-  };
-
-  input = utils$1.removePrefix(input, state);
-  len = input.length;
-
-  const extglobs = [];
-  const braces = [];
-  const stack = [];
-  let prev = bos;
-  let value;
-
-  /**
-   * Tokenizing helpers
-   */
-
-  const eos = () => state.index === len - 1;
-  const peek = state.peek = (n = 1) => input[state.index + n];
-  const advance = state.advance = () => input[++state.index] || '';
-  const remaining = () => input.slice(state.index + 1);
-  const consume = (value = '', num = 0) => {
-    state.consumed += value;
-    state.index += num;
-  };
-
-  const append = token => {
-    state.output += token.output != null ? token.output : token.value;
-    consume(token.value);
-  };
-
-  const negate = () => {
-    let count = 1;
-
-    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
-      advance();
-      state.start++;
-      count++;
-    }
-
-    if (count % 2 === 0) {
-      return false;
-    }
-
-    state.negated = true;
-    state.start++;
-    return true;
-  };
-
-  const increment = type => {
-    state[type]++;
-    stack.push(type);
-  };
-
-  const decrement = type => {
-    state[type]--;
-    stack.pop();
-  };
-
-  /**
-   * Push tokens onto the tokens array. This helper speeds up
-   * tokenizing by 1) helping us avoid backtracking as much as possible,
-   * and 2) helping us avoid creating extra tokens when consecutive
-   * characters are plain text. This improves performance and simplifies
-   * lookbehinds.
-   */
-
-  const push = tok => {
-    if (prev.type === 'globstar') {
-      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
-      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
-
-      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
-        state.output = state.output.slice(0, -prev.output.length);
-        prev.type = 'star';
-        prev.value = '*';
-        prev.output = star;
-        state.output += prev.output;
-      }
-    }
-
-    if (extglobs.length && tok.type !== 'paren') {
-      extglobs[extglobs.length - 1].inner += tok.value;
-    }
-
-    if (tok.value || tok.output) append(tok);
-    if (prev && prev.type === 'text' && tok.type === 'text') {
-      prev.value += tok.value;
-      prev.output = (prev.output || '') + tok.value;
-      return;
-    }
-
-    tok.prev = prev;
-    tokens.push(tok);
-    prev = tok;
-  };
-
-  const extglobOpen = (type, value) => {
-    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
-
-    token.prev = prev;
-    token.parens = state.parens;
-    token.output = state.output;
-    const output = (opts.capture ? '(' : '') + token.open;
-
-    increment('parens');
-    push({ type, value, output: state.output ? '' : ONE_CHAR });
-    push({ type: 'paren', extglob: true, value: advance(), output });
-    extglobs.push(token);
-  };
-
-  const extglobClose = token => {
-    let output = token.close + (opts.capture ? ')' : '');
-    let rest;
-
-    if (token.type === 'negate') {
-      let extglobStar = star;
-
-      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
-        extglobStar = globstar(opts);
-      }
-
-      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
-        output = token.close = `)$))${extglobStar}`;
-      }
-
-      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
-        // In this case, we need to parse the string and use it in the output of the original pattern.
-        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
-        //
-        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
-        const expression = parse$2(rest, { ...options, fastpaths: false }).output;
-
-        output = token.close = `)${expression})${extglobStar})`;
-      }
-
-      if (token.prev.type === 'bos') {
-        state.negatedExtglob = true;
-      }
-    }
-
-    push({ type: 'paren', extglob: true, value, output });
-    decrement('parens');
-  };
-
-  /**
-   * Fast paths
-   */
-
-  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
-    let backslashes = false;
-
-    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
-      if (first === '\\') {
-        backslashes = true;
-        return m;
-      }
-
-      if (first === '?') {
-        if (esc) {
-          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
-        }
-        if (index === 0) {
-          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
-        }
-        return QMARK.repeat(chars.length);
-      }
-
-      if (first === '.') {
-        return DOT_LITERAL.repeat(chars.length);
-      }
-
-      if (first === '*') {
-        if (esc) {
-          return esc + first + (rest ? star : '');
-        }
-        return star;
-      }
-      return esc ? m : `\\${m}`;
-    });
-
-    if (backslashes === true) {
-      if (opts.unescape === true) {
-        output = output.replace(/\\/g, '');
-      } else {
-        output = output.replace(/\\+/g, m => {
-          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
-        });
-      }
-    }
-
-    if (output === input && opts.contains === true) {
-      state.output = input;
-      return state;
-    }
-
-    state.output = utils$1.wrapOutput(output, state, options);
-    return state;
-  }
-
-  /**
-   * Tokenize input until we reach end-of-string
-   */
-
-  while (!eos()) {
-    value = advance();
-
-    if (value === '\u0000') {
-      continue;
-    }
-
-    /**
-     * Escaped characters
-     */
-
-    if (value === '\\') {
-      const next = peek();
-
-      if (next === '/' && opts.bash !== true) {
-        continue;
-      }
-
-      if (next === '.' || next === ';') {
-        continue;
-      }
-
-      if (!next) {
-        value += '\\';
-        push({ type: 'text', value });
-        continue;
-      }
-
-      // collapse slashes to reduce potential for exploits
-      const match = /^\\+/.exec(remaining());
-      let slashes = 0;
-
-      if (match && match[0].length > 2) {
-        slashes = match[0].length;
-        state.index += slashes;
-        if (slashes % 2 !== 0) {
-          value += '\\';
-        }
-      }
-
-      if (opts.unescape === true) {
-        value = advance();
-      } else {
-        value += advance();
-      }
-
-      if (state.brackets === 0) {
-        push({ type: 'text', value });
-        continue;
-      }
-    }
-
-    /**
-     * If we're inside a regex character class, continue
-     * until we reach the closing bracket.
-     */
-
-    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
-      if (opts.posix !== false && value === ':') {
-        const inner = prev.value.slice(1);
-        if (inner.includes('[')) {
-          prev.posix = true;
-
-          if (inner.includes(':')) {
-            const idx = prev.value.lastIndexOf('[');
-            const pre = prev.value.slice(0, idx);
-            const rest = prev.value.slice(idx + 2);
-            const posix = POSIX_REGEX_SOURCE[rest];
-            if (posix) {
-              prev.value = pre + posix;
-              state.backtrack = true;
-              advance();
-
-              if (!bos.output && tokens.indexOf(prev) === 1) {
-                bos.output = ONE_CHAR;
-              }
-              continue;
-            }
-          }
-        }
-      }
-
-      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
-        value = `\\${value}`;
-      }
-
-      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
-        value = `\\${value}`;
-      }
-
-      if (opts.posix === true && value === '!' && prev.value === '[') {
-        value = '^';
-      }
-
-      prev.value += value;
-      append({ value });
-      continue;
-    }
-
-    /**
-     * If we're inside a quoted string, continue
-     * until we reach the closing double quote.
-     */
-
-    if (state.quotes === 1 && value !== '"') {
-      value = utils$1.escapeRegex(value);
-      prev.value += value;
-      append({ value });
-      continue;
-    }
-
-    /**
-     * Double quotes
-     */
-
-    if (value === '"') {
-      state.quotes = state.quotes === 1 ? 0 : 1;
-      if (opts.keepQuotes === true) {
-        push({ type: 'text', value });
-      }
-      continue;
-    }
-
-    /**
-     * Parentheses
-     */
-
-    if (value === '(') {
-      increment('parens');
-      push({ type: 'paren', value });
-      continue;
-    }
-
-    if (value === ')') {
-      if (state.parens === 0 && opts.strictBrackets === true) {
-        throw new SyntaxError(syntaxError('opening', '('));
-      }
-
-      const extglob = extglobs[extglobs.length - 1];
-      if (extglob && state.parens === extglob.parens + 1) {
-        extglobClose(extglobs.pop());
-        continue;
-      }
-
-      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
-      decrement('parens');
-      continue;
-    }
-
-    /**
-     * Square brackets
-     */
-
-    if (value === '[') {
-      if (opts.nobracket === true || !remaining().includes(']')) {
-        if (opts.nobracket !== true && opts.strictBrackets === true) {
-          throw new SyntaxError(syntaxError('closing', ']'));
-        }
-
-        value = `\\${value}`;
-      } else {
-        increment('brackets');
-      }
-
-      push({ type: 'bracket', value });
-      continue;
-    }
-
-    if (value === ']') {
-      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
-        push({ type: 'text', value, output: `\\${value}` });
-        continue;
-      }
-
-      if (state.brackets === 0) {
-        if (opts.strictBrackets === true) {
-          throw new SyntaxError(syntaxError('opening', '['));
-        }
-
-        push({ type: 'text', value, output: `\\${value}` });
-        continue;
-      }
-
-      decrement('brackets');
-
-      const prevValue = prev.value.slice(1);
-      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
-        value = `/${value}`;
-      }
-
-      prev.value += value;
-      append({ value });
-
-      // when literal brackets are explicitly disabled
-      // assume we should match with a regex character class
-      if (opts.literalBrackets === false || utils$1.hasRegexChars(prevValue)) {
-        continue;
-      }
-
-      const escaped = utils$1.escapeRegex(prev.value);
-      state.output = state.output.slice(0, -prev.value.length);
-
-      // when literal brackets are explicitly enabled
-      // assume we should escape the brackets to match literal characters
-      if (opts.literalBrackets === true) {
-        state.output += escaped;
-        prev.value = escaped;
-        continue;
-      }
-
-      // when the user specifies nothing, try to match both
-      prev.value = `(${capture}${escaped}|${prev.value})`;
-      state.output += prev.value;
-      continue;
-    }
-
-    /**
-     * Braces
-     */
-
-    if (value === '{' && opts.nobrace !== true) {
-      increment('braces');
-
-      const open = {
-        type: 'brace',
-        value,
-        output: '(',
-        outputIndex: state.output.length,
-        tokensIndex: state.tokens.length
-      };
-
-      braces.push(open);
-      push(open);
-      continue;
-    }
-
-    if (value === '}') {
-      const brace = braces[braces.length - 1];
-
-      if (opts.nobrace === true || !brace) {
-        push({ type: 'text', value, output: value });
-        continue;
-      }
-
-      let output = ')';
-
-      if (brace.dots === true) {
-        const arr = tokens.slice();
-        const range = [];
-
-        for (let i = arr.length - 1; i >= 0; i--) {
-          tokens.pop();
-          if (arr[i].type === 'brace') {
-            break;
-          }
-          if (arr[i].type !== 'dots') {
-            range.unshift(arr[i].value);
-          }
-        }
-
-        output = expandRange(range, opts);
-        state.backtrack = true;
-      }
-
-      if (brace.comma !== true && brace.dots !== true) {
-        const out = state.output.slice(0, brace.outputIndex);
-        const toks = state.tokens.slice(brace.tokensIndex);
-        brace.value = brace.output = '\\{';
-        value = output = '\\}';
-        state.output = out;
-        for (const t of toks) {
-          state.output += (t.output || t.value);
-        }
-      }
-
-      push({ type: 'brace', value, output });
-      decrement('braces');
-      braces.pop();
-      continue;
-    }
-
-    /**
-     * Pipes
-     */
-
-    if (value === '|') {
-      if (extglobs.length > 0) {
-        extglobs[extglobs.length - 1].conditions++;
-      }
-      push({ type: 'text', value });
-      continue;
-    }
-
-    /**
-     * Commas
-     */
-
-    if (value === ',') {
-      let output = value;
-
-      const brace = braces[braces.length - 1];
-      if (brace && stack[stack.length - 1] === 'braces') {
-        brace.comma = true;
-        output = '|';
-      }
-
-      push({ type: 'comma', value, output });
-      continue;
-    }
-
-    /**
-     * Slashes
-     */
-
-    if (value === '/') {
-      // if the beginning of the glob is "./", advance the start
-      // to the current index, and don't add the "./" characters
-      // to the state. This greatly simplifies lookbehinds when
-      // checking for BOS characters like "!" and "." (not "./")
-      if (prev.type === 'dot' && state.index === state.start + 1) {
-        state.start = state.index + 1;
-        state.consumed = '';
-        state.output = '';
-        tokens.pop();
-        prev = bos; // reset "prev" to the first token
-        continue;
-      }
-
-      push({ type: 'slash', value, output: SLASH_LITERAL });
-      continue;
-    }
-
-    /**
-     * Dots
-     */
-
-    if (value === '.') {
-      if (state.braces > 0 && prev.type === 'dot') {
-        if (prev.value === '.') prev.output = DOT_LITERAL;
-        const brace = braces[braces.length - 1];
-        prev.type = 'dots';
-        prev.output += value;
-        prev.value += value;
-        brace.dots = true;
-        continue;
-      }
-
-      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
-        push({ type: 'text', value, output: DOT_LITERAL });
-        continue;
-      }
-
-      push({ type: 'dot', value, output: DOT_LITERAL });
-      continue;
-    }
-
-    /**
-     * Question marks
-     */
-
-    if (value === '?') {
-      const isGroup = prev && prev.value === '(';
-      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
-        extglobOpen('qmark', value);
-        continue;
-      }
-
-      if (prev && prev.type === 'paren') {
-        const next = peek();
-        let output = value;
-
-        if (next === '<' && !utils$1.supportsLookbehinds()) {
-          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
-        }
-
-        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
-          output = `\\${value}`;
-        }
-
-        push({ type: 'text', value, output });
-        continue;
-      }
-
-      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
-        push({ type: 'qmark', value, output: QMARK_NO_DOT });
-        continue;
-      }
-
-      push({ type: 'qmark', value, output: QMARK });
-      continue;
-    }
-
-    /**
-     * Exclamation
-     */
-
-    if (value === '!') {
-      if (opts.noextglob !== true && peek() === '(') {
-        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
-          extglobOpen('negate', value);
-          continue;
-        }
-      }
-
-      if (opts.nonegate !== true && state.index === 0) {
-        negate();
-        continue;
-      }
-    }
-
-    /**
-     * Plus
-     */
-
-    if (value === '+') {
-      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
-        extglobOpen('plus', value);
-        continue;
-      }
-
-      if ((prev && prev.value === '(') || opts.regex === false) {
-        push({ type: 'plus', value, output: PLUS_LITERAL });
-        continue;
-      }
-
-      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
-        push({ type: 'plus', value });
-        continue;
-      }
-
-      push({ type: 'plus', value: PLUS_LITERAL });
-      continue;
-    }
-
-    /**
-     * Plain text
-     */
-
-    if (value === '@') {
-      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
-        push({ type: 'at', extglob: true, value, output: '' });
-        continue;
-      }
-
-      push({ type: 'text', value });
-      continue;
-    }
-
-    /**
-     * Plain text
-     */
-
-    if (value !== '*') {
-      if (value === '$' || value === '^') {
-        value = `\\${value}`;
-      }
-
-      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
-      if (match) {
-        value += match[0];
-        state.index += match[0].length;
-      }
-
-      push({ type: 'text', value });
-      continue;
-    }
-
-    /**
-     * Stars
-     */
-
-    if (prev && (prev.type === 'globstar' || prev.star === true)) {
-      prev.type = 'star';
-      prev.star = true;
-      prev.value += value;
-      prev.output = star;
-      state.backtrack = true;
-      state.globstar = true;
-      consume(value);
-      continue;
-    }
-
-    let rest = remaining();
-    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
-      extglobOpen('star', value);
-      continue;
-    }
-
-    if (prev.type === 'star') {
-      if (opts.noglobstar === true) {
-        consume(value);
-        continue;
-      }
-
-      const prior = prev.prev;
-      const before = prior.prev;
-      const isStart = prior.type === 'slash' || prior.type === 'bos';
-      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
-
-      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
-        push({ type: 'star', value, output: '' });
-        continue;
-      }
-
-      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
-      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
-      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
-        push({ type: 'star', value, output: '' });
-        continue;
-      }
-
-      // strip consecutive `/**/`
-      while (rest.slice(0, 3) === '/**') {
-        const after = input[state.index + 4];
-        if (after && after !== '/') {
-          break;
-        }
-        rest = rest.slice(3);
-        consume('/**', 3);
-      }
-
-      if (prior.type === 'bos' && eos()) {
-        prev.type = 'globstar';
-        prev.value += value;
-        prev.output = globstar(opts);
-        state.output = prev.output;
-        state.globstar = true;
-        consume(value);
-        continue;
-      }
-
-      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
-        state.output = state.output.slice(0, -(prior.output + prev.output).length);
-        prior.output = `(?:${prior.output}`;
-
-        prev.type = 'globstar';
-        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
-        prev.value += value;
-        state.globstar = true;
-        state.output += prior.output + prev.output;
-        consume(value);
-        continue;
-      }
-
-      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
-        const end = rest[1] !== void 0 ? '|$' : '';
-
-        state.output = state.output.slice(0, -(prior.output + prev.output).length);
-        prior.output = `(?:${prior.output}`;
-
-        prev.type = 'globstar';
-        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
-        prev.value += value;
-
-        state.output += prior.output + prev.output;
-        state.globstar = true;
-
-        consume(value + advance());
-
-        push({ type: 'slash', value: '/', output: '' });
-        continue;
-      }
-
-      if (prior.type === 'bos' && rest[0] === '/') {
-        prev.type = 'globstar';
-        prev.value += value;
-        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
-        state.output = prev.output;
-        state.globstar = true;
-        consume(value + advance());
-        push({ type: 'slash', value: '/', output: '' });
-        continue;
-      }
-
-      // remove single star from output
-      state.output = state.output.slice(0, -prev.output.length);
-
-      // reset previous token to globstar
-      prev.type = 'globstar';
-      prev.output = globstar(opts);
-      prev.value += value;
-
-      // reset output with globstar
-      state.output += prev.output;
-      state.globstar = true;
-      consume(value);
-      continue;
-    }
-
-    const token = { type: 'star', value, output: star };
-
-    if (opts.bash === true) {
-      token.output = '.*?';
-      if (prev.type === 'bos' || prev.type === 'slash') {
-        token.output = nodot + token.output;
-      }
-      push(token);
-      continue;
-    }
-
-    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
-      token.output = value;
-      push(token);
-      continue;
-    }
-
-    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
-      if (prev.type === 'dot') {
-        state.output += NO_DOT_SLASH;
-        prev.output += NO_DOT_SLASH;
-
-      } else if (opts.dot === true) {
-        state.output += NO_DOTS_SLASH;
-        prev.output += NO_DOTS_SLASH;
-
-      } else {
-        state.output += nodot;
-        prev.output += nodot;
-      }
-
-      if (peek() !== '*') {
-        state.output += ONE_CHAR;
-        prev.output += ONE_CHAR;
-      }
-    }
-
-    push(token);
-  }
-
-  while (state.brackets > 0) {
-    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
-    state.output = utils$1.escapeLast(state.output, '[');
-    decrement('brackets');
-  }
-
-  while (state.parens > 0) {
-    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
-    state.output = utils$1.escapeLast(state.output, '(');
-    decrement('parens');
-  }
-
-  while (state.braces > 0) {
-    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
-    state.output = utils$1.escapeLast(state.output, '{');
-    decrement('braces');
-  }
-
-  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
-    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
-  }
-
-  // rebuild the output if we had to backtrack at any point
-  if (state.backtrack === true) {
-    state.output = '';
-
-    for (const token of state.tokens) {
-      state.output += token.output != null ? token.output : token.value;
-
-      if (token.suffix) {
-        state.output += token.suffix;
-      }
-    }
-  }
-
-  return state;
-};
-
-/**
- * Fast paths for creating regular expressions for common glob patterns.
- * This can significantly speed up processing and has very little downside
- * impact when none of the fast paths match.
- */
-
-parse$2.fastpaths = (input, options) => {
-  const opts = { ...options };
-  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-  const len = input.length;
-  if (len > max) {
-    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-  }
-
-  input = REPLACEMENTS[input] || input;
-  const win32 = utils$1.isWindows(options);
-
-  // create constants based on platform, for windows or posix
-  const {
-    DOT_LITERAL,
-    SLASH_LITERAL,
-    ONE_CHAR,
-    DOTS_SLASH,
-    NO_DOT,
-    NO_DOTS,
-    NO_DOTS_SLASH,
-    STAR,
-    START_ANCHOR
-  } = constants$1.globChars(win32);
-
-  const nodot = opts.dot ? NO_DOTS : NO_DOT;
-  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
-  const capture = opts.capture ? '' : '?:';
-  const state = { negated: false, prefix: '' };
-  let star = opts.bash === true ? '.*?' : STAR;
-
-  if (opts.capture) {
-    star = `(${star})`;
-  }
-
-  const globstar = opts => {
-    if (opts.noglobstar === true) return star;
-    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
-  };
-
-  const create = str => {
-    switch (str) {
-      case '*':
-        return `${nodot}${ONE_CHAR}${star}`;
-
-      case '.*':
-        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
-
-      case '*.*':
-        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
-
-      case '*/*':
-        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
-
-      case '**':
-        return nodot + globstar(opts);
-
-      case '**/*':
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
-
-      case '**/*.*':
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
-
-      case '**/.*':
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
-
-      default: {
-        const match = /^(.*?)\.(\w+)$/.exec(str);
-        if (!match) return;
-
-        const source = create(match[1]);
-        if (!source) return;
-
-        return source + DOT_LITERAL + match[2];
-      }
-    }
-  };
-
-  const output = utils$1.removePrefix(input, state);
-  let source = create(output);
-
-  if (source && opts.strictSlashes !== true) {
-    source += `${SLASH_LITERAL}?`;
-  }
-
-  return source;
-};
-
-var parse_1$1 = parse$2;
-
-const path$1 = require$$0$1;
-const scan = scan_1;
-const parse$1 = parse_1$1;
-const utils = utils$3;
-const constants = constants$2;
-const isObject$2 = val => val && typeof val === 'object' && !Array.isArray(val);
-
-/**
- * Creates a matcher function from one or more glob patterns. The
- * returned function takes a string to match as its first argument,
- * and returns true if the string is a match. The returned matcher
- * function also takes a boolean as the second argument that, when true,
- * returns an object with additional information.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch(glob[, options]);
- *
- * const isMatch = picomatch('*.!(*a)');
- * console.log(isMatch('a.a')); //=> false
- * console.log(isMatch('a.b')); //=> true
- * ```
- * @name picomatch
- * @param {String|Array} `globs` One or more glob patterns.
- * @param {Object=} `options`
- * @return {Function=} Returns a matcher function.
- * @api public
- */
-
-const picomatch$1 = (glob, options, returnState = false) => {
-  if (Array.isArray(glob)) {
-    const fns = glob.map(input => picomatch$1(input, options, returnState));
-    const arrayMatcher = str => {
-      for (const isMatch of fns) {
-        const state = isMatch(str);
-        if (state) return state;
-      }
-      return false;
-    };
-    return arrayMatcher;
-  }
-
-  const isState = isObject$2(glob) && glob.tokens && glob.input;
-
-  if (glob === '' || (typeof glob !== 'string' && !isState)) {
-    throw new TypeError('Expected pattern to be a non-empty string');
-  }
-
-  const opts = options || {};
-  const posix = utils.isWindows(options);
-  const regex = isState
-    ? picomatch$1.compileRe(glob, options)
-    : picomatch$1.makeRe(glob, options, false, true);
-
-  const state = regex.state;
-  delete regex.state;
-
-  let isIgnored = () => false;
-  if (opts.ignore) {
-    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-    isIgnored = picomatch$1(opts.ignore, ignoreOpts, returnState);
-  }
-
-  const matcher = (input, returnObject = false) => {
-    const { isMatch, match, output } = picomatch$1.test(input, regex, options, { glob, posix });
-    const result = { glob, state, regex, posix, input, output, match, isMatch };
-
-    if (typeof opts.onResult === 'function') {
-      opts.onResult(result);
-    }
-
-    if (isMatch === false) {
-      result.isMatch = false;
-      return returnObject ? result : false;
-    }
+			return val;
+		}
 
-    if (isIgnored(input)) {
-      if (typeof opts.onIgnore === 'function') {
-        opts.onIgnore(result);
-      }
-      result.isMatch = false;
-      return returnObject ? result : false;
-    }
+		/**
+		* XXX DO NOT USE. This is a temporary stub function.
+		* XXX It WILL be removed in the next major release.
+		*/
+		function destroy() {
+			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+		}
 
-    if (typeof opts.onMatch === 'function') {
-      opts.onMatch(result);
-    }
-    return returnObject ? result : true;
-  };
+		createDebug.enable(createDebug.load());
 
-  if (returnState) {
-    matcher.state = state;
-  }
+		return createDebug;
+	}
 
-  return matcher;
-};
+	common = setup;
+	return common;
+}
 
 /**
- * Test `input` with the given `regex`. This is used by the main
- * `picomatch()` function to test the input string.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.test(input, regex[, options]);
- *
- * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
- * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
- * ```
- * @param {String} `input` String to test.
- * @param {RegExp} `regex`
- * @return {Object} Returns an object with matching info.
- * @api public
+ * Module dependencies.
  */
 
-picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected input to be a string');
-  }
-
-  if (input === '') {
-    return { isMatch: false, output: '' };
-  }
-
-  const opts = options || {};
-  const format = opts.format || (posix ? utils.toPosixSlashes : null);
-  let match = input === glob;
-  let output = (match && format) ? format(input) : input;
+(function (module, exports) {
+	const tty = require$$0;
+	const util = require$$1;
 
-  if (match === false) {
-    output = format ? format(input) : input;
-    match = output === glob;
-  }
-
-  if (match === false || opts.capture === true) {
-    if (opts.matchBase === true || opts.basename === true) {
-      match = picomatch$1.matchBase(input, regex, options, posix);
-    } else {
-      match = regex.exec(output);
-    }
-  }
+	/**
+	 * This is the Node.js implementation of `debug()`.
+	 */
 
-  return { isMatch: Boolean(match), match, output };
-};
+	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`.'
+	);
 
-/**
- * Match the basename of a filepath.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.matchBase(input, glob[, options]);
- * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
- * ```
- * @param {String} `input` String to test.
- * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
- * @return {Boolean}
- * @api public
- */
+	/**
+	 * Colors.
+	 */
 
-picomatch$1.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
-  const regex = glob instanceof RegExp ? glob : picomatch$1.makeRe(glob, options);
-  return regex.test(path$1.basename(input));
-};
+	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 = require('supports-color');
+
+		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.
+	}
 
-/**
- * Returns true if **any** of the given glob `patterns` match the specified `string`.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.isMatch(string, patterns[, options]);
- *
- * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
- * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
- * ```
- * @param {String|Array} str The string to test.
- * @param {String|Array} patterns One or more glob patterns to use for matching.
- * @param {Object} [options] See available [options](#options).
- * @return {Boolean} Returns true if any patterns match `str`
- * @api public
- */
+	/**
+	 * Build up the default `inspectOpts` object from the environment variables.
+	 *
+	 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+	 */
 
-picomatch$1.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);
+	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();
+			});
 
-/**
- * Parse a glob pattern to create the source string for a regular
- * expression.
- *
- * ```js
- * const picomatch = require('picomatch');
- * const result = picomatch.parse(pattern[, options]);
- * ```
- * @param {String} `pattern`
- * @param {Object} `options`
- * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
- * @api public
- */
+		// 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);
+		}
 
-picomatch$1.parse = (pattern, options) => {
-  if (Array.isArray(pattern)) return pattern.map(p => picomatch$1.parse(p, options));
-  return parse$1(pattern, { ...options, fastpaths: false });
-};
+		obj[prop] = val;
+		return obj;
+	}, {});
 
-/**
- * Scan a glob pattern to separate the pattern into segments.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.scan(input[, options]);
- *
- * const result = picomatch.scan('!./foo/*.js');
- * console.log(result);
- * { prefix: '!./',
- *   input: '!./foo/*.js',
- *   start: 3,
- *   base: 'foo',
- *   glob: '*.js',
- *   isBrace: false,
- *   isBracket: false,
- *   isGlob: true,
- *   isExtglob: false,
- *   isGlobstar: false,
- *   negated: true }
- * ```
- * @param {String} `input` Glob pattern to scan.
- * @param {Object} `options`
- * @return {Object} Returns an object with
- * @api public
- */
+	/**
+	 * Is stdout a TTY? Colored output is enabled when `true`.
+	 */
 
-picomatch$1.scan = (input, options) => scan(input, options);
+	function useColors() {
+		return 'colors' in exports.inspectOpts ?
+			Boolean(exports.inspectOpts.colors) :
+			tty.isatty(process.stderr.fd);
+	}
 
-/**
- * Compile a regular expression from the `state` object returned by the
- * [parse()](#parse) method.
- *
- * @param {Object} `state`
- * @param {Object} `options`
- * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
- * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
- * @return {RegExp}
- * @api public
- */
+	/**
+	 * Adds ANSI color escape codes if enabled.
+	 *
+	 * @api public
+	 */
 
-picomatch$1.compileRe = (state, options, returnOutput = false, returnState = false) => {
-  if (returnOutput === true) {
-    return state.output;
-  }
+	function formatArgs(args) {
+		const {namespace: name, useColors} = this;
 
-  const opts = options || {};
-  const prepend = opts.contains ? '' : '^';
-  const append = opts.contains ? '' : '$';
+		if (useColors) {
+			const c = this.color;
+			const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+			const prefix = `  ${colorCode};1m${name} \u001B[0m`;
 
-  let source = `${prepend}(?:${state.output})${append}`;
-  if (state && state.negated === true) {
-    source = `^(?!${source}).*$`;
-  }
+			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];
+		}
+	}
 
-  const regex = picomatch$1.toRegex(source, options);
-  if (returnState === true) {
-    regex.state = state;
-  }
+	function getDate() {
+		if (exports.inspectOpts.hideDate) {
+			return '';
+		}
+		return new Date().toISOString() + ' ';
+	}
 
-  return regex;
-};
+	/**
+	 * Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
+	 */
 
-/**
- * Create a regular expression from a parsed glob pattern.
- *
- * ```js
- * const picomatch = require('picomatch');
- * const state = picomatch.parse('*.js');
- * // picomatch.compileRe(state[, options]);
- *
- * console.log(picomatch.compileRe(state));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `state` The object returned from the `.parse` method.
- * @param {Object} `options`
- * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
- * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
- * @return {RegExp} Returns a regex created from the given pattern.
- * @api public
- */
+	function log(...args) {
+		return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + '\n');
+	}
 
-picomatch$1.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
-  if (!input || typeof input !== 'string') {
-    throw new TypeError('Expected a non-empty string');
-  }
+	/**
+	 * 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;
+		}
+	}
 
-  let parsed = { negated: false, fastpaths: true };
+	/**
+	 * Load `namespaces`.
+	 *
+	 * @return {String} returns the previously persisted debug modes
+	 * @api private
+	 */
 
-  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
-    parsed.output = parse$1.fastpaths(input, options);
-  }
+	function load() {
+		return process.env.DEBUG;
+	}
 
-  if (!parsed.output) {
-    parsed = parse$1(input, options);
-  }
+	/**
+	 * Init logic for `debug` instances.
+	 *
+	 * Create a new `inspectOpts` object in case `useColors` is set
+	 * differently for a particular `debug` instance.
+	 */
 
-  return picomatch$1.compileRe(parsed, options, returnOutput, returnState);
-};
+	function init(debug) {
+		debug.inspectOpts = {};
 
-/**
- * Create a regular expression from the given regex source string.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.toRegex(source[, options]);
- *
- * const { output } = picomatch.parse('*.js');
- * console.log(picomatch.toRegex(output));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `source` Regular expression source string.
- * @param {Object} `options`
- * @return {RegExp}
- * @api public
- */
+		const keys = Object.keys(exports.inspectOpts);
+		for (let i = 0; i < keys.length; i++) {
+			debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+		}
+	}
 
-picomatch$1.toRegex = (source, options) => {
-  try {
-    const opts = options || {};
-    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
-  } catch (err) {
-    if (options && options.debug === true) throw err;
-    return /$^/;
-  }
-};
+	module.exports = requireCommon()(exports);
 
-/**
- * Picomatch constants.
- * @return {Object}
- */
+	const {formatters} = module.exports;
 
-picomatch$1.constants = constants;
+	/**
+	 * Map %o to `util.inspect()`, all on a single line.
+	 */
 
-/**
- * Expose "picomatch"
- */
+	formatters.o = function (v) {
+		this.inspectOpts.colors = this.useColors;
+		return util.inspect(v, this.inspectOpts)
+			.split('\n')
+			.map(str => str.trim())
+			.join(' ');
+	};
 
-var picomatch_1 = picomatch$1;
+	/**
+	 * Map %O to `util.inspect()`, allowing multiple lines if needed.
+	 */
 
-var picomatch = picomatch_1;
+	formatters.O = function (v) {
+		this.inspectOpts.colors = this.useColors;
+		return util.inspect(v, this.inspectOpts);
+	}; 
+} (node, node.exports));
 
-var pm = /*@__PURE__*/getDefaultExportFromCjs(picomatch);
+var nodeExports = node.exports;
+var debug$3 = /*@__PURE__*/getDefaultExportFromCjs(nodeExports);
 
 // Helper since Typescript can't detect readonly arrays with Array.isArray
 function isArray(arg) {
@@ -3303,23 +982,24 @@ function ensureArray(thing) {
     return [thing];
 }
 
+const normalizePathRegExp = new RegExp(`\\${require$$1$1.win32.sep}`, 'g');
 const normalizePath$1 = function normalizePath(filename) {
-    return filename.split(require$$0$1.win32.sep).join(require$$0$1.posix.sep);
+    return filename.replace(normalizePathRegExp, require$$1$1.posix.sep);
 };
 
 function getMatcherString(id, resolutionBase) {
-    if (resolutionBase === false || require$$0$1.isAbsolute(id) || id.startsWith('**')) {
+    if (resolutionBase === false || require$$1$1.isAbsolute(id) || id.startsWith('**')) {
         return normalizePath$1(id);
     }
     // resolve('') is valid and will default to process.cwd()
-    const basePath = normalizePath$1(require$$0$1.resolve(resolutionBase || ''))
+    const basePath = normalizePath$1(require$$1$1.resolve(resolutionBase || ''))
         // escape all possible (posix + win) path characters that might interfere with regex
         .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
     // Note that we use posix.join because:
     // 1. the basePath has been normalized to use /
     // 2. the incoming glob (id) matcher, also uses /
     // otherwise Node will force backslash (\) on windows
-    return require$$0$1.posix.join(basePath, normalizePath$1(id));
+    return require$$1$1.posix.join(basePath, normalizePath$1(id));
 }
 const createFilter$1 = function createFilter(include, exclude, options) {
     const resolutionBase = options && options.resolve;
@@ -3336,19 +1016,27 @@ const createFilter$1 = function createFilter(include, exclude, options) {
         };
     const includeMatchers = ensureArray(include).map(getMatcher);
     const excludeMatchers = ensureArray(exclude).map(getMatcher);
+    if (!includeMatchers.length && !excludeMatchers.length)
+        return (id) => typeof id === 'string' && !id.includes('\0');
     return function result(id) {
         if (typeof id !== 'string')
             return false;
-        if (/\0/.test(id))
+        if (id.includes('\0'))
             return false;
         const pathId = normalizePath$1(id);
         for (let i = 0; i < excludeMatchers.length; ++i) {
             const matcher = excludeMatchers[i];
+            if (matcher instanceof RegExp) {
+                matcher.lastIndex = 0;
+            }
             if (matcher.test(pathId))
                 return false;
         }
         for (let i = 0; i < includeMatchers.length; ++i) {
             const matcher = includeMatchers[i];
+            if (matcher instanceof RegExp) {
+                matcher.lastIndex = 0;
+            }
             if (matcher.test(pathId))
                 return true;
         }
@@ -3377,29 +1065,106 @@ function withTrailingSlash(path) {
   return path;
 }
 
+let pnp;
 if (process.versions.pnp) {
   try {
-    node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))("pnpapi");
+    pnp = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))("pnpapi");
   } catch {
   }
 }
+function resolvePackageData(pkgName, basedir, preserveSymlinks = false, packageCache) {
+  if (pnp) {
+    try {
+      const pkg = pnp.resolveToUnqualified(pkgName, basedir, {
+        considerBuiltins: false
+      });
+      if (!pkg) return null;
+      const pkgData = loadPackageData(path$1.join(pkg, "package.json"));
+      return pkgData;
+    } catch {
+      return null;
+    }
+  }
+  while (basedir) {
+    const pkg = path$1.join(basedir, "node_modules", pkgName, "package.json");
+    try {
+      if (fs$1.existsSync(pkg)) {
+        const pkgPath = preserveSymlinks ? pkg : safeRealpathSync(pkg);
+        const pkgData = loadPackageData(pkgPath);
+        return pkgData;
+      }
+    } catch {
+    }
+    const nextBasedir = path$1.dirname(basedir);
+    if (nextBasedir === basedir) break;
+    basedir = nextBasedir;
+  }
+  return null;
+}
+function loadPackageData(pkgPath) {
+  const data = JSON.parse(stripBomTag(fs$1.readFileSync(pkgPath, "utf-8")));
+  const pkgDir = normalizePath(path$1.dirname(pkgPath));
+  const { sideEffects } = data;
+  let hasSideEffects;
+  if (typeof sideEffects === "boolean") {
+    hasSideEffects = () => sideEffects;
+  } else if (Array.isArray(sideEffects)) {
+    if (sideEffects.length <= 0) {
+      hasSideEffects = () => false;
+    } else {
+      const finalPackageSideEffects = sideEffects.map((sideEffect) => {
+        if (sideEffect.includes("/")) {
+          return sideEffect;
+        }
+        return `**/${sideEffect}`;
+      });
+      hasSideEffects = createFilter(finalPackageSideEffects, null, {
+        resolve: pkgDir
+      });
+    }
+  } else {
+    hasSideEffects = () => null;
+  }
+  const resolvedCache = {};
+  const pkg = {
+    dir: pkgDir,
+    data,
+    hasSideEffects,
+    setResolvedCache(key, entry, options) {
+      resolvedCache[getResolveCacheKey(key, options)] = entry;
+    },
+    getResolvedCache(key, options) {
+      return resolvedCache[getResolveCacheKey(key, options)];
+    }
+  };
+  return pkg;
+}
+function getResolveCacheKey(key, options) {
+  return [
+    key,
+    options.isRequire ? "1" : "0",
+    options.conditions.join("_"),
+    options.extensions.join("_"),
+    options.mainFields.join("_")
+  ].join("|");
+}
 
 const createFilter = createFilter$1;
 node_module.builtinModules.filter((id) => !id.includes(":"));
 function isInNodeModules(id) {
   return id.includes("node_modules");
 }
-const _require = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)));
-function resolveDependencyVersion(dep, pkgRelativePath = "../../package.json") {
-  const pkgPath = path$3.resolve(_require.resolve(dep), pkgRelativePath);
-  return JSON.parse(fs$1.readFileSync(pkgPath, "utf-8")).version;
-}
-const rollupVersion = resolveDependencyVersion("rollup");
+node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)));
+const _dirname = path$1.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))));
+const rollupVersion = resolvePackageData("rollup", _dirname, true)?.data.version ?? "";
 const filter = process.env.VITE_DEBUG_FILTER;
 const DEBUG = process.env.DEBUG;
 function createDebugger(namespace, options = {}) {
-  const log = debug$2(namespace);
-  const { onlyWhenFocused } = options;
+  const log = debug$3(namespace);
+  const { onlyWhenFocused, depth } = options;
+  if (depth && log.inspectOpts && log.inspectOpts.depth == null) {
+    log.inspectOpts.depth = options.depth;
+  }
   let enabled = log.enabled;
   if (enabled && onlyWhenFocused) {
     const ns = typeof onlyWhenFocused === "string" ? onlyWhenFocused : namespace;
@@ -3429,7 +1194,7 @@ function testCaseInsensitiveFS() {
 const isCaseInsensitiveFS = testCaseInsensitiveFS();
 const VOLUME_RE = /^[A-Z]:/i;
 function normalizePath(id) {
-  return path$3.posix.normalize(isWindows ? slash(id) : id);
+  return path$1.posix.normalize(isWindows ? slash(id) : id);
 }
 function fsPathFromId(id) {
   const fsPath = normalizePath(
@@ -3472,10 +1237,57 @@ function isFileReadable(filename) {
     return false;
   }
 }
+let safeRealpathSync = isWindows ? windowsSafeRealPathSync : fs$1.realpathSync.native;
+const windowsNetworkMap = /* @__PURE__ */ new Map();
+function windowsMappedRealpathSync(path2) {
+  const realPath = fs$1.realpathSync.native(path2);
+  if (realPath.startsWith("\\\\")) {
+    for (const [network, volume] of windowsNetworkMap) {
+      if (realPath.startsWith(network)) return realPath.replace(network, volume);
+    }
+  }
+  return realPath;
+}
+const parseNetUseRE = /^\w* +(\w:) +([^ ]+)\s/;
+let firstSafeRealPathSyncRun = false;
+function windowsSafeRealPathSync(path2) {
+  if (!firstSafeRealPathSyncRun) {
+    optimizeSafeRealPathSync();
+    firstSafeRealPathSyncRun = true;
+  }
+  return fs$1.realpathSync(path2);
+}
+function optimizeSafeRealPathSync() {
+  const nodeVersion = process.versions.node.split(".").map(Number);
+  if (nodeVersion[0] < 18 || nodeVersion[0] === 18 && nodeVersion[1] < 10) {
+    safeRealpathSync = fs$1.realpathSync;
+    return;
+  }
+  try {
+    fs$1.realpathSync.native(path$1.resolve("./"));
+  } catch (error) {
+    if (error.message.includes("EISDIR: illegal operation on a directory")) {
+      safeRealpathSync = fs$1.realpathSync;
+      return;
+    }
+  }
+  node_child_process.exec("net use", (error, stdout) => {
+    if (error) return;
+    const lines = stdout.split("\n");
+    for (const line of lines) {
+      const m = parseNetUseRE.exec(line);
+      if (m) windowsNetworkMap.set(m[2], m[1]);
+    }
+    if (windowsNetworkMap.size === 0) {
+      safeRealpathSync = fs$1.realpathSync.native;
+    } else {
+      safeRealpathSync = windowsMappedRealpathSync;
+    }
+  });
+}
 function arraify(target) {
   return Array.isArray(target) ? target : [target];
 }
-path$3.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))));
 function backwardCompatibleWorkerPlugins(plugins) {
   if (Array.isArray(plugins)) {
     return plugins;
@@ -3503,7 +1315,7 @@ function mergeConfigRecursively(defaults, overrides, rootPath) {
     } else if (key === "assetsInclude" && rootPath === "") {
       merged[key] = [].concat(existing, value);
       continue;
-    } else if (key === "noExternal" && rootPath === "ssr" && (existing === true || value === true)) {
+    } else if (key === "noExternal" && (rootPath === "ssr" || rootPath === "resolve") && (existing === true || value === true)) {
       merged[key] = true;
       continue;
     } else if (key === "plugins" && rootPath === "worker") {
@@ -3559,7 +1371,7 @@ function normalizeSingleAlias({
   replacement,
   customResolver
 }) {
-  if (typeof find === "string" && find[find.length - 1] === "/" && replacement[replacement.length - 1] === "/") {
+  if (typeof find === "string" && find.endsWith("/") && replacement.endsWith("/")) {
     find = find.slice(0, find.length - 1);
     replacement = replacement.slice(0, replacement.length - 1);
   }
@@ -3572,6 +1384,12 @@ function normalizeSingleAlias({
   }
   return alias;
 }
+function stripBomTag(content) {
+  if (content.charCodeAt(0) === 65279) {
+    return content.slice(1);
+  }
+  return content;
+}
 
 const CSS_LANGS_RE = (
   // eslint-disable-next-line regexp/no-unused-capturing-group
@@ -3629,7 +1447,7 @@ function splitVendorChunkPlugin() {
     const cache = new SplitVendorChunkCache();
     caches.push(cache);
     const build = config.build ?? {};
-    const format = output?.format;
+    const format = output.format;
     if (!build.ssr && !build.lib && format !== "umd" && format !== "iife") {
       return splitVendorChunk({ cache });
     }
@@ -3637,7 +1455,7 @@ function splitVendorChunkPlugin() {
   return {
     name: "vite:split-vendor-chunk",
     config(config) {
-      let outputs = config?.build?.rollupOptions?.output;
+      let outputs = config.build?.rollupOptions?.output;
       if (outputs) {
         outputs = arraify(outputs);
         for (const output of outputs) {
@@ -3677,6 +1495,26 @@ function splitVendorChunkPlugin() {
   };
 }
 
+function perEnvironmentPlugin(name, applyToEnvironment) {
+  return {
+    name,
+    applyToEnvironment
+  };
+}
+
+function perEnvironmentState(initial) {
+  const stateMap = /* @__PURE__ */ new WeakMap();
+  return function(context) {
+    const { environment } = context;
+    let state = stateMap.get(environment);
+    if (!state) {
+      state = initial(environment);
+      stateMap.set(environment, state);
+    }
+    return state;
+  };
+}
+
 var convertSourceMap$1 = {};
 
 (function (exports) {
@@ -3934,8 +1772,8 @@ var etag_1 = etag;
  * @private
  */
 
-var crypto$1 = require$$0$2;
-var Stats = fs$2.Stats;
+var crypto$1 = require$$0$1;
+var Stats = require$$1$2.Stats;
 
 /**
  * Module variables.
@@ -4173,7 +2011,7 @@ class Chunk {
 			// '  test'.trim()
 			//     split   -> '  ' + 'test'
 			//   ✔️ edit    -> '' + 'test'
-			//   ✖️ edit    -> 'test' + '' 
+			//   ✖️ edit    -> 'test' + ''
 			// TODO is this block necessary?...
 			newChunk.edit('', false);
 			this.content = '';
@@ -4266,6 +2104,9 @@ class SourceMap {
 		if (typeof properties.x_google_ignoreList !== 'undefined') {
 			this.x_google_ignoreList = properties.x_google_ignoreList;
 		}
+		if (typeof properties.debugId !== 'undefined') {
+			this.debugId = properties.debugId;
+		}
 	}
 
 	toString() {
@@ -4410,27 +2251,6 @@ class Mappings {
 		let charInHiresBoundary = false;
 
 		while (originalCharIndex < chunk.end) {
-			if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
-				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
-
-				if (this.hires === 'boundary') {
-					// in hires "boundary", group segments per word boundary than per char
-					if (wordRegex.test(original[originalCharIndex])) {
-						// for first char in the boundary found, start the boundary by pushing a segment
-						if (!charInHiresBoundary) {
-							this.rawSegments.push(segment);
-							charInHiresBoundary = true;
-						}
-					} else {
-						// for non-word char, end the boundary by pushing a segment
-						this.rawSegments.push(segment);
-						charInHiresBoundary = false;
-					}
-				} else {
-					this.rawSegments.push(segment);
-				}
-			}
-
 			if (original[originalCharIndex] === '\n') {
 				loc.line += 1;
 				loc.column = 0;
@@ -4438,7 +2258,29 @@ class Mappings {
 				this.raw[this.generatedCodeLine] = this.rawSegments = [];
 				this.generatedCodeColumn = 0;
 				first = true;
+				charInHiresBoundary = false;
 			} else {
+				if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+					const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+
+					if (this.hires === 'boundary') {
+						// in hires "boundary", group segments per word boundary than per char
+						if (wordRegex.test(original[originalCharIndex])) {
+							// for first char in the boundary found, start the boundary by pushing a segment
+							if (!charInHiresBoundary) {
+								this.rawSegments.push(segment);
+								charInHiresBoundary = true;
+							}
+						} else {
+							// for non-word char, end the boundary by pushing a segment
+							this.rawSegments.push(segment);
+							charInHiresBoundary = false;
+						}
+					} else {
+						this.rawSegments.push(segment);
+					}
+				}
+
 				loc.column += 1;
 				this.generatedCodeColumn += 1;
 				first = false;
@@ -4494,6 +2336,7 @@ class MagicString {
 			storedNames: { writable: true, value: {} },
 			indentStr: { writable: true, value: undefined },
 			ignoreList: { writable: true, value: options.ignoreList },
+			offset: { writable: true, value: options.offset || 0 },
 		});
 
 		this.byStart[0] = chunk;
@@ -4512,6 +2355,8 @@ class MagicString {
 	}
 
 	appendLeft(index, content) {
+		index = index + this.offset;
+
 		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
 
 		this._split(index);
@@ -4527,6 +2372,8 @@ class MagicString {
 	}
 
 	appendRight(index, content) {
+		index = index + this.offset;
+
 		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
 
 		this._split(index);
@@ -4542,7 +2389,7 @@ class MagicString {
 	}
 
 	clone() {
-		const cloned = new MagicString(this.original, { filename: this.filename });
+		const cloned = new MagicString(this.original, { filename: this.filename, offset: this.offset });
 
 		let originalChunk = this.firstChunk;
 		let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());
@@ -4740,7 +2587,7 @@ class MagicString {
 		if (!warned.insertLeft) {
 			console.warn(
 				'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',
-			); // eslint-disable-line no-console
+			);
 			warned.insertLeft = true;
 		}
 
@@ -4751,7 +2598,7 @@ class MagicString {
 		if (!warned.insertRight) {
 			console.warn(
 				'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',
-			); // eslint-disable-line no-console
+			);
 			warned.insertRight = true;
 		}
 
@@ -4759,6 +2606,10 @@ class MagicString {
 	}
 
 	move(start, end, index) {
+		start = start + this.offset;
+		end = end + this.offset;
+		index = index + this.offset;
+
 		if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');
 
 		this._split(start);
@@ -4801,6 +2652,9 @@ class MagicString {
 	}
 
 	update(start, end, content, options) {
+		start = start + this.offset;
+		end = end + this.offset;
+
 		if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
 
 		if (this.original.length !== 0) {
@@ -4821,7 +2675,7 @@ class MagicString {
 			if (!warned.storeName) {
 				console.warn(
 					'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',
-				); // eslint-disable-line no-console
+				);
 				warned.storeName = true;
 			}
 
@@ -4872,6 +2726,8 @@ class MagicString {
 	}
 
 	prependLeft(index, content) {
+		index = index + this.offset;
+
 		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
 
 		this._split(index);
@@ -4887,6 +2743,8 @@ class MagicString {
 	}
 
 	prependRight(index, content) {
+		index = index + this.offset;
+
 		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
 
 		this._split(index);
@@ -4902,6 +2760,9 @@ class MagicString {
 	}
 
 	remove(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+
 		if (this.original.length !== 0) {
 			while (start < 0) start += this.original.length;
 			while (end < 0) end += this.original.length;
@@ -4928,6 +2789,9 @@ class MagicString {
 	}
 
 	reset(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+
 		if (this.original.length !== 0) {
 			while (start < 0) start += this.original.length;
 			while (end < 0) end += this.original.length;
@@ -4992,7 +2856,10 @@ class MagicString {
 		return this.intro + lineStr;
 	}
 
-	slice(start = 0, end = this.original.length) {
+	slice(start = 0, end = this.original.length - this.offset) {
+		start = start + this.offset;
+		end = end + this.offset;
+
 		if (this.original.length !== 0) {
 			while (start < 0) start += this.original.length;
 			while (end < 0) end += this.original.length;
@@ -5228,11 +3095,7 @@ class MagicString {
 				if (match.index != null) {
 					const replacement = getReplacement(match, this.original);
 					if (replacement !== match[0]) {
-						this.overwrite(
-							match.index,
-							match.index + match[0].length,
-							replacement
-						);
+						this.overwrite(match.index, match.index + match[0].length, replacement);
 					}
 				}
 			});
@@ -5241,11 +3104,7 @@ class MagicString {
 			if (match && match.index != null) {
 				const replacement = getReplacement(match, this.original);
 				if (replacement !== match[0]) {
-					this.overwrite(
-						match.index,
-						match.index + match[0].length,
-						replacement
-					);
+					this.overwrite(match.index, match.index + match[0].length, replacement);
 				}
 			}
 		}
@@ -5280,8 +3139,7 @@ class MagicString {
 			index = original.indexOf(string, index + stringLength)
 		) {
 			const previous = original.slice(index, index + stringLength);
-			if (previous !== replacement)
-				this.overwrite(index, index + stringLength, replacement);
+			if (previous !== replacement) this.overwrite(index, index + stringLength, replacement);
 		}
 
 		return this;
@@ -5302,7 +3160,7 @@ class MagicString {
 	}
 }
 
-const debug$1 = createDebugger("vite:sourcemap", {
+const debug$2 = createDebugger("vite:sourcemap", {
   onlyWhenFocused: true
 });
 function genSourceMapUrl(map) {
@@ -5312,7 +3170,7 @@ function genSourceMapUrl(map) {
   return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
 }
 function getCodeWithSourcemap(type, code, map) {
-  if (debug$1) {
+  if (debug$2) {
     code += `
 /*${JSON.stringify(map, null, 2).replace(/\*\//g, "*\\/")}*/
 `;
@@ -5327,7 +3185,7 @@ function getCodeWithSourcemap(type, code, map) {
   return code;
 }
 
-const debug = createDebugger("vite:send", {
+const debug$1 = createDebugger("vite:send", {
   onlyWhenFocused: true
 });
 const alias = {
@@ -5366,7 +3224,7 @@ function send(req, res, content, type, options) {
   } else if (type === "js" && (!map || map.mappings !== "")) {
     const code = content.toString();
     if (convertSourceMap.mapFileCommentRegex.test(code)) {
-      debug?.(`Skipped injecting fallback sourcemap for ${req.url}`);
+      debug$1?.(`Skipped injecting fallback sourcemap for ${req.url}`);
     } else {
       const urlWithoutTimestamp = removeTimestampQuery(req.url);
       const ms = new MagicString(code);
@@ -5374,7 +3232,7 @@ function send(req, res, content, type, options) {
         type,
         code,
         ms.generateMap({
-          source: path$3.basename(urlWithoutTimestamp),
+          source: path$1.basename(urlWithoutTimestamp),
           hires: "boundary",
           includeContent: true
         })
@@ -5416,7 +3274,11 @@ function createLogger(level = "info", options = {}) {
     return options.customLogger;
   }
   const loggedErrors = /* @__PURE__ */ new WeakSet();
-  const { prefix = "[vite]", allowClearScreen = true } = options;
+  const {
+    prefix = "[vite]",
+    allowClearScreen = true,
+    console: console2 = globalThis.console
+  } = options;
   const thresh = LogLevels[level];
   const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
   const clear = canClearScreen ? clearScreen : () => {
@@ -5431,7 +3293,8 @@ function createLogger(level = "info", options = {}) {
       } else {
         tag = colors.red(colors.bold(prefix));
       }
-      return `${colors.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${msg}`;
+      const environment = options2.environment ? options2.environment + " " : "";
+      return `${colors.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${environment}${msg}`;
     } else {
       return msg;
     }
@@ -5446,7 +3309,7 @@ function createLogger(level = "info", options = {}) {
         if (type === lastType && msg === lastMsg) {
           sameCount++;
           clear();
-          console[method](
+          console2[method](
             format(type, msg, options2),
             colors.yellow(`(x${sameCount + 1})`)
           );
@@ -5457,10 +3320,10 @@ function createLogger(level = "info", options = {}) {
           if (options2.clear) {
             clear();
           }
-          console[method](format(type, msg, options2));
+          console2[method](format(type, msg, options2));
         }
       } else {
-        console[method](format(type, msg, options2));
+        console2[method](format(type, msg, options2));
       }
     }
   }
@@ -5509,7 +3372,7 @@ const ROOT_FILES = [
   "lerna.json"
 ];
 function hasWorkspacePackageJSON(root) {
-  const path = path$3.join(root, "package.json");
+  const path = path$1.join(root, "package.json");
   if (!isFileReadable(path)) {
     return false;
   }
@@ -5521,131 +3384,65 @@ function hasWorkspacePackageJSON(root) {
   }
 }
 function hasRootFile(root) {
-  return ROOT_FILES.some((file) => fs$1.existsSync(path$3.join(root, file)));
+  return ROOT_FILES.some((file) => fs$1.existsSync(path$1.join(root, file)));
 }
 function hasPackageJSON(root) {
-  const path = path$3.join(root, "package.json");
+  const path = path$1.join(root, "package.json");
   return fs$1.existsSync(path);
 }
 function searchForPackageRoot(current, root = current) {
   if (hasPackageJSON(current)) return current;
-  const dir = path$3.dirname(current);
+  const dir = path$1.dirname(current);
   if (!dir || dir === current) return root;
   return searchForPackageRoot(dir, root);
 }
 function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
   if (hasRootFile(current)) return current;
   if (hasWorkspacePackageJSON(current)) return current;
-  const dir = path$3.dirname(current);
+  const dir = path$1.dirname(current);
   if (!dir || dir === current) return root;
   return searchForWorkspaceRoot(dir, root);
 }
 
-function isFileServingAllowed(url, server) {
-  if (!server.config.server.fs.strict) return true;
+function isFileServingAllowed(configOrUrl, urlOrServer) {
+  const config = typeof urlOrServer === "string" ? configOrUrl : urlOrServer.config;
+  const url = typeof urlOrServer === "string" ? urlOrServer : configOrUrl;
+  if (!config.server.fs.strict) return true;
   const filePath = fsPathFromUrl(url);
-  return isFileLoadingAllowed(server, filePath);
+  return isFileLoadingAllowed(config, filePath);
 }
 function isUriInFilePath(uri, filePath) {
   return isSameFileUri(uri, filePath) || isParentDirectory(uri, filePath);
 }
-function isFileLoadingAllowed(server, filePath) {
-  const { fs } = server.config.server;
+const windowsDriveRE = /^[A-Z]:/i;
+function isFileLoadingAllowed(config, filePath) {
+  const { fs } = config.server;
   if (!fs.strict) return true;
+  if (isWindows && filePath.includes("~")) {
+    return false;
+  }
+  const hasDriveLetter = isWindows && windowsDriveRE.test(filePath);
+  const hasColon = (hasDriveLetter ? filePath.slice(2) : filePath).includes(":");
+  if (hasColon) {
+    return false;
+  }
   const filePathWithoutTrailingSlash = filePath.endsWith("/") ? filePath.slice(0, -1) : filePath;
-  if (server._fsDenyGlob(filePathWithoutTrailingSlash)) return false;
-  if (server.moduleGraph.safeModulesPath.has(filePath)) return true;
+  if (config.fsDenyGlob(filePathWithoutTrailingSlash)) return false;
+  if (config.safeModulePaths.has(filePath)) return true;
   if (fs.allow.some((uri) => isUriInFilePath(uri, filePath))) return true;
   return false;
 }
 
-var main$1 = {exports: {}};
-
-var name = "dotenv";
-var version$1 = "16.4.5";
-var description = "Loads environment variables from .env file";
-var main = "lib/main.js";
-var types = "lib/main.d.ts";
-var exports$1 = {
-	".": {
-		types: "./lib/main.d.ts",
-		require: "./lib/main.js",
-		"default": "./lib/main.js"
-	},
-	"./config": "./config.js",
-	"./config.js": "./config.js",
-	"./lib/env-options": "./lib/env-options.js",
-	"./lib/env-options.js": "./lib/env-options.js",
-	"./lib/cli-options": "./lib/cli-options.js",
-	"./lib/cli-options.js": "./lib/cli-options.js",
-	"./package.json": "./package.json"
-};
-var scripts = {
-	"dts-check": "tsc --project tests/types/tsconfig.json",
-	lint: "standard",
-	"lint-readme": "standard-markdown",
-	pretest: "npm run lint && npm run dts-check",
-	test: "tap tests/*.js --100 -Rspec",
-	"test:coverage": "tap --coverage-report=lcov",
-	prerelease: "npm test",
-	release: "standard-version"
-};
-var repository = {
-	type: "git",
-	url: "git://github.com/motdotla/dotenv.git"
-};
-var funding = "https://dotenvx.com";
-var keywords = [
-	"dotenv",
-	"env",
-	".env",
-	"environment",
-	"variables",
-	"config",
-	"settings"
-];
-var readmeFilename = "README.md";
-var license = "BSD-2-Clause";
-var devDependencies = {
-	"@definitelytyped/dtslint": "^0.0.133",
-	"@types/node": "^18.11.3",
-	decache: "^4.6.1",
-	sinon: "^14.0.1",
-	standard: "^17.0.0",
-	"standard-markdown": "^7.1.0",
-	"standard-version": "^9.5.0",
-	tap: "^16.3.0",
-	tar: "^6.1.11",
-	typescript: "^4.8.4"
-};
-var engines = {
-	node: ">=12"
-};
-var browser = {
-	fs: false
-};
+var main = {exports: {}};
+
+var version$1 = "16.5.0";
 var require$$4 = {
-	name: name,
-	version: version$1,
-	description: description,
-	main: main,
-	types: types,
-	exports: exports$1,
-	scripts: scripts,
-	repository: repository,
-	funding: funding,
-	keywords: keywords,
-	readmeFilename: readmeFilename,
-	license: license,
-	devDependencies: devDependencies,
-	engines: engines,
-	browser: browser
-};
+	version: version$1};
 
-const fs = fs$2;
-const path = require$$0$1;
+const fs = require$$1$2;
+const path = require$$1$1;
 const os = require$$2;
-const crypto = require$$0$2;
+const crypto = require$$0$1;
 const packageJson = require$$4;
 
 const version = packageJson.version;
@@ -5733,10 +3530,6 @@ function _parseVault (options) {
   return DotenvModule.parse(decrypted)
 }
 
-function _log (message) {
-  console.log(`[dotenv@${version}][INFO] ${message}`);
-}
-
 function _warn (message) {
   console.log(`[dotenv@${version}][WARN] ${message}`);
 }
@@ -5832,7 +3625,10 @@ function _resolveHome (envPath) {
 }
 
 function _configVault (options) {
-  _log('Loading env from encrypted .env.vault');
+  const debug = Boolean(options && options.debug);
+  if (debug) {
+    _debug('Loading env from encrypted .env.vault');
+  }
 
   const parsed = DotenvModule._parseVault(options);
 
@@ -5994,92 +3790,104 @@ const DotenvModule = {
   populate
 };
 
-main$1.exports.configDotenv = DotenvModule.configDotenv;
-main$1.exports._configVault = DotenvModule._configVault;
-main$1.exports._parseVault = DotenvModule._parseVault;
-main$1.exports.config = DotenvModule.config;
-main$1.exports.decrypt = DotenvModule.decrypt;
-var parse_1 = main$1.exports.parse = DotenvModule.parse;
-main$1.exports.populate = DotenvModule.populate;
+main.exports.configDotenv = DotenvModule.configDotenv;
+main.exports._configVault = DotenvModule._configVault;
+main.exports._parseVault = DotenvModule._parseVault;
+main.exports.config = DotenvModule.config;
+main.exports.decrypt = DotenvModule.decrypt;
+var parse_1 = main.exports.parse = DotenvModule.parse;
+main.exports.populate = DotenvModule.populate;
 
-main$1.exports = DotenvModule;
-
-// * /
-// *   (\\)?            # is it escaped with a backslash?
-// *   (\$)             # literal $
-// *   (?!\()           # shouldnt be followed by parenthesis
-// *   (\{?)            # first brace wrap opening
-// *   ([\w.]+)         # key
-// *   (?::-((?:\$\{(?:\$\{(?:\$\{[^}]*\}|[^}])*}|[^}])*}|[^}])+))? # optional default nested 3 times
-// *   (\}?)            # last brace warp closing
-// * /xi
-
-const DOTENV_SUBSTITUTION_REGEX = /(\\)?(\$)(?!\()(\{?)([\w.]+)(?::?-((?:\$\{(?:\$\{(?:\$\{[^}]*\}|[^}])*}|[^}])*}|[^}])+))?(\}?)/gi;
+main.exports = DotenvModule;
 
 function _resolveEscapeSequences (value) {
   return value.replace(/\\\$/g, '$')
 }
 
-function interpolate (value, processEnv, parsed) {
-  return value.replace(DOTENV_SUBSTITUTION_REGEX, (match, escaped, dollarSign, openBrace, key, defaultValue, closeBrace) => {
-    if (escaped === '\\') {
-      return match.slice(1)
-    } else {
-      if (processEnv[key]) {
-        if (processEnv[key] === parsed[key]) {
-          return processEnv[key]
-        } else {
-          // scenario: PASSWORD_EXPAND_NESTED=${PASSWORD_EXPAND}
-          return interpolate(processEnv[key], processEnv, parsed)
-        }
-      }
+function expandValue (value, processEnv, runningParsed) {
+  const env = { ...runningParsed, ...processEnv }; // process.env wins
 
-      if (parsed[key]) {
-        // avoid recursion from EXPAND_SELF=$EXPAND_SELF
-        if (parsed[key] === value) {
-          return parsed[key]
-        } else {
-          return interpolate(parsed[key], processEnv, parsed)
-        }
-      }
+  const regex = /(?<!\\)\${([^{}]+)}|(?<!\\)\$([A-Za-z_][A-Za-z0-9_]*)/g;
 
-      if (defaultValue) {
-        if (defaultValue.startsWith('$')) {
-          return interpolate(defaultValue, processEnv, parsed)
-        } else {
-          return defaultValue
-        }
+  let result = value;
+  let match;
+  const seen = new Set(); // self-referential checker
+
+  while ((match = regex.exec(result)) !== null) {
+    seen.add(result);
+
+    const [template, bracedExpression, unbracedExpression] = match;
+    const expression = bracedExpression || unbracedExpression;
+
+    // match the operators `:+`, `+`, `:-`, and `-`
+    const opRegex = /(:\+|\+|:-|-)/;
+    // find first match
+    const opMatch = expression.match(opRegex);
+    const splitter = opMatch ? opMatch[0] : null;
+
+    const r = expression.split(splitter);
+
+    let defaultValue;
+    let value;
+
+    const key = r.shift();
+
+    if ([':+', '+'].includes(splitter)) {
+      defaultValue = env[key] ? r.join(splitter) : '';
+      value = null;
+    } else {
+      defaultValue = r.join(splitter);
+      value = env[key];
+    }
+
+    if (value) {
+      // self-referential check
+      if (seen.has(value)) {
+        result = result.replace(template, defaultValue);
+      } else {
+        result = result.replace(template, value);
       }
+    } else {
+      result = result.replace(template, defaultValue);
+    }
 
-      return ''
+    // if the result equaled what was in process.env and runningParsed then stop expanding
+    if (result === runningParsed[key]) {
+      break
     }
-  })
+
+    regex.lastIndex = 0; // reset regex search position to re-evaluate after each replacement
+  }
+
+  return result
 }
 
 function expand (options) {
+  // for use with progressive expansion
+  // const runningParsed = {}
+
   let processEnv = process.env;
   if (options && options.processEnv != null) {
     processEnv = options.processEnv;
   }
 
+  // dotenv.config() ran before this so the assumption is process.env has already been set
   for (const key in options.parsed) {
     let value = options.parsed[key];
 
-    const inProcessEnv = Object.prototype.hasOwnProperty.call(processEnv, key);
-    if (inProcessEnv) {
-      if (processEnv[key] === options.parsed[key]) {
-        // assume was set to processEnv from the .env file if the values match and therefore interpolate
-        value = interpolate(value, processEnv, options.parsed);
-      } else {
-        // do not interpolate - assume processEnv had the intended value even if containing a $.
-        value = processEnv[key];
-      }
+    // short-circuit scenario: process.env was already set prior to the file value
+    if (processEnv[key] && processEnv[key] !== value) {
+      value = processEnv[key];
     } else {
-      // not inProcessEnv so assume interpolation for this .env key
-      value = interpolate(value, processEnv, options.parsed);
+      // PATCH: we pass options.parsed instead of runningParsed
+      //        to allow variables declared in other files to be used
+      value = expandValue(value, processEnv, options.parsed);
     }
 
     options.parsed[key] = _resolveEscapeSequences(value);
+
+    // for use with progressive expansion
+    // runningParsed[key] = _resolveEscapeSequences(value)
   }
 
   for (const processKey in options.parsed) {
@@ -6091,19 +3899,25 @@ function expand (options) {
 
 var expand_1 = expand;
 
+const debug = createDebugger("vite:env");
 function getEnvFilesForMode(mode, envDir) {
-  return [
-    /** default file */
-    `.env`,
-    /** local file */
-    `.env.local`,
-    /** mode file */
-    `.env.${mode}`,
-    /** mode local file */
-    `.env.${mode}.local`
-  ].map((file) => normalizePath(path$3.join(envDir, file)));
+  if (envDir !== false) {
+    return [
+      /** default file */
+      `.env`,
+      /** local file */
+      `.env.local`,
+      /** mode file */
+      `.env.${mode}`,
+      /** mode local file */
+      `.env.${mode}.local`
+    ].map((file) => normalizePath(path$1.join(envDir, file)));
+  }
+  return [];
 }
 function loadEnv(mode, envDir, prefixes = "VITE_") {
+  const start = performance.now();
+  const getTime = () => `${(performance.now() - start).toFixed(2)}ms`;
   if (mode === "local") {
     throw new Error(
       `"local" cannot be used as a mode name because it conflicts with the .local postfix for .env files.`
@@ -6112,12 +3926,14 @@ function loadEnv(mode, envDir, prefixes = "VITE_") {
   prefixes = arraify(prefixes);
   const env = {};
   const envFiles = getEnvFilesForMode(mode, envDir);
+  debug?.(`loading env files: %O`, envFiles);
   const parsed = Object.fromEntries(
     envFiles.flatMap((filePath) => {
       if (!tryStatSync(filePath)?.isFile()) return [];
       return Object.entries(parse_1(fs$1.readFileSync(filePath)));
     })
   );
+  debug?.(`env files loaded in ${getTime()}`);
   if (parsed.NODE_ENV && process.env.VITE_USER_NODE_ENV === void 0) {
     process.env.VITE_USER_NODE_ENV = parsed.NODE_ENV;
   }
@@ -6139,6 +3955,7 @@ function loadEnv(mode, envDir, prefixes = "VITE_") {
       env[key] = process.env[key];
     }
   }
+  debug?.(`using resolved env: %O`, env);
   return env;
 }
 function resolveEnvPrefix({
@@ -6156,6 +3973,11 @@ function resolveEnvPrefix({
 exports.esbuildVersion = esbuild.version;
 exports.createFilter = createFilter;
 exports.createLogger = createLogger;
+exports.defaultAllowedOrigins = defaultAllowedOrigins;
+exports.defaultClientConditions = DEFAULT_CLIENT_CONDITIONS;
+exports.defaultClientMainFields = DEFAULT_CLIENT_MAIN_FIELDS;
+exports.defaultServerConditions = DEFAULT_SERVER_CONDITIONS;
+exports.defaultServerMainFields = DEFAULT_SERVER_MAIN_FIELDS;
 exports.isCSSRequest = isCSSRequest;
 exports.isFileLoadingAllowed = isFileLoadingAllowed;
 exports.isFileServingAllowed = isFileServingAllowed;
@@ -6163,6 +3985,8 @@ exports.loadEnv = loadEnv;
 exports.mergeAlias = mergeAlias;
 exports.mergeConfig = mergeConfig;
 exports.normalizePath = normalizePath;
+exports.perEnvironmentPlugin = perEnvironmentPlugin;
+exports.perEnvironmentState = perEnvironmentState;
 exports.resolveEnvPrefix = resolveEnvPrefix;
 exports.rollupVersion = rollupVersion;
 exports.searchForWorkspaceRoot = searchForWorkspaceRoot;