vite 6.0.0-beta.0 → 6.0.0-beta.10

package/dist/node-cjs/publicUtils.cjs

@@ -1,32 +1,52 @@
 '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 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 comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -125,35 +145,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,54 +169,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"),
-
-		blackBright: init("\x1b[90m", "\x1b[39m"),
-		redBright: init("\x1b[91m", "\x1b[39m"),
-		greenBright: init("\x1b[92m", "\x1b[39m"),
-		yellowBright: init("\x1b[93m", "\x1b[39m"),
-		blueBright: init("\x1b[94m", "\x1b[39m"),
-		magentaBright: init("\x1b[95m", "\x1b[39m"),
-		cyanBright: init("\x1b[96m", "\x1b[39m"),
-		whiteBright: init("\x1b[97m", "\x1b[39m"),
-
-		bgBlackBright: init("\x1b[100m","\x1b[49m"),
-		bgRedBright: init("\x1b[101m","\x1b[49m"),
-		bgGreenBright: init("\x1b[102m","\x1b[49m"),
-		bgYellowBright: init("\x1b[103m","\x1b[49m"),
-		bgBlueBright: init("\x1b[104m","\x1b[49m"),
-		bgMagentaBright: init("\x1b[105m","\x1b[49m"),
-		bgCyanBright: init("\x1b[106m","\x1b[49m"),
-		bgWhiteBright: init("\x1b[107m","\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"),
 	}
 };
 
@@ -1247,9 +1253,8 @@ if (typeof process === 'undefined' || process.type === 'renderer' || process.bro
 var srcExports = src.exports;
 var debug$2 = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
 
-var utils$3 = {};
+var utils$4 = {};
 
-const path$2 = require$$0$1;
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -1272,6 +1277,7 @@ 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 SEP = '/';
 
 const POSIX_CHARS = {
   DOT_LITERAL,
@@ -1288,7 +1294,8 @@ const POSIX_CHARS = {
   NO_DOTS_SLASH,
   QMARK_NO_DOT,
   STAR,
-  START_ANCHOR
+  START_ANCHOR,
+  SEP
 };
 
 /**
@@ -1308,7 +1315,8 @@ const WINDOWS_CHARS = {
   NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
   QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
   START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
-  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+  SEP: '\\'
 };
 
 /**
@@ -1402,8 +1410,6 @@ var constants$2 = {
   CHAR_VERTICAL_LINE: 124, /* | */
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
 
-  SEP: path$2.sep,
-
   /**
    * Create EXTGLOB_CHARS
    */
@@ -1427,10 +1433,10 @@ var constants$2 = {
   }
 };
 
+/*global navigator*/
+
 (function (exports) {
 
-	const path = require$$0$1;
-	const win32 = process.platform === 'win32';
 	const {
 	  REGEX_BACKSLASH,
 	  REGEX_REMOVE_BACKSLASH,
@@ -1444,25 +1450,23 @@ var constants$2 = {
 	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.isWindows = () => {
+	  if (typeof navigator !== 'undefined' && navigator.platform) {
+	    const platform = navigator.platform.toLowerCase();
+	    return platform === 'win32' || platform === 'windows';
+	  }
 
-	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;
+	  if (typeof process !== 'undefined' && process.platform) {
+	    return process.platform === 'win32';
 	  }
+
 	  return false;
 	};
 
-	exports.isWindows = options => {
-	  if (options && typeof options.windows === 'boolean') {
-	    return options.windows;
-	  }
-	  return win32 === true || path.sep === '\\';
+	exports.removeBackslashes = str => {
+	  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+	    return match === '\\' ? '' : match;
+	  });
 	};
 
 	exports.escapeLast = (input, char, lastIdx) => {
@@ -1490,10 +1494,21 @@ var constants$2 = {
 	    output = `(?:^(?!${output}).*$)`;
 	  }
 	  return output;
+	};
+
+	exports.basename = (path, { windows } = {}) => {
+	  const segs = path.split(windows ? /[\\/]/ : '/');
+	  const last = segs[segs.length - 1];
+
+	  if (last === '') {
+	    return segs[segs.length - 2];
+	  }
+
+	  return last;
 	}; 
-} (utils$3));
+} (utils$4));
 
-const utils$2 = utils$3;
+const utils$3 = utils$4;
 const {
   CHAR_ASTERISK,             /* * */
   CHAR_AT,                   /* @ */
@@ -1810,10 +1825,10 @@ const scan$1 = (input, options) => {
   }
 
   if (opts.unescape === true) {
-    if (glob) glob = utils$2.removeBackslashes(glob);
+    if (glob) glob = utils$3.removeBackslashes(glob);
 
     if (base && backslashes === true) {
-      base = utils$2.removeBackslashes(base);
+      base = utils$3.removeBackslashes(base);
     }
   }
 
@@ -1884,7 +1899,7 @@ const scan$1 = (input, options) => {
 var scan_1 = scan$1;
 
 const constants$1 = constants$2;
-const utils$1 = utils$3;
+const utils$2 = utils$4;
 
 /**
  * Constants
@@ -1947,10 +1962,9 @@ const parse$2 = (input, options) => {
   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 PLATFORM_CHARS = constants$1.globChars(opts.windows);
   const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
 
   const {
@@ -2003,7 +2017,7 @@ const parse$2 = (input, options) => {
     tokens
   };
 
-  input = utils$1.removePrefix(input, state);
+  input = utils$2.removePrefix(input, state);
   len = input.length;
 
   const extglobs = [];
@@ -2086,8 +2100,8 @@ const parse$2 = (input, options) => {
 
     if (tok.value || tok.output) append(tok);
     if (prev && prev.type === 'text' && tok.type === 'text') {
+      prev.output = (prev.output || prev.value) + tok.value;
       prev.value += tok.value;
-      prev.output = (prev.output || '') + tok.value;
       return;
     }
 
@@ -2196,7 +2210,7 @@ const parse$2 = (input, options) => {
       return state;
     }
 
-    state.output = utils$1.wrapOutput(output, state, options);
+    state.output = utils$2.wrapOutput(output, state, options);
     return state;
   }
 
@@ -2309,7 +2323,7 @@ const parse$2 = (input, options) => {
      */
 
     if (state.quotes === 1 && value !== '"') {
-      value = utils$1.escapeRegex(value);
+      value = utils$2.escapeRegex(value);
       prev.value += value;
       append({ value });
       continue;
@@ -2399,11 +2413,11 @@ const parse$2 = (input, options) => {
 
       // when literal brackets are explicitly disabled
       // assume we should match with a regex character class
-      if (opts.literalBrackets === false || utils$1.hasRegexChars(prevValue)) {
+      if (opts.literalBrackets === false || utils$2.hasRegexChars(prevValue)) {
         continue;
       }
 
-      const escaped = utils$1.escapeRegex(prev.value);
+      const escaped = utils$2.escapeRegex(prev.value);
       state.output = state.output.slice(0, -prev.value.length);
 
       // when literal brackets are explicitly enabled
@@ -2575,10 +2589,6 @@ const parse$2 = (input, options) => {
         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}`;
         }
@@ -2835,19 +2845,19 @@ const parse$2 = (input, options) => {
 
   while (state.brackets > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
-    state.output = utils$1.escapeLast(state.output, '[');
+    state.output = utils$2.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, '(');
+    state.output = utils$2.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, '{');
+    state.output = utils$2.escapeLast(state.output, '{');
     decrement('braces');
   }
 
@@ -2886,7 +2896,6 @@ parse$2.fastpaths = (input, options) => {
   }
 
   input = REPLACEMENTS[input] || input;
-  const win32 = utils$1.isWindows(options);
 
   // create constants based on platform, for windows or posix
   const {
@@ -2899,7 +2908,7 @@ parse$2.fastpaths = (input, options) => {
     NO_DOTS_SLASH,
     STAR,
     START_ANCHOR
-  } = constants$1.globChars(win32);
+  } = constants$1.globChars(opts.windows);
 
   const nodot = opts.dot ? NO_DOTS : NO_DOT;
   const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
@@ -2954,7 +2963,7 @@ parse$2.fastpaths = (input, options) => {
     }
   };
 
-  const output = utils$1.removePrefix(input, state);
+  const output = utils$2.removePrefix(input, state);
   let source = create(output);
 
   if (source && opts.strictSlashes !== true) {
@@ -2966,10 +2975,9 @@ parse$2.fastpaths = (input, options) => {
 
 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 utils$1 = utils$4;
 const constants = constants$2;
 const isObject$2 = val => val && typeof val === 'object' && !Array.isArray(val);
 
@@ -3015,7 +3023,7 @@ const picomatch$1 = (glob, options, returnState = false) => {
   }
 
   const opts = options || {};
-  const posix = utils.isWindows(options);
+  const posix = opts.windows;
   const regex = isState
     ? picomatch$1.compileRe(glob, options)
     : picomatch$1.makeRe(glob, options, false, true);
@@ -3090,7 +3098,7 @@ picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
   }
 
   const opts = options || {};
-  const format = opts.format || (posix ? utils.toPosixSlashes : null);
+  const format = opts.format || (posix ? utils$1.toPosixSlashes : null);
   let match = input === glob;
   let output = (match && format) ? format(input) : input;
 
@@ -3124,9 +3132,9 @@ picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
  * @api public
  */
 
-picomatch$1.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+picomatch$1.matchBase = (input, glob, options) => {
   const regex = glob instanceof RegExp ? glob : picomatch$1.makeRe(glob, options);
-  return regex.test(path$1.basename(input));
+  return regex.test(utils$1.basename(input));
 };
 
 /**
@@ -3305,11 +3313,25 @@ picomatch$1.constants = constants;
  * Expose "picomatch"
  */
 
-var picomatch_1 = picomatch$1;
+var picomatch_1$1 = picomatch$1;
+
+const pico = picomatch_1$1;
+const utils = utils$4;
+
+function picomatch(glob, options, returnState = false) {
+  // default to os.platform()
+  if (options && (options.windows === null || options.windows === undefined)) {
+    // don't mutate the original options object
+    options = { ...options, windows: utils.isWindows() };
+  }
+
+  return pico(glob, options, returnState);
+}
 
-var picomatch = picomatch_1;
+Object.assign(picomatch, pico);
+var picomatch_1 = picomatch;
 
-var pm = /*@__PURE__*/getDefaultExportFromCjs(picomatch);
+var pm = /*@__PURE__*/getDefaultExportFromCjs(picomatch_1);
 
 // Helper since Typescript can't detect readonly arrays with Array.isArray
 function isArray(arg) {
@@ -3323,23 +3345,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;
@@ -3356,10 +3379,12 @@ 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) {
@@ -3397,29 +3422,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(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 { 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;
@@ -3449,7 +3551,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(
@@ -3492,10 +3594,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;
@@ -3697,6 +3846,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) {
@@ -3954,8 +4123,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.
@@ -4430,27 +4599,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;
@@ -4459,6 +4607,27 @@ class Mappings {
 				this.generatedCodeColumn = 0;
 				first = true;
 			} 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;
@@ -5394,7 +5563,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
         })
@@ -5436,7 +5605,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 : () => {
@@ -5467,7 +5640,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})`)
           );
@@ -5478,10 +5651,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));
       }
     }
   }
@@ -5530,7 +5703,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;
   }
@@ -5542,22 +5715,22 @@ 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);
 }
@@ -5664,10 +5837,10 @@ var require$$4 = {
 	browser: browser
 };
 
-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;
@@ -6123,7 +6296,7 @@ function getEnvFilesForMode(mode, envDir) {
     `.env.${mode}`,
     /** mode local file */
     `.env.${mode}.local`
-  ].map((file) => normalizePath(path$3.join(envDir, file)));
+  ].map((file) => normalizePath(path$1.join(envDir, file)));
 }
 function loadEnv(mode, envDir, prefixes = "VITE_") {
   if (mode === "local") {
@@ -6178,6 +6351,10 @@ function resolveEnvPrefix({
 exports.esbuildVersion = esbuild.version;
 exports.createFilter = createFilter;
 exports.createLogger = createLogger;
+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;
@@ -6185,6 +6362,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;