vite 6.0.0-alpha.8 → 6.0.0-beta.0

package/dist/node-cjs/publicUtils.cjs

@@ -14,17 +14,18 @@ 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());
+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()
+);
 const VERSION = version$2;
-/**
- * Prefix for resolved fs paths, since windows paths may not be valid as URLs.
- */
 const FS_PREFIX = `/@fs/`;
 const VITE_PACKAGE_DIR = path$3.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))), '../../..');
-const CLIENT_ENTRY = path$3.resolve(VITE_PACKAGE_DIR, 'dist/client/client.mjs');
-path$3.resolve(VITE_PACKAGE_DIR, 'dist/client/env.mjs');
+  // 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))),
+  "../../.."
+);
+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 comma = ','.charCodeAt(0);
@@ -37,6 +38,20 @@ for (let i = 0; i < chars.length; i++) {
     intToChar[i] = c;
     charToInt[c] = i;
 }
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+    do {
+        let clamped = delta & 0b011111;
+        delta >>>= 5;
+        if (delta > 0)
+            clamped |= 0b100000;
+        builder.write(intToChar[clamped]);
+    } while (delta > 0);
+    return num;
+}
+
+const bufLength = 1024 * 16;
 // Provide a fallback for older environments.
 const td = typeof TextDecoder !== 'undefined'
     ? /* #__PURE__ */ new TextDecoder()
@@ -56,80 +71,75 @@ const td = typeof TextDecoder !== 'undefined'
                 return out;
             },
         };
+class StringWriter {
+    constructor() {
+        this.pos = 0;
+        this.out = '';
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+}
 function encode(decoded) {
-    const state = new Int32Array(5);
-    const bufLength = 1024 * 16;
-    const subLength = bufLength - 36;
-    const buf = new Uint8Array(bufLength);
-    const sub = buf.subarray(0, subLength);
-    let pos = 0;
-    let out = '';
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
     for (let i = 0; i < decoded.length; i++) {
         const line = decoded[i];
-        if (i > 0) {
-            if (pos === bufLength) {
-                out += td.decode(buf);
-                pos = 0;
-            }
-            buf[pos++] = semicolon;
-        }
+        if (i > 0)
+            writer.write(semicolon);
         if (line.length === 0)
             continue;
-        state[0] = 0;
+        let genColumn = 0;
         for (let j = 0; j < line.length; j++) {
             const segment = line[j];
-            // We can push up to 5 ints, each int can take at most 7 chars, and we
-            // may push a comma.
-            if (pos > subLength) {
-                out += td.decode(sub);
-                buf.copyWithin(0, subLength, pos);
-                pos -= subLength;
-            }
             if (j > 0)
-                buf[pos++] = comma;
-            pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
+                writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
             if (segment.length === 1)
                 continue;
-            pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
-            pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
-            pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
             if (segment.length === 4)
                 continue;
-            pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
         }
     }
-    return out + td.decode(buf.subarray(0, pos));
-}
-function encodeInteger(buf, pos, state, segment, j) {
-    const next = segment[j];
-    let num = next - state[j];
-    state[j] = next;
-    num = num < 0 ? (-num << 1) | 1 : num << 1;
-    do {
-        let clamped = num & 0b011111;
-        num >>>= 5;
-        if (num > 0)
-            clamped |= 0b100000;
-        buf[pos++] = intToChar[clamped];
-    } while (num > 0);
-    return pos;
+    return writer.flush();
 }
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-var picocolors = {exports: {}};
+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.');
+}
 
-let tty = require$$0;
+var picocolors = {exports: {}};
 
+let argv = process.argv || [],
+	env = process.env;
 let isColorSupported =
-	!("NO_COLOR" in process.env || process.argv.includes("--no-color")) &&
-	("FORCE_COLOR" in process.env ||
-		process.argv.includes("--color") ||
+	!("NO_COLOR" in env || argv.includes("--no-color")) &&
+	("FORCE_COLOR" in env ||
+		argv.includes("--color") ||
 		process.platform === "win32" ||
-		(tty.isatty(1) && process.env.TERM !== "dumb") ||
-		"CI" in process.env);
+		(commonjsRequire != null && require$$0.isatty(1) && env.TERM !== "dumb") ||
+		"CI" in env);
 
 let formatter =
 	(open, close, replace = open) =>
@@ -142,40 +152,67 @@ let formatter =
 	};
 
 let replaceClose = (string, close, replace, index) => {
-	let start = string.substring(0, index) + replace;
-	let end = string.substring(index + close.length);
-	let nextIndex = end.indexOf(close);
-	return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end
+	let result = "";
+	let cursor = 0;
+	do {
+		result += string.substring(cursor, index) + replace;
+		cursor = index + close.length;
+		index = string.indexOf(close, cursor);
+	} while (~index)
+	return result + string.substring(cursor)
 };
 
-let createColors = (enabled = isColorSupported) => ({
-	isColorSupported: enabled,
-	reset: enabled ? s => `\x1b[0m${s}\x1b[0m` : String,
-	bold: enabled ? formatter("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m") : String,
-	dim: enabled ? formatter("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m") : String,
-	italic: enabled ? formatter("\x1b[3m", "\x1b[23m") : String,
-	underline: enabled ? formatter("\x1b[4m", "\x1b[24m") : String,
-	inverse: enabled ? formatter("\x1b[7m", "\x1b[27m") : String,
-	hidden: enabled ? formatter("\x1b[8m", "\x1b[28m") : String,
-	strikethrough: enabled ? formatter("\x1b[9m", "\x1b[29m") : String,
-	black: enabled ? formatter("\x1b[30m", "\x1b[39m") : String,
-	red: enabled ? formatter("\x1b[31m", "\x1b[39m") : String,
-	green: enabled ? formatter("\x1b[32m", "\x1b[39m") : String,
-	yellow: enabled ? formatter("\x1b[33m", "\x1b[39m") : String,
-	blue: enabled ? formatter("\x1b[34m", "\x1b[39m") : String,
-	magenta: enabled ? formatter("\x1b[35m", "\x1b[39m") : String,
-	cyan: enabled ? formatter("\x1b[36m", "\x1b[39m") : String,
-	white: enabled ? formatter("\x1b[37m", "\x1b[39m") : String,
-	gray: enabled ? formatter("\x1b[90m", "\x1b[39m") : String,
-	bgBlack: enabled ? formatter("\x1b[40m", "\x1b[49m") : String,
-	bgRed: enabled ? formatter("\x1b[41m", "\x1b[49m") : String,
-	bgGreen: enabled ? formatter("\x1b[42m", "\x1b[49m") : String,
-	bgYellow: enabled ? formatter("\x1b[43m", "\x1b[49m") : String,
-	bgBlue: enabled ? formatter("\x1b[44m", "\x1b[49m") : String,
-	bgMagenta: enabled ? formatter("\x1b[45m", "\x1b[49m") : String,
-	bgCyan: enabled ? formatter("\x1b[46m", "\x1b[49m") : String,
-	bgWhite: enabled ? formatter("\x1b[47m", "\x1b[49m") : String,
-});
+let createColors = (enabled = isColorSupported) => {
+	let init = 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"),
+	}
+};
 
 picocolors.exports = createColors();
 picocolors.exports.createColors = createColors;
@@ -218,7 +255,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) {
@@ -773,6 +810,8 @@ function requireBrowser () {
 				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) ||
@@ -780,7 +819,7 @@ function requireBrowser () {
 				(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 && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+				(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+)/));
 		}
@@ -1116,11 +1155,11 @@ function requireNode () {
 		}
 
 		/**
-		 * Invokes `util.format()` with the specified arguments and writes to stderr.
+		 * Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
 		 */
 
 		function log(...args) {
-			return process.stderr.write(util.format(...args) + '\n');
+			return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + '\n');
 		}
 
 		/**
@@ -2956,9 +2995,9 @@ const isObject$2 = val => val && typeof val === 'object' && !Array.isArray(val);
  * @api public
  */
 
-const picomatch$2 = (glob, options, returnState = false) => {
+const picomatch$1 = (glob, options, returnState = false) => {
   if (Array.isArray(glob)) {
-    const fns = glob.map(input => picomatch$2(input, options, returnState));
+    const fns = glob.map(input => picomatch$1(input, options, returnState));
     const arrayMatcher = str => {
       for (const isMatch of fns) {
         const state = isMatch(str);
@@ -2978,8 +3017,8 @@ const picomatch$2 = (glob, options, returnState = false) => {
   const opts = options || {};
   const posix = utils.isWindows(options);
   const regex = isState
-    ? picomatch$2.compileRe(glob, options)
-    : picomatch$2.makeRe(glob, options, false, true);
+    ? picomatch$1.compileRe(glob, options)
+    : picomatch$1.makeRe(glob, options, false, true);
 
   const state = regex.state;
   delete regex.state;
@@ -2987,11 +3026,11 @@ const picomatch$2 = (glob, options, returnState = false) => {
   let isIgnored = () => false;
   if (opts.ignore) {
     const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-    isIgnored = picomatch$2(opts.ignore, ignoreOpts, returnState);
+    isIgnored = picomatch$1(opts.ignore, ignoreOpts, returnState);
   }
 
   const matcher = (input, returnObject = false) => {
-    const { isMatch, match, output } = picomatch$2.test(input, regex, options, { glob, posix });
+    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') {
@@ -3041,7 +3080,7 @@ const picomatch$2 = (glob, options, returnState = false) => {
  * @api public
  */
 
-picomatch$2.test = (input, regex, options, { glob, posix } = {}) => {
+picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected input to be a string');
   }
@@ -3062,7 +3101,7 @@ picomatch$2.test = (input, regex, options, { glob, posix } = {}) => {
 
   if (match === false || opts.capture === true) {
     if (opts.matchBase === true || opts.basename === true) {
-      match = picomatch$2.matchBase(input, regex, options, posix);
+      match = picomatch$1.matchBase(input, regex, options, posix);
     } else {
       match = regex.exec(output);
     }
@@ -3085,8 +3124,8 @@ picomatch$2.test = (input, regex, options, { glob, posix } = {}) => {
  * @api public
  */
 
-picomatch$2.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
-  const regex = glob instanceof RegExp ? glob : picomatch$2.makeRe(glob, options);
+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));
 };
 
@@ -3107,7 +3146,7 @@ picomatch$2.matchBase = (input, glob, options, posix = utils.isWindows(options))
  * @api public
  */
 
-picomatch$2.isMatch = (str, patterns, options) => picomatch$2(patterns, options)(str);
+picomatch$1.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);
 
 /**
  * Parse a glob pattern to create the source string for a regular
@@ -3123,8 +3162,8 @@ picomatch$2.isMatch = (str, patterns, options) => picomatch$2(patterns, options)
  * @api public
  */
 
-picomatch$2.parse = (pattern, options) => {
-  if (Array.isArray(pattern)) return pattern.map(p => picomatch$2.parse(p, options));
+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 });
 };
 
@@ -3155,7 +3194,7 @@ picomatch$2.parse = (pattern, options) => {
  * @api public
  */
 
-picomatch$2.scan = (input, options) => scan(input, options);
+picomatch$1.scan = (input, options) => scan(input, options);
 
 /**
  * Compile a regular expression from the `state` object returned by the
@@ -3169,7 +3208,7 @@ picomatch$2.scan = (input, options) => scan(input, options);
  * @api public
  */
 
-picomatch$2.compileRe = (state, options, returnOutput = false, returnState = false) => {
+picomatch$1.compileRe = (state, options, returnOutput = false, returnState = false) => {
   if (returnOutput === true) {
     return state.output;
   }
@@ -3183,7 +3222,7 @@ picomatch$2.compileRe = (state, options, returnOutput = false, returnState = fal
     source = `^(?!${source}).*$`;
   }
 
-  const regex = picomatch$2.toRegex(source, options);
+  const regex = picomatch$1.toRegex(source, options);
   if (returnState === true) {
     regex.state = state;
   }
@@ -3210,7 +3249,7 @@ picomatch$2.compileRe = (state, options, returnOutput = false, returnState = fal
  * @api public
  */
 
-picomatch$2.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+picomatch$1.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
   if (!input || typeof input !== 'string') {
     throw new TypeError('Expected a non-empty string');
   }
@@ -3225,7 +3264,7 @@ picomatch$2.makeRe = (input, options = {}, returnOutput = false, returnState = f
     parsed = parse$1(input, options);
   }
 
-  return picomatch$2.compileRe(parsed, options, returnOutput, returnState);
+  return picomatch$1.compileRe(parsed, options, returnOutput, returnState);
 };
 
 /**
@@ -3245,7 +3284,7 @@ picomatch$2.makeRe = (input, options = {}, returnOutput = false, returnState = f
  * @api public
  */
 
-picomatch$2.toRegex = (source, options) => {
+picomatch$1.toRegex = (source, options) => {
   try {
     const opts = options || {};
     return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
@@ -3260,17 +3299,17 @@ picomatch$2.toRegex = (source, options) => {
  * @return {Object}
  */
 
-picomatch$2.constants = constants;
+picomatch$1.constants = constants;
 
 /**
  * Expose "picomatch"
  */
 
-var picomatch_1 = picomatch$2;
+var picomatch_1 = picomatch$1;
 
 var picomatch = picomatch_1;
 
-var picomatch$1 = /*@__PURE__*/getDefaultExportFromCjs(picomatch);
+var pm = /*@__PURE__*/getDefaultExportFromCjs(picomatch);
 
 // Helper since Typescript can't detect readonly arrays with Array.isArray
 function isArray(arg) {
@@ -3310,7 +3349,7 @@ const createFilter$1 = function createFilter(include, exclude, options) {
             test: (what) => {
                 // this refactor is a tad overly verbose but makes for easy debugging
                 const pattern = getMatcherString(id, resolutionBase);
-                const fn = picomatch$1(pattern, { dot: true });
+                const fn = pm(pattern, { dot: true });
                 const result = fn(what);
                 return result;
             }
@@ -3342,363 +3381,320 @@ const builtins = 'arguments Infinity NaN undefined null true false eval uneval i
 const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
 forbiddenIdentifiers.add('');
 
-const isWindows = typeof process !== 'undefined' && process.platform === 'win32';
+const isWindows = typeof process !== "undefined" && process.platform === "win32";
 const windowsSlashRE = /\\/g;
 function slash(p) {
-    return p.replace(windowsSlashRE, '/');
+  return p.replace(windowsSlashRE, "/");
 }
 const postfixRE = /[?#].*$/;
 function cleanUrl(url) {
-    return url.replace(postfixRE, '');
+  return url.replace(postfixRE, "");
 }
 function withTrailingSlash(path) {
-    if (path[path.length - 1] !== '/') {
-        return `${path}/`;
-    }
-    return path;
+  if (path[path.length - 1] !== "/") {
+    return `${path}/`;
+  }
+  return path;
 }
 
 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');
-    }
-    catch { }
+  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");
+  } catch {
+  }
 }
 
 const createFilter = createFilter$1;
-// Some runtimes like Bun injects namespaced modules here, which is not a node builtin
-node_module.builtinModules.filter((id) => !id.includes(':'));
+node_module.builtinModules.filter((id) => !id.includes(":"));
 function isInNodeModules(id) {
-    return id.includes('node_modules');
+  return id.includes("node_modules");
 }
-// TODO: use import()
 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;
+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');
-// set in bin/vite.js
+const rollupVersion = resolveDependencyVersion("rollup");
 const filter = process.env.VITE_DEBUG_FILTER;
 const DEBUG = process.env.DEBUG;
 function createDebugger(namespace, options = {}) {
-    const log = debug$2(namespace);
-    const { onlyWhenFocused } = options;
-    let enabled = log.enabled;
-    if (enabled && onlyWhenFocused) {
-        const ns = typeof onlyWhenFocused === 'string' ? onlyWhenFocused : namespace;
-        enabled = !!DEBUG?.includes(ns);
-    }
-    if (enabled) {
-        return (...args) => {
-            if (!filter || args.some((a) => a?.includes?.(filter))) {
-                log(...args);
-            }
-        };
-    }
+  const log = debug$2(namespace);
+  const { onlyWhenFocused } = options;
+  let enabled = log.enabled;
+  if (enabled && onlyWhenFocused) {
+    const ns = typeof onlyWhenFocused === "string" ? onlyWhenFocused : namespace;
+    enabled = !!DEBUG?.includes(ns);
+  }
+  if (enabled) {
+    return (...args) => {
+      if (!filter || args.some((a) => a?.includes?.(filter))) {
+        log(...args);
+      }
+    };
+  }
 }
 function testCaseInsensitiveFS() {
-    if (!CLIENT_ENTRY.endsWith('client.mjs')) {
-        throw new Error(`cannot test case insensitive FS, CLIENT_ENTRY const doesn't contain client.mjs`);
-    }
-    if (!fs$1.existsSync(CLIENT_ENTRY)) {
-        throw new Error('cannot test case insensitive FS, CLIENT_ENTRY does not point to an existing file: ' +
-            CLIENT_ENTRY);
-    }
-    return fs$1.existsSync(CLIENT_ENTRY.replace('client.mjs', 'cLiEnT.mjs'));
+  if (!CLIENT_ENTRY.endsWith("client.mjs")) {
+    throw new Error(
+      `cannot test case insensitive FS, CLIENT_ENTRY const doesn't contain client.mjs`
+    );
+  }
+  if (!fs$1.existsSync(CLIENT_ENTRY)) {
+    throw new Error(
+      "cannot test case insensitive FS, CLIENT_ENTRY does not point to an existing file: " + CLIENT_ENTRY
+    );
+  }
+  return fs$1.existsSync(CLIENT_ENTRY.replace("client.mjs", "cLiEnT.mjs"));
 }
 const isCaseInsensitiveFS = testCaseInsensitiveFS();
 const VOLUME_RE = /^[A-Z]:/i;
 function normalizePath(id) {
-    return path$3.posix.normalize(isWindows ? slash(id) : id);
+  return path$3.posix.normalize(isWindows ? slash(id) : id);
 }
 function fsPathFromId(id) {
-    const fsPath = normalizePath(id.startsWith(FS_PREFIX) ? id.slice(FS_PREFIX.length) : id);
-    return fsPath[0] === '/' || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
+  const fsPath = normalizePath(
+    id.startsWith(FS_PREFIX) ? id.slice(FS_PREFIX.length) : id
+  );
+  return fsPath[0] === "/" || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
 }
 function fsPathFromUrl(url) {
-    return fsPathFromId(cleanUrl(url));
+  return fsPathFromId(cleanUrl(url));
 }
-/**
- * Check if dir is a parent of file
- *
- * Warning: parameters are not validated, only works with normalized absolute paths
- *
- * @param dir - normalized absolute path
- * @param file - normalized absolute path
- * @returns true if dir is a parent of file
- */
 function isParentDirectory(dir, file) {
-    dir = withTrailingSlash(dir);
-    return (file.startsWith(dir) ||
-        (isCaseInsensitiveFS && file.toLowerCase().startsWith(dir.toLowerCase())));
+  dir = withTrailingSlash(dir);
+  return file.startsWith(dir) || isCaseInsensitiveFS && file.toLowerCase().startsWith(dir.toLowerCase());
 }
-/**
- * Check if 2 file name are identical
- *
- * Warning: parameters are not validated, only works with normalized absolute paths
- *
- * @param file1 - normalized absolute path
- * @param file2 - normalized absolute path
- * @returns true if both files url are identical
- */
 function isSameFileUri(file1, file2) {
-    return (file1 === file2 ||
-        (isCaseInsensitiveFS && file1.toLowerCase() === file2.toLowerCase()));
+  return file1 === file2 || isCaseInsensitiveFS && file1.toLowerCase() === file2.toLowerCase();
 }
 const trailingSeparatorRE = /[?&]$/;
 const timestampRE = /\bt=\d{13}&?\b/;
 function removeTimestampQuery(url) {
-    return url.replace(timestampRE, '').replace(trailingSeparatorRE, '');
+  return url.replace(timestampRE, "").replace(trailingSeparatorRE, "");
 }
 function isObject$1(value) {
-    return Object.prototype.toString.call(value) === '[object Object]';
+  return Object.prototype.toString.call(value) === "[object Object]";
 }
 function tryStatSync(file) {
-    try {
-        // The "throwIfNoEntry" is a performance optimization for cases where the file does not exist
-        return fs$1.statSync(file, { throwIfNoEntry: false });
-    }
-    catch {
-        // Ignore errors
-    }
+  try {
+    return fs$1.statSync(file, { throwIfNoEntry: false });
+  } catch {
+  }
 }
 function isFileReadable(filename) {
-    if (!tryStatSync(filename)) {
-        return false;
-    }
-    try {
-        // Check if current process has read permission to the file
-        fs$1.accessSync(filename, fs$1.constants.R_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
+  if (!tryStatSync(filename)) {
+    return false;
+  }
+  try {
+    fs$1.accessSync(filename, fs$1.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
 }
 function arraify(target) {
-    return Array.isArray(target) ? target : [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;
-    }
-    if (typeof plugins === 'function') {
-        return plugins();
-    }
-    return [];
+  if (Array.isArray(plugins)) {
+    return plugins;
+  }
+  if (typeof plugins === "function") {
+    return plugins();
+  }
+  return [];
 }
 function mergeConfigRecursively(defaults, overrides, rootPath) {
-    const merged = { ...defaults };
-    for (const key in overrides) {
-        const value = overrides[key];
-        if (value == null) {
-            continue;
-        }
-        const existing = merged[key];
-        if (existing == null) {
-            merged[key] = value;
-            continue;
-        }
-        // fields that require special handling
-        if (key === 'alias' && (rootPath === 'resolve' || rootPath === '')) {
-            merged[key] = mergeAlias(existing, value);
-            continue;
-        }
-        else if (key === 'assetsInclude' && rootPath === '') {
-            merged[key] = [].concat(existing, value);
-            continue;
-        }
-        else if (key === 'noExternal' && // TODO: environments
-            rootPath === 'ssr' &&
-            (existing === true || value === true)) {
-            merged[key] = true;
-            continue;
-        }
-        else if (key === 'plugins' && rootPath === 'worker') {
-            merged[key] = () => [
-                ...backwardCompatibleWorkerPlugins(existing),
-                ...backwardCompatibleWorkerPlugins(value),
-            ];
-            continue;
-        }
-        if (Array.isArray(existing) || Array.isArray(value)) {
-            merged[key] = [...arraify(existing), ...arraify(value)];
-            continue;
-        }
-        if (isObject$1(existing) && isObject$1(value)) {
-            merged[key] = mergeConfigRecursively(existing, value, rootPath ? `${rootPath}.${key}` : key);
-            continue;
-        }
-        merged[key] = value;
+  const merged = { ...defaults };
+  for (const key in overrides) {
+    const value = overrides[key];
+    if (value == null) {
+      continue;
     }
-    return merged;
+    const existing = merged[key];
+    if (existing == null) {
+      merged[key] = value;
+      continue;
+    }
+    if (key === "alias" && (rootPath === "resolve" || rootPath === "")) {
+      merged[key] = mergeAlias(existing, value);
+      continue;
+    } else if (key === "assetsInclude" && rootPath === "") {
+      merged[key] = [].concat(existing, value);
+      continue;
+    } else if (key === "noExternal" && (rootPath === "ssr" || rootPath === "resolve") && (existing === true || value === true)) {
+      merged[key] = true;
+      continue;
+    } else if (key === "plugins" && rootPath === "worker") {
+      merged[key] = () => [
+        ...backwardCompatibleWorkerPlugins(existing),
+        ...backwardCompatibleWorkerPlugins(value)
+      ];
+      continue;
+    } else if (key === "server" && rootPath === "server.hmr") {
+      merged[key] = value;
+      continue;
+    }
+    if (Array.isArray(existing) || Array.isArray(value)) {
+      merged[key] = [...arraify(existing), ...arraify(value)];
+      continue;
+    }
+    if (isObject$1(existing) && isObject$1(value)) {
+      merged[key] = mergeConfigRecursively(
+        existing,
+        value,
+        rootPath ? `${rootPath}.${key}` : key
+      );
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
 }
 function mergeConfig(defaults, overrides, isRoot = true) {
-    if (typeof defaults === 'function' || typeof overrides === 'function') {
-        throw new Error(`Cannot merge config in form of callback`);
-    }
-    return mergeConfigRecursively(defaults, overrides, isRoot ? '' : '.');
+  if (typeof defaults === "function" || typeof overrides === "function") {
+    throw new Error(`Cannot merge config in form of callback`);
+  }
+  return mergeConfigRecursively(defaults, overrides, isRoot ? "" : ".");
 }
 function mergeAlias(a, b) {
-    if (!a)
-        return b;
-    if (!b)
-        return a;
-    if (isObject$1(a) && isObject$1(b)) {
-        return { ...a, ...b };
-    }
-    // the order is flipped because the alias is resolved from top-down,
-    // where the later should have higher priority
-    return [...normalizeAlias(b), ...normalizeAlias(a)];
+  if (!a) return b;
+  if (!b) return a;
+  if (isObject$1(a) && isObject$1(b)) {
+    return { ...a, ...b };
+  }
+  return [...normalizeAlias(b), ...normalizeAlias(a)];
 }
 function normalizeAlias(o = []) {
-    return Array.isArray(o)
-        ? o.map(normalizeSingleAlias)
-        : Object.keys(o).map((find) => normalizeSingleAlias({
-            find,
-            replacement: o[find],
-        }));
+  return Array.isArray(o) ? o.map(normalizeSingleAlias) : Object.keys(o).map(
+    (find) => normalizeSingleAlias({
+      find,
+      replacement: o[find]
+    })
+  );
 }
-// https://github.com/vitejs/vite/issues/1363
-// work around https://github.com/rollup/plugins/issues/759
-function normalizeSingleAlias({ find, replacement, customResolver, }) {
-    if (typeof find === 'string' &&
-        find[find.length - 1] === '/' &&
-        replacement[replacement.length - 1] === '/') {
-        find = find.slice(0, find.length - 1);
-        replacement = replacement.slice(0, replacement.length - 1);
-    }
-    const alias = {
-        find,
-        replacement,
-    };
-    if (customResolver) {
-        alias.customResolver = customResolver;
-    }
-    return alias;
+function normalizeSingleAlias({
+  find,
+  replacement,
+  customResolver
+}) {
+  if (typeof find === "string" && find[find.length - 1] === "/" && replacement[replacement.length - 1] === "/") {
+    find = find.slice(0, find.length - 1);
+    replacement = replacement.slice(0, replacement.length - 1);
+  }
+  const alias = {
+    find,
+    replacement
+  };
+  if (customResolver) {
+    alias.customResolver = customResolver;
+  }
+  return alias;
 }
 
-// This file will be built for both ESM and CJS. Avoid relying on other modules as possible.
-// copy from constants.ts
-const CSS_LANGS_RE = 
-// eslint-disable-next-line regexp/no-unused-capturing-group
-/\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+const CSS_LANGS_RE = (
+  // eslint-disable-next-line regexp/no-unused-capturing-group
+  /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/
+);
 const isCSSRequest = (request) => CSS_LANGS_RE.test(request);
-// Use splitVendorChunkPlugin() to get the same manualChunks strategy as Vite 2.7
-// We don't recommend using this strategy as a general solution moving forward
-// splitVendorChunk is a simple index/vendor strategy that was used in Vite
-// until v2.8. It is exposed to let people continue to use it in case it was
-// working well for their setups.
-// The cache needs to be reset on buildStart for watch mode to work correctly
-// Don't use this manualChunks strategy for ssr, lib mode, and 'umd' or 'iife'
-/**
- * @deprecated use build.rollupOutput.manualChunks or framework specific configuration
- */
 class SplitVendorChunkCache {
-    cache;
-    constructor() {
-        this.cache = new Map();
-    }
-    reset() {
-        this.cache = new Map();
-    }
+  cache;
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  reset() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
 }
-/**
- * @deprecated use build.rollupOutput.manualChunks or framework specific configuration
- */
 function splitVendorChunk(options = {}) {
-    const cache = options.cache ?? new SplitVendorChunkCache();
-    return (id, { getModuleInfo }) => {
-        if (isInNodeModules(id) &&
-            !isCSSRequest(id) &&
-            staticImportedByEntry(id, getModuleInfo, cache.cache)) {
-            return 'vendor';
-        }
-    };
+  const cache = options.cache ?? new SplitVendorChunkCache();
+  return (id, { getModuleInfo }) => {
+    if (isInNodeModules(id) && !isCSSRequest(id) && staticImportedByEntry(id, getModuleInfo, cache.cache)) {
+      return "vendor";
+    }
+  };
 }
 function staticImportedByEntry(id, getModuleInfo, cache, importStack = []) {
-    if (cache.has(id)) {
-        return cache.get(id);
-    }
-    if (importStack.includes(id)) {
-        // circular deps!
-        cache.set(id, false);
-        return false;
-    }
-    const mod = getModuleInfo(id);
-    if (!mod) {
-        cache.set(id, false);
-        return false;
-    }
-    if (mod.isEntry) {
-        cache.set(id, true);
-        return true;
-    }
-    const someImporterIs = mod.importers.some((importer) => staticImportedByEntry(importer, getModuleInfo, cache, importStack.concat(id)));
-    cache.set(id, someImporterIs);
-    return someImporterIs;
+  if (cache.has(id)) {
+    return cache.get(id);
+  }
+  if (importStack.includes(id)) {
+    cache.set(id, false);
+    return false;
+  }
+  const mod = getModuleInfo(id);
+  if (!mod) {
+    cache.set(id, false);
+    return false;
+  }
+  if (mod.isEntry) {
+    cache.set(id, true);
+    return true;
+  }
+  const someImporterIs = mod.importers.some(
+    (importer) => staticImportedByEntry(
+      importer,
+      getModuleInfo,
+      cache,
+      importStack.concat(id)
+    )
+  );
+  cache.set(id, someImporterIs);
+  return someImporterIs;
 }
-/**
- * @deprecated use build.rollupOutput.manualChunks or framework specific configuration
- */
 function splitVendorChunkPlugin() {
-    const caches = [];
-    function createSplitVendorChunk(output, config) {
-        const cache = new SplitVendorChunkCache();
-        caches.push(cache);
-        const build = config.build ?? {};
-        const format = output?.format;
-        if (!build.ssr && !build.lib && format !== 'umd' && format !== 'iife') {
-            return splitVendorChunk({ cache });
-        }
+  const caches = [];
+  function createSplitVendorChunk(output, config) {
+    const cache = new SplitVendorChunkCache();
+    caches.push(cache);
+    const build = config.build ?? {};
+    const format = output?.format;
+    if (!build.ssr && !build.lib && format !== "umd" && format !== "iife") {
+      return splitVendorChunk({ cache });
     }
-    return {
-        name: 'vite:split-vendor-chunk',
-        config(config) {
-            let outputs = config?.build?.rollupOptions?.output;
-            if (outputs) {
-                outputs = arraify(outputs);
-                for (const output of outputs) {
-                    const viteManualChunks = createSplitVendorChunk(output, config);
-                    if (viteManualChunks) {
-                        if (output.manualChunks) {
-                            if (typeof output.manualChunks === 'function') {
-                                const userManualChunks = output.manualChunks;
-                                output.manualChunks = (id, api) => {
-                                    return userManualChunks(id, api) ?? viteManualChunks(id, api);
-                                };
-                            }
-                            else {
-                                // else, leave the object form of manualChunks untouched, as
-                                // we can't safely replicate rollup handling.
-                                // eslint-disable-next-line no-console
-                                console.warn("(!) the `splitVendorChunk` plugin doesn't have any effect when using the object form of `build.rollupOptions.output.manualChunks`. Consider using the function form instead.");
-                            }
-                        }
-                        else {
-                            output.manualChunks = viteManualChunks;
-                        }
-                    }
-                }
-            }
-            else {
-                return {
-                    build: {
-                        rollupOptions: {
-                            output: {
-                                manualChunks: createSplitVendorChunk({}, config),
-                            },
-                        },
-                    },
+  }
+  return {
+    name: "vite:split-vendor-chunk",
+    config(config) {
+      let outputs = config?.build?.rollupOptions?.output;
+      if (outputs) {
+        outputs = arraify(outputs);
+        for (const output of outputs) {
+          const viteManualChunks = createSplitVendorChunk(output, config);
+          if (viteManualChunks) {
+            if (output.manualChunks) {
+              if (typeof output.manualChunks === "function") {
+                const userManualChunks = output.manualChunks;
+                output.manualChunks = (id, api) => {
+                  return userManualChunks(id, api) ?? viteManualChunks(id, api);
                 };
+              } else {
+                console.warn(
+                  "(!) the `splitVendorChunk` plugin doesn't have any effect when using the object form of `build.rollupOptions.output.manualChunks`. Consider using the function form instead."
+                );
+              }
+            } else {
+              output.manualChunks = viteManualChunks;
             }
-        },
-        buildStart() {
-            caches.forEach((cache) => cache.reset());
-        },
-    };
+          }
+        }
+      } else {
+        return {
+          build: {
+            rollupOptions: {
+              output: {
+                manualChunks: createSplitVendorChunk({}, config)
+              }
+            }
+          }
+        };
+      }
+    },
+    buildStart() {
+      caches.forEach((cache) => cache.reset());
+    }
+  };
 }
 
 var convertSourceMap$1 = {};
@@ -4827,8 +4823,10 @@ class MagicString {
 	update(start, end, content, options) {
 		if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
 
-		while (start < 0) start += this.original.length;
-		while (end < 0) end += this.original.length;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
 
 		if (end > this.original.length) throw new Error('end is out of bounds');
 		if (start === end)
@@ -4924,8 +4922,10 @@ class MagicString {
 	}
 
 	remove(start, end) {
-		while (start < 0) start += this.original.length;
-		while (end < 0) end += this.original.length;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
 
 		if (start === end) return this;
 
@@ -4948,8 +4948,10 @@ class MagicString {
 	}
 
 	reset(start, end) {
-		while (start < 0) start += this.original.length;
-		while (end < 0) end += this.original.length;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
 
 		if (start === end) return this;
 
@@ -5011,8 +5013,10 @@ class MagicString {
 	}
 
 	slice(start = 0, end = this.original.length) {
-		while (start < 0) start += this.original.length;
-		while (end < 0) end += this.original.length;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
 
 		let result = '';
 
@@ -5318,309 +5322,263 @@ class MagicString {
 	}
 }
 
-const debug$1 = createDebugger('vite:sourcemap', {
-    onlyWhenFocused: true,
+const debug$1 = createDebugger("vite:sourcemap", {
+  onlyWhenFocused: true
 });
 function genSourceMapUrl(map) {
-    if (typeof map !== 'string') {
-        map = JSON.stringify(map);
-    }
-    return `data:application/json;base64,${Buffer.from(map).toString('base64')}`;
+  if (typeof map !== "string") {
+    map = JSON.stringify(map);
+  }
+  return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
 }
 function getCodeWithSourcemap(type, code, map) {
-    if (debug$1) {
-        code += `\n/*${JSON.stringify(map, null, 2).replace(/\*\//g, '*\\/')}*/\n`;
-    }
-    if (type === 'js') {
-        code += `\n//# sourceMappingURL=${genSourceMapUrl(map)}`;
-    }
-    else if (type === 'css') {
-        code += `\n/*# sourceMappingURL=${genSourceMapUrl(map)} */`;
-    }
-    return code;
+  if (debug$1) {
+    code += `
+/*${JSON.stringify(map, null, 2).replace(/\*\//g, "*\\/")}*/
+`;
+  }
+  if (type === "js") {
+    code += `
+//# sourceMappingURL=${genSourceMapUrl(map)}`;
+  } else if (type === "css") {
+    code += `
+/*# sourceMappingURL=${genSourceMapUrl(map)} */`;
+  }
+  return code;
 }
 
-const debug = createDebugger('vite:send', {
-    onlyWhenFocused: true,
+const debug = createDebugger("vite:send", {
+  onlyWhenFocused: true
 });
 const alias = {
-    js: 'text/javascript',
-    css: 'text/css',
-    html: 'text/html',
-    json: 'application/json',
+  js: "text/javascript",
+  css: "text/css",
+  html: "text/html",
+  json: "application/json"
 };
 function send(req, res, content, type, options) {
-    const { etag = getEtag(content, { weak: true }), cacheControl = 'no-cache', headers, map, } = options;
-    if (res.writableEnded) {
-        return;
-    }
-    if (req.headers['if-none-match'] === etag) {
-        res.statusCode = 304;
-        res.end();
-        return;
-    }
-    res.setHeader('Content-Type', alias[type] || type);
-    res.setHeader('Cache-Control', cacheControl);
-    res.setHeader('Etag', etag);
-    if (headers) {
-        for (const name in headers) {
-            res.setHeader(name, headers[name]);
-        }
+  const {
+    etag = getEtag(content, { weak: true }),
+    cacheControl = "no-cache",
+    headers,
+    map
+  } = options;
+  if (res.writableEnded) {
+    return;
+  }
+  if (req.headers["if-none-match"] === etag) {
+    res.statusCode = 304;
+    res.end();
+    return;
+  }
+  res.setHeader("Content-Type", alias[type] || type);
+  res.setHeader("Cache-Control", cacheControl);
+  res.setHeader("Etag", etag);
+  if (headers) {
+    for (const name in headers) {
+      res.setHeader(name, headers[name]);
     }
-    // inject source map reference
-    if (map && 'version' in map && map.mappings) {
-        if (type === 'js' || type === 'css') {
-            content = getCodeWithSourcemap(type, content.toString(), map);
-        }
+  }
+  if (map && "version" in map && map.mappings) {
+    if (type === "js" || type === "css") {
+      content = getCodeWithSourcemap(type, content.toString(), map);
     }
-    // inject fallback sourcemap for js for improved debugging
-    // https://github.com/vitejs/vite/pull/13514#issuecomment-1592431496
-    else if (type === 'js' && (!map || map.mappings !== '')) {
-        const code = content.toString();
-        // if the code has existing inline sourcemap, assume it's correct and skip
-        if (convertSourceMap.mapFileCommentRegex.test(code)) {
-            debug?.(`Skipped injecting fallback sourcemap for ${req.url}`);
-        }
-        else {
-            const urlWithoutTimestamp = removeTimestampQuery(req.url);
-            const ms = new MagicString(code);
-            content = getCodeWithSourcemap(type, code, ms.generateMap({
-                source: path$3.basename(urlWithoutTimestamp),
-                hires: 'boundary',
-                includeContent: true,
-            }));
-        }
+  } else if (type === "js" && (!map || map.mappings !== "")) {
+    const code = content.toString();
+    if (convertSourceMap.mapFileCommentRegex.test(code)) {
+      debug?.(`Skipped injecting fallback sourcemap for ${req.url}`);
+    } else {
+      const urlWithoutTimestamp = removeTimestampQuery(req.url);
+      const ms = new MagicString(code);
+      content = getCodeWithSourcemap(
+        type,
+        code,
+        ms.generateMap({
+          source: path$3.basename(urlWithoutTimestamp),
+          hires: "boundary",
+          includeContent: true
+        })
+      );
     }
-    res.statusCode = 200;
-    res.end(content);
-    return;
+  }
+  res.statusCode = 200;
+  res.end(content);
+  return;
 }
 
-/* eslint no-console: 0 */
 const LogLevels = {
-    silent: 0,
-    error: 1,
-    warn: 2,
-    info: 3,
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3
 };
 let lastType;
 let lastMsg;
 let sameCount = 0;
 function clearScreen() {
-    const repeatCount = process.stdout.rows - 2;
-    const blank = repeatCount > 0 ? '\n'.repeat(repeatCount) : '';
-    console.log(blank);
-    readline.cursorTo(process.stdout, 0, 0);
-    readline.clearScreenDown(process.stdout);
+  const repeatCount = process.stdout.rows - 2;
+  const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+  console.log(blank);
+  readline.cursorTo(process.stdout, 0, 0);
+  readline.clearScreenDown(process.stdout);
 }
-// Only initialize the timeFormatter when the timestamp option is used, and
-// reuse it across all loggers
 let timeFormatter;
 function getTimeFormatter() {
-    timeFormatter ??= new Intl.DateTimeFormat(undefined, {
-        hour: 'numeric',
-        minute: 'numeric',
-        second: 'numeric',
-    });
-    return timeFormatter;
+  timeFormatter ??= new Intl.DateTimeFormat(void 0, {
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  });
+  return timeFormatter;
 }
-function createLogger(level = 'info', options = {}) {
-    if (options.customLogger) {
-        return options.customLogger;
+function createLogger(level = "info", options = {}) {
+  if (options.customLogger) {
+    return options.customLogger;
+  }
+  const loggedErrors = /* @__PURE__ */ new WeakSet();
+  const { prefix = "[vite]", allowClearScreen = true } = options;
+  const thresh = LogLevels[level];
+  const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
+  const clear = canClearScreen ? clearScreen : () => {
+  };
+  function format(type, msg, options2 = {}) {
+    if (options2.timestamp) {
+      let tag = "";
+      if (type === "info") {
+        tag = colors.cyan(colors.bold(prefix));
+      } else if (type === "warn") {
+        tag = colors.yellow(colors.bold(prefix));
+      } else {
+        tag = colors.red(colors.bold(prefix));
+      }
+      const environment = options2.environment ? options2.environment + " " : "";
+      return `${colors.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${environment}${msg}`;
+    } else {
+      return msg;
     }
-    const loggedErrors = new WeakSet();
-    const { prefix = '[vite]', allowClearScreen = true } = options;
-    const thresh = LogLevels[level];
-    const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
-    const clear = canClearScreen ? clearScreen : () => { };
-    function format(type, msg, options = {}) {
-        if (options.timestamp) {
-            const color = type === 'info'
-                ? colors.cyan
-                : type === 'warn'
-                    ? colors.yellow
-                    : colors.red;
-            const tag = color(colors.bold(prefix));
-            const environment = options.environment ? options.environment + ' ' : '';
-            return `${colors.dim(getTimeFormatter().format(new Date()))} ${tag} ${environment}${msg}`;
-        }
-        else {
-            return msg;
+  }
+  function output(type, msg, options2 = {}) {
+    if (thresh >= LogLevels[type]) {
+      const method = type === "info" ? "log" : type;
+      if (options2.error) {
+        loggedErrors.add(options2.error);
+      }
+      if (canClearScreen) {
+        if (type === lastType && msg === lastMsg) {
+          sameCount++;
+          clear();
+          console[method](
+            format(type, msg, options2),
+            colors.yellow(`(x${sameCount + 1})`)
+          );
+        } else {
+          sameCount = 0;
+          lastMsg = msg;
+          lastType = type;
+          if (options2.clear) {
+            clear();
+          }
+          console[method](format(type, msg, options2));
         }
+      } else {
+        console[method](format(type, msg, options2));
+      }
     }
-    function output(type, msg, options = {}) {
-        if (thresh >= LogLevels[type]) {
-            const method = type === 'info' ? 'log' : type;
-            if (options.error) {
-                loggedErrors.add(options.error);
-            }
-            if (canClearScreen) {
-                if (type === lastType && msg === lastMsg) {
-                    sameCount++;
-                    clear();
-                    console[method](format(type, msg, options), colors.yellow(`(x${sameCount + 1})`));
-                }
-                else {
-                    sameCount = 0;
-                    lastMsg = msg;
-                    lastType = type;
-                    if (options.clear) {
-                        clear();
-                    }
-                    console[method](format(type, msg, options));
-                }
-            }
-            else {
-                console[method](format(type, msg, options));
-            }
-        }
+  }
+  const warnedMessages = /* @__PURE__ */ new Set();
+  const logger = {
+    hasWarned: false,
+    info(msg, opts) {
+      output("info", msg, opts);
+    },
+    warn(msg, opts) {
+      logger.hasWarned = true;
+      output("warn", msg, opts);
+    },
+    warnOnce(msg, opts) {
+      if (warnedMessages.has(msg)) return;
+      logger.hasWarned = true;
+      output("warn", msg, opts);
+      warnedMessages.add(msg);
+    },
+    error(msg, opts) {
+      logger.hasWarned = true;
+      output("error", msg, opts);
+    },
+    clearScreen(type) {
+      if (thresh >= LogLevels[type]) {
+        clear();
+      }
+    },
+    hasErrorLogged(error) {
+      return loggedErrors.has(error);
     }
-    const warnedMessages = new Set();
-    const logger = {
-        hasWarned: false,
-        info(msg, opts) {
-            output('info', msg, opts);
-        },
-        warn(msg, opts) {
-            logger.hasWarned = true;
-            output('warn', msg, opts);
-        },
-        warnOnce(msg, opts) {
-            if (warnedMessages.has(msg))
-                return;
-            logger.hasWarned = true;
-            output('warn', msg, opts);
-            warnedMessages.add(msg);
-        },
-        error(msg, opts) {
-            logger.hasWarned = true;
-            output('error', msg, opts);
-        },
-        clearScreen(type) {
-            if (thresh >= LogLevels[type]) {
-                clear();
-            }
-        },
-        hasErrorLogged(error) {
-            return loggedErrors.has(error);
-        },
-    };
-    return logger;
+  };
+  return logger;
 }
 
-// https://github.com/vitejs/vite/issues/2820#issuecomment-812495079
 const ROOT_FILES = [
-    // '.git',
-    // https://pnpm.io/workspaces/
-    'pnpm-workspace.yaml',
-    // https://rushjs.io/pages/advanced/config_files/
-    // 'rush.json',
-    // https://nx.dev/latest/react/getting-started/nx-setup
-    // 'workspace.json',
-    // 'nx.json',
-    // https://github.com/lerna/lerna#lernajson
-    'lerna.json',
+  // '.git',
+  // https://pnpm.io/workspaces/
+  "pnpm-workspace.yaml",
+  // https://rushjs.io/pages/advanced/config_files/
+  // 'rush.json',
+  // https://nx.dev/latest/react/getting-started/nx-setup
+  // 'workspace.json',
+  // 'nx.json',
+  // https://github.com/lerna/lerna#lernajson
+  "lerna.json"
 ];
-// npm: https://docs.npmjs.com/cli/v7/using-npm/workspaces#installing-workspaces
-// yarn: https://classic.yarnpkg.com/en/docs/workspaces/#toc-how-to-use-it
 function hasWorkspacePackageJSON(root) {
-    const path = path$3.join(root, 'package.json');
-    if (!isFileReadable(path)) {
-        return false;
-    }
-    try {
-        const content = JSON.parse(fs$1.readFileSync(path, 'utf-8')) || {};
-        return !!content.workspaces;
-    }
-    catch {
-        return false;
-    }
+  const path = path$3.join(root, "package.json");
+  if (!isFileReadable(path)) {
+    return false;
+  }
+  try {
+    const content = JSON.parse(fs$1.readFileSync(path, "utf-8")) || {};
+    return !!content.workspaces;
+  } catch {
+    return false;
+  }
 }
 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$3.join(root, file)));
 }
 function hasPackageJSON(root) {
-    const path = path$3.join(root, 'package.json');
-    return fs$1.existsSync(path);
+  const path = path$3.join(root, "package.json");
+  return fs$1.existsSync(path);
 }
-/**
- * Search up for the nearest `package.json`
- */
 function searchForPackageRoot(current, root = current) {
-    if (hasPackageJSON(current))
-        return current;
-    const dir = path$3.dirname(current);
-    // reach the fs root
-    if (!dir || dir === current)
-        return root;
-    return searchForPackageRoot(dir, root);
+  if (hasPackageJSON(current)) return current;
+  const dir = path$3.dirname(current);
+  if (!dir || dir === current) return root;
+  return searchForPackageRoot(dir, root);
 }
-/**
- * Search up for the nearest workspace root
- */
 function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
-    if (hasRootFile(current))
-        return current;
-    if (hasWorkspacePackageJSON(current))
-        return current;
-    const dir = path$3.dirname(current);
-    // reach the fs root
-    if (!dir || dir === current)
-        return root;
-    return searchForWorkspaceRoot(dir, root);
+  if (hasRootFile(current)) return current;
+  if (hasWorkspacePackageJSON(current)) return current;
+  const dir = path$3.dirname(current);
+  if (!dir || dir === current) return root;
+  return searchForWorkspaceRoot(dir, root);
 }
 
-const safeModulePathsCache = new WeakMap();
-function isSafeModulePath(config, filePath) {
-    let safeModulePaths = safeModulePathsCache.get(config);
-    if (!safeModulePaths) {
-        safeModulePaths = new Set();
-        safeModulePathsCache.set(config, safeModulePaths);
-    }
-    return safeModulePaths.has(filePath);
-}
-const fsDenyGlobCache = new WeakMap();
-function fsDenyGlob(config, filePath) {
-    let matcher = fsDenyGlobCache.get(config);
-    if (!matcher) {
-        (matcher = picomatch$1(
-        // matchBase: true does not work as it's documented
-        // https://github.com/micromatch/picomatch/issues/89
-        // convert patterns without `/` on our side for now
-        config.server.fs.deny.map((pattern) => pattern.includes('/') ? pattern : `**/${pattern}`), {
-            matchBase: false,
-            nocase: true,
-            dot: true,
-        })),
-            fsDenyGlobCache.set(config, matcher);
-    }
-    return matcher(filePath);
-}
-/**
- * Check if the url is allowed to be served, via the `server.fs` config.
- * @deprecate use isFileLoadingAllowed
- */
-function isFileServingAllowed(url, server) {
-    const { config } = server;
-    if (!config.server.fs.strict)
-        return true;
-    const filePath = fsPathFromUrl(url);
-    return isFileLoadingAllowed(config, filePath);
+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(config, filePath);
 }
 function isUriInFilePath(uri, filePath) {
-    return isSameFileUri(uri, filePath) || isParentDirectory(uri, filePath);
+  return isSameFileUri(uri, filePath) || isParentDirectory(uri, filePath);
 }
 function isFileLoadingAllowed(config, filePath) {
-    const { fs } = config.server;
-    if (!fs.strict)
-        return true;
-    if (fsDenyGlob(config, filePath))
-        return false;
-    if (isSafeModulePath(config, filePath))
-        return true;
-    if (fs.allow.some((uri) => isUriInFilePath(uri, filePath)))
-        return true;
-    return false;
+  const { fs } = config.server;
+  if (!fs.strict) return true;
+  if (config.fsDenyGlob(filePath)) 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: {}};
@@ -6156,68 +6114,72 @@ function expand (options) {
 var expand_1 = expand;
 
 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)));
+  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)));
 }
-function loadEnv(mode, envDir, prefixes = 'VITE_') {
-    if (mode === 'local') {
-        throw new Error(`"local" cannot be used as a mode name because it conflicts with ` +
-            `the .local postfix for .env files.`);
-    }
-    prefixes = arraify(prefixes);
-    const env = {};
-    const envFiles = getEnvFilesForMode(mode, envDir);
-    const parsed = Object.fromEntries(envFiles.flatMap((filePath) => {
-        if (!tryStatSync(filePath)?.isFile())
-            return [];
-        return Object.entries(parse_1(fs$1.readFileSync(filePath)));
-    }));
-    // test NODE_ENV override before expand as otherwise process.env.NODE_ENV would override this
-    if (parsed.NODE_ENV && process.env.VITE_USER_NODE_ENV === undefined) {
-        process.env.VITE_USER_NODE_ENV = parsed.NODE_ENV;
-    }
-    // support BROWSER and BROWSER_ARGS env variables
-    if (parsed.BROWSER && process.env.BROWSER === undefined) {
-        process.env.BROWSER = parsed.BROWSER;
-    }
-    if (parsed.BROWSER_ARGS && process.env.BROWSER_ARGS === undefined) {
-        process.env.BROWSER_ARGS = parsed.BROWSER_ARGS;
-    }
-    // let environment variables use each other. make a copy of `process.env` so that `dotenv-expand`
-    // doesn't re-assign the expanded values to the global `process.env`.
-    const processEnv = { ...process.env };
-    expand_1({ parsed, processEnv });
-    // only keys that start with prefix are exposed to client
-    for (const [key, value] of Object.entries(parsed)) {
-        if (prefixes.some((prefix) => key.startsWith(prefix))) {
-            env[key] = value;
-        }
+function loadEnv(mode, envDir, prefixes = "VITE_") {
+  if (mode === "local") {
+    throw new Error(
+      `"local" cannot be used as a mode name because it conflicts with the .local postfix for .env files.`
+    );
+  }
+  prefixes = arraify(prefixes);
+  const env = {};
+  const envFiles = getEnvFilesForMode(mode, envDir);
+  const parsed = Object.fromEntries(
+    envFiles.flatMap((filePath) => {
+      if (!tryStatSync(filePath)?.isFile()) return [];
+      return Object.entries(parse_1(fs$1.readFileSync(filePath)));
+    })
+  );
+  if (parsed.NODE_ENV && process.env.VITE_USER_NODE_ENV === void 0) {
+    process.env.VITE_USER_NODE_ENV = parsed.NODE_ENV;
+  }
+  if (parsed.BROWSER && process.env.BROWSER === void 0) {
+    process.env.BROWSER = parsed.BROWSER;
+  }
+  if (parsed.BROWSER_ARGS && process.env.BROWSER_ARGS === void 0) {
+    process.env.BROWSER_ARGS = parsed.BROWSER_ARGS;
+  }
+  const processEnv = { ...process.env };
+  expand_1({ parsed, processEnv });
+  for (const [key, value] of Object.entries(parsed)) {
+    if (prefixes.some((prefix) => key.startsWith(prefix))) {
+      env[key] = value;
     }
-    // check if there are actual env variables starting with VITE_*
-    // these are typically provided inline and should be prioritized
-    for (const key in process.env) {
-        if (prefixes.some((prefix) => key.startsWith(prefix))) {
-            env[key] = process.env[key];
-        }
+  }
+  for (const key in process.env) {
+    if (prefixes.some((prefix) => key.startsWith(prefix))) {
+      env[key] = process.env[key];
     }
-    return env;
+  }
+  return env;
 }
-function resolveEnvPrefix({ envPrefix = 'VITE_', }) {
-    envPrefix = arraify(envPrefix);
-    if (envPrefix.includes('')) {
-        throw new Error(`envPrefix option contains value '', which could lead unexpected exposure of sensitive information.`);
-    }
-    return envPrefix;
+function resolveEnvPrefix({
+  envPrefix = "VITE_"
+}) {
+  envPrefix = arraify(envPrefix);
+  if (envPrefix.includes("")) {
+    throw new Error(
+      `envPrefix option contains value '', which could lead unexpected exposure of sensitive information.`
+    );
+  }
+  return envPrefix;
 }
 
 exports.esbuildVersion = esbuild.version;
 exports.createFilter = createFilter;
 exports.createLogger = createLogger;
 exports.isCSSRequest = isCSSRequest;
+exports.isFileLoadingAllowed = isFileLoadingAllowed;
 exports.isFileServingAllowed = isFileServingAllowed;
 exports.loadEnv = loadEnv;
 exports.mergeAlias = mergeAlias;