vite 5.0.0-beta.4 → 5.0.0-beta.6

package/dist/node/chunks/{dep-69dc786c.js → dep-db07a1ea.js}

@@ -23,7 +23,7 @@ import os$4 from 'node:os';
 import { exec } from 'node:child_process';
 import { createHash as createHash$2 } from 'node:crypto';
 import { promises } from 'node:dns';
-import { CLIENT_ENTRY, OPTIMIZABLE_ENTRY_RE, wildcardHosts, loopbackHosts, VALID_ID_PREFIX, NULL_BYTE_PLACEHOLDER, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, ENV_ENTRY, DEP_VERSION_RE, DEFAULT_MAIN_FIELDS, DEFAULT_EXTENSIONS as DEFAULT_EXTENSIONS$1, SPECIAL_QUERY_RE, CSS_LANGS_RE, ESBUILD_MODULES_TARGET, KNOWN_ASSET_TYPES, CLIENT_DIR, JS_TYPES_RE, VERSION as VERSION$1, VITE_PACKAGE_DIR, DEFAULT_DEV_PORT, DEFAULT_PREVIEW_PORT, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
+import { CLIENT_ENTRY, OPTIMIZABLE_ENTRY_RE, wildcardHosts, loopbackHosts, VALID_ID_PREFIX, NULL_BYTE_PLACEHOLDER, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, ENV_ENTRY, DEP_VERSION_RE, DEFAULT_MAIN_FIELDS, DEFAULT_EXTENSIONS, SPECIAL_QUERY_RE, CSS_LANGS_RE, ESBUILD_MODULES_TARGET, KNOWN_ASSET_TYPES, CLIENT_DIR, JS_TYPES_RE, VERSION as VERSION$1, VITE_PACKAGE_DIR, DEFAULT_DEV_PORT, DEFAULT_PREVIEW_PORT, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
 import require$$3$1 from 'crypto';
 import { Buffer as Buffer$1 } from 'node:buffer';
 import require$$0$8, { createRequire as createRequire$2 } from 'module';
@@ -7460,9 +7460,9 @@ function isReference(node, parent) {
     return false;
 }
 
-var version$3 = "25.0.4";
+var version$3 = "25.0.5";
 var peerDependencies = {
-	rollup: "^2.68.0||^3.0.0"
+	rollup: "^2.68.0||^3.0.0||^4.0.0"
 };
 
 function tryParse(parse, code, id) {
@@ -7485,6 +7485,7 @@ function hasCjsKeywords(code, ignoreGlobal) {
 
 /* eslint-disable no-underscore-dangle */
 
+
 function analyzeTopLevelStatements(parse, code, id) {
   const ast = tryParse(parse, code, id);
 
@@ -7531,6 +7532,7 @@ function analyzeTopLevelStatements(parse, code, id) {
 
 /* eslint-disable import/prefer-default-export */
 
+
 function deconflict(scopes, globals, identifier) {
   let i = 1;
   let deconflicted = makeLegalIdentifier(identifier);
@@ -7919,6 +7921,7 @@ function getEsImportProxy(id, defaultIsModuleExports) {
 
 /* eslint-disable no-param-reassign, no-undefined */
 
+
 function getCandidatesForExtension(resolved, extension) {
   return [resolved + extension, `${resolved}${sep}index${extension}`];
 }
@@ -8229,6 +8232,7 @@ function getRequireResolver(extensions, detectCyclesAndConditional, currentlyRes
             currentlyResolvingForParent.add(source);
             const resolved =
               (await rollupContext.resolve(source, parentId, {
+                skipSelf: false,
                 custom: { 'node-resolve': { isRequire: true } }
               })) || resolveExtensions(source, parentId, extensions);
             currentlyResolvingForParent.delete(source);
@@ -8897,6 +8901,7 @@ function getGenerateRequireName() {
 
 /* eslint-disable no-param-reassign, no-shadow, no-underscore-dangle, no-continue */
 
+
 const exportsPattern = /^(?:module\.)?exports(?:\.([a-zA-Z_$][a-zA-Z_$0-9]*))?$/;
 
 const functionType = /^(?:FunctionDeclaration|FunctionExpression|ArrowFunctionExpression)$/;
@@ -9167,6 +9172,9 @@ async function transformCommonjs(
               }
               if (!ignoreDynamicRequires) {
                 if (isShorthandProperty(parent)) {
+                  // as key and value are the same object, isReference regards
+                  // both as references, so we need to skip now
+                  skippedNodes.add(parent.value);
                   magicString.prependRight(node.start, 'require: ');
                 }
                 replacedDynamicRequires.push(node);
@@ -9709,7 +9717,7 @@ function commonjs(options = {}) {
       try {
         return transformAndCheckExports.call(this, code, id);
       } catch (err) {
-        return this.error(err, err.loc);
+        return this.error(err, err.pos);
       }
     }
   };
@@ -11868,11 +11876,22 @@ const replaceSlashOrColonRE = /[/:]/g;
 const replaceDotRE = /\./g;
 const replaceNestedIdRE = /(\s*>\s*)/g;
 const replaceHashRE = /#/g;
-const flattenId = (id) => id
-    .replace(replaceSlashOrColonRE, '_')
-    .replace(replaceDotRE, '__')
-    .replace(replaceNestedIdRE, '___')
-    .replace(replaceHashRE, '____');
+const flattenId = (id) => {
+    const flatId = limitFlattenIdLength(id
+        .replace(replaceSlashOrColonRE, '_')
+        .replace(replaceDotRE, '__')
+        .replace(replaceNestedIdRE, '___')
+        .replace(replaceHashRE, '____'));
+    return flatId;
+};
+const FLATTEN_ID_HASH_LENGTH = 8;
+const FLATTEN_ID_MAX_FILE_LENGTH = 170;
+const limitFlattenIdLength = (id, limit = FLATTEN_ID_MAX_FILE_LENGTH) => {
+    if (id.length <= limit) {
+        return id;
+    }
+    return id.slice(0, limit - (FLATTEN_ID_HASH_LENGTH + 1)) + '_' + getHash(id);
+};
 const normalizeId = (id) => id.replace(replaceNestedIdRE, ' > ');
 // Supported by Node, Deno, Bun
 const NODE_BUILTIN_NAMESPACE = 'node:';
@@ -12565,20 +12584,12 @@ function arraify(target) {
 const multilineCommentsRE$1 = /\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\//g;
 const singlelineCommentsRE$1 = /\/\/.*/g;
 const requestQuerySplitRE = /\?(?!.*[/|}])/;
-// @ts-expect-error jest only exists when running Jest
-const usingDynamicImport = typeof jest === 'undefined';
 /**
  * Dynamically import files. It will make sure it's not being compiled away by TS/Rollup.
  *
- * As a temporary workaround for Jest's lack of stable ESM support, we fallback to require
- * if we're in a Jest environment.
- * See https://github.com/vitejs/vite/pull/5197#issuecomment-938054077
- *
  * @param file File path to import.
  */
-const dynamicImport = usingDynamicImport
-    ? new Function('file', 'return import(file)')
-    : _require$2;
+const dynamicImport = new Function('file', 'return import(file)');
 function parseRequest(id) {
     const [_, search] = id.split(requestQuerySplitRE, 2);
     if (!search) {
@@ -13215,11 +13226,13 @@ const NATIVE_SEP_RE = new RegExp('\\' + path$o.sep, 'g');
 /** @type {Map<string,RegExp>}*/
 const PATTERN_REGEX_CACHE = new Map();
 const GLOB_ALL_PATTERN = `**/*`;
-const DEFAULT_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts'];
-const DEFAULT_EXTENSIONS_RE_GROUP = `\\.(?:${DEFAULT_EXTENSIONS.map((ext) => ext.substring(1)).join(
+const TS_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts'];
+const JS_EXTENSIONS = ['.js', '.jsx', '.mjs', '.cjs'];
+const TSJS_EXTENSIONS = TS_EXTENSIONS.concat(JS_EXTENSIONS);
+const TS_EXTENSIONS_RE_GROUP = `\\.(?:${TS_EXTENSIONS.map((ext) => ext.substring(1)).join('|')})`;
+const TSJS_EXTENSIONS_RE_GROUP = `\\.(?:${TSJS_EXTENSIONS.map((ext) => ext.substring(1)).join(
 	'|'
 )})`;
-
 const IS_POSIX = path$o.posix.sep === path$o.sep;
 
 /**
@@ -13245,10 +13258,8 @@ async function resolveTSConfigJson(filename, cache) {
 		return; // ignore files that are not json
 	}
 	const tsconfig = path$o.resolve(filename);
-	if (cache) {
-		if (cache.hasParseResult(tsconfig) || cache.hasParseResult(filename)) {
-			return tsconfig;
-		}
+	if (cache && (cache.hasParseResult(tsconfig) || cache.hasParseResult(filename))) {
+		return tsconfig;
 	}
 	return promises$1.stat(tsconfig).then((stat) => {
 		if (stat.isFile() || stat.isFIFO()) {
@@ -13317,12 +13328,15 @@ const resolve2posix = IS_POSIX
 /**
  *
  * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @param {import('./public.d.ts').TSConfckParseOptions} [options]
  * @returns {string[]}
  */
-function resolveReferencedTSConfigFiles(result) {
+function resolveReferencedTSConfigFiles(result, options) {
 	const dir = path$o.dirname(result.tsconfigFile);
 	return result.tsconfig.references.map((ref) => {
-		const refPath = ref.path.endsWith('.json') ? ref.path : path$o.join(ref.path, 'tsconfig.json');
+		const refPath = ref.path.endsWith('.json')
+			? ref.path
+			: path$o.join(ref.path, options?.configName ?? 'tsconfig.json');
 		return resolve2posix(dir, refPath);
 	});
 }
@@ -13333,9 +13347,11 @@ function resolveReferencedTSConfigFiles(result) {
  * @returns {import('./public.d.ts').TSConfckParseResult}
  */
 function resolveSolutionTSConfig(filename, result) {
+	const allowJs = result.tsconfig.compilerOptions?.allowJs;
+	const extensions = allowJs ? TSJS_EXTENSIONS : TS_EXTENSIONS;
 	if (
 		result.referenced &&
-		DEFAULT_EXTENSIONS.some((ext) => filename.endsWith(ext)) &&
+		extensions.some((ext) => filename.endsWith(ext)) &&
 		!isIncluded(filename, result)
 	) {
 		const solutionTSConfig = result.referenced.find((referenced) =>
@@ -13361,13 +13377,15 @@ function isIncluded(filename, result) {
 	if (files.includes(filename)) {
 		return true;
 	}
+	const allowJs = result.tsconfig.compilerOptions?.allowJs;
 	const isIncluded = isGlobMatch(
 		absoluteFilename,
 		dir,
-		result.tsconfig.include || (result.tsconfig.files ? [] : [GLOB_ALL_PATTERN])
+		result.tsconfig.include || (result.tsconfig.files ? [] : [GLOB_ALL_PATTERN]),
+		allowJs
 	);
 	if (isIncluded) {
-		const isExcluded = isGlobMatch(absoluteFilename, dir, result.tsconfig.exclude || []);
+		const isExcluded = isGlobMatch(absoluteFilename, dir, result.tsconfig.exclude || [], allowJs);
 		return !isExcluded;
 	}
 	return false;
@@ -13379,9 +13397,11 @@ function isIncluded(filename, result) {
  * @param filename {string} posix style abolute path to filename to test
  * @param dir {string} posix style absolute path to directory of tsconfig containing patterns
  * @param patterns {string[]} glob patterns to match against
+ * @param allowJs {boolean} allowJs setting in tsconfig to include js extensions in checks
  * @returns {boolean} true when at least one pattern matches filename
  */
-function isGlobMatch(filename, dir, patterns) {
+function isGlobMatch(filename, dir, patterns, allowJs) {
+	const extensions = allowJs ? TSJS_EXTENSIONS : TS_EXTENSIONS;
 	return patterns.some((pattern) => {
 		// filename must end with part of pattern that comes after last wildcard
 		let lastWildcardIndex = pattern.length;
@@ -13403,7 +13423,7 @@ function isGlobMatch(filename, dir, patterns) {
 		}
 
 		// if pattern ends with *, filename must end with a default extension
-		if (pattern.endsWith('*') && !DEFAULT_EXTENSIONS.some((ext) => filename.endsWith(ext))) {
+		if (pattern.endsWith('*') && !extensions.some((ext) => filename.endsWith(ext))) {
 			return false;
 		}
 
@@ -13439,7 +13459,7 @@ function isGlobMatch(filename, dir, patterns) {
 		if (PATTERN_REGEX_CACHE.has(resolvedPattern)) {
 			return PATTERN_REGEX_CACHE.get(resolvedPattern).test(filename);
 		}
-		const regex = pattern2regex(resolvedPattern);
+		const regex = pattern2regex(resolvedPattern, allowJs);
 		PATTERN_REGEX_CACHE.set(resolvedPattern, regex);
 		return regex.test(filename);
 	});
@@ -13447,9 +13467,10 @@ function isGlobMatch(filename, dir, patterns) {
 
 /**
  * @param {string} resolvedPattern
+ * @param {boolean} allowJs
  * @returns {RegExp}
  */
-function pattern2regex(resolvedPattern) {
+function pattern2regex(resolvedPattern, allowJs) {
 	let regexStr = '^';
 	for (let i = 0; i < resolvedPattern.length; i++) {
 		const char = resolvedPattern[i];
@@ -13474,7 +13495,7 @@ function pattern2regex(resolvedPattern) {
 
 	// add known file endings if pattern ends on *
 	if (resolvedPattern.endsWith('*')) {
-		regexStr += DEFAULT_EXTENSIONS_RE_GROUP;
+		regexStr += allowJs ? TSJS_EXTENSIONS_RE_GROUP : TS_EXTENSIONS_RE_GROUP;
 	}
 	regexStr += '$';
 
@@ -13494,12 +13515,15 @@ async function find(filename, options) {
 		return null;
 	}
 	const cache = options?.cache;
-	if (cache?.hasTSConfigPath(dir)) {
-		return cache.getTSConfigPath(dir);
+	const configName = options?.configName ?? 'tsconfig.json';
+	if (cache?.hasConfigPath(dir, configName)) {
+		return cache.getConfigPath(dir, configName);
 	}
 	const { /** @type {Promise<string|null>} */ promise, resolve, reject } = makePromise();
-	const root = options?.root ? path$o.resolve(options.root) : null;
-	findUp(dir, { promise, resolve, reject }, options?.cache, root);
+	if (options?.root && !path$o.isAbsolute(options.root)) {
+		options.root = path$o.resolve(options.root);
+	}
+	findUp(dir, { promise, resolve, reject }, options);
 	return promise;
 }
 
@@ -13507,16 +13531,15 @@ async function find(filename, options) {
  *
  * @param {string} dir
  * @param {{promise:Promise<string|null>,resolve:(result:string|null)=>void,reject:(err:any)=>void}} madePromise
- * @param {import('./cache.js').TSConfckCache}  [cache]
- * @param {string} [root]
+ * @param {import('./public.d.ts').TSConfckFindOptions} [options] - options
  */
-function findUp(dir, { resolve, reject, promise }, cache, root) {
-	const tsconfig = path$o.join(dir, 'tsconfig.json');
+function findUp(dir, { resolve, reject, promise }, options) {
+	const { cache, root, configName } = options ?? {};
 	if (cache) {
-		if (cache.hasTSConfigPath(dir)) {
+		if (cache.hasConfigPath(dir, configName)) {
 			let cached;
 			try {
-				cached = cache.getTSConfigPath(dir);
+				cached = cache.getConfigPath(dir, configName);
 			} catch (e) {
 				reject(e);
 				return;
@@ -13527,9 +13550,10 @@ function findUp(dir, { resolve, reject, promise }, cache, root) {
 				resolve(cached);
 			}
 		} else {
-			cache.setTSConfigPath(dir, promise);
+			cache.setConfigPath(dir, promise, configName);
 		}
 	}
+	const tsconfig = path$o.join(dir, options?.configName ?? 'tsconfig.json');
 	fs$l.stat(tsconfig, (err, stats) => {
 		if (stats && (stats.isFile() || stats.isFIFO())) {
 			resolve(tsconfig);
@@ -13540,7 +13564,7 @@ function findUp(dir, { resolve, reject, promise }, cache, root) {
 			if (root === dir || (parent = path$o.dirname(dir)) === dir) {
 				resolve(null);
 			} else {
-				findUp(parent, { promise, resolve, reject }, cache, root);
+				findUp(parent, { promise, resolve, reject }, options);
 			}
 		}
 	});
@@ -13752,7 +13776,7 @@ async function parse$f(filename, options) {
 			result = await cache.getParseResult(tsconfigFile);
 		} else {
 			result = await parseFile$1(tsconfigFile, cache, filename === tsconfigFile);
-			await Promise.all([parseExtends(result, cache), parseReferences(result, cache)]);
+			await Promise.all([parseExtends(result, cache), parseReferences(result, options)]);
 		}
 		resolve(resolveSolutionTSConfig(filename, result));
 		return promise;
@@ -13777,9 +13801,11 @@ async function parseFile$1(tsconfigFile, cache, skipCache) {
 		.readFile(tsconfigFile, 'utf-8')
 		.then(toJson)
 		.then((json) => {
+			const parsed = JSON.parse(json);
+			applyDefaults(parsed, tsconfigFile);
 			return {
 				tsconfigFile,
-				tsconfig: normalizeTSConfig(JSON.parse(json), path$o.dirname(tsconfigFile))
+				tsconfig: normalizeTSConfig(parsed, path$o.dirname(tsconfigFile))
 			};
 		})
 		.catch((e) => {
@@ -13813,16 +13839,18 @@ function normalizeTSConfig(tsconfig, dir) {
 /**
  *
  * @param {import('./public.d.ts').TSConfckParseResult} result
- * @param {import('./cache.js').TSConfckCache} [cache]
+ * @param {import('./public.d.ts').TSConfckParseOptions} [options]
  * @returns {Promise<void>}
  */
-async function parseReferences(result, cache) {
+async function parseReferences(result, options) {
 	if (!result.tsconfig.references) {
 		return;
 	}
-	const referencedFiles = resolveReferencedTSConfigFiles(result);
-	const referenced = await Promise.all(referencedFiles.map((file) => parseFile$1(file, cache)));
-	await Promise.all(referenced.map((ref) => parseExtends(ref, cache)));
+	const referencedFiles = resolveReferencedTSConfigFiles(result, options);
+	const referenced = await Promise.all(
+		referencedFiles.map((file) => parseFile$1(file, options?.cache))
+	);
+	await Promise.all(referenced.map((ref) => parseExtends(ref, options?.cache)));
 	referenced.forEach((ref) => {
 		ref.solution = result;
 	});
@@ -14074,34 +14102,66 @@ class TSConfckParseError extends Error {
 	}
 }
 
+/**
+ *
+ * @param {any} tsconfig
+ * @param {string} tsconfigFile
+ */
+function applyDefaults(tsconfig, tsconfigFile) {
+	if (isJSConfig(tsconfigFile)) {
+		tsconfig.compilerOptions = {
+			...DEFAULT_JSCONFIG_COMPILER_OPTIONS,
+			...tsconfig.compilerOptions
+		};
+	}
+}
+
+const DEFAULT_JSCONFIG_COMPILER_OPTIONS = {
+	allowJs: true,
+	maxNodeModuleJsDepth: 2,
+	allowSyntheticDefaultImports: true,
+	skipLibCheck: true,
+	noEmit: true
+};
+
+/**
+ * @param {string} configFileName
+ */
+function isJSConfig(configFileName) {
+	return path$o.basename(configFileName) === 'jsconfig.json';
+}
+
 /** @template T */
 class TSConfckCache {
 	/**
 	 * clear cache, use this if you have a long running process and tsconfig files have been added,changed or deleted
 	 */
 	clear() {
-		this.#tsconfigPaths.clear();
+		this.#configPaths.clear();
 		this.#parsed.clear();
 	}
 
 	/**
-	 * has cached closest tsconfig for files in dir
+	 * has cached closest config for files in dir
 	 * @param {string} dir
+	 * @param {string} [configName=tsconfig.json]
 	 * @returns {boolean}
 	 */
-	hasTSConfigPath(dir) {
-		return this.#tsconfigPaths.has(dir);
+	hasConfigPath(dir, configName = 'tsconfig.json') {
+		return this.#configPaths.has(`${dir}/${configName}`);
 	}
 
 	/**
 	 * get cached closest tsconfig for files in dir
 	 * @param {string} dir
+	 * @param {string} [configName=tsconfig.json]
 	 * @returns {Promise<string|null>|string|null}
 	 * @throws {unknown} if cached value is an error
 	 */
-	getTSConfigPath(dir) {
-		const value = this.#tsconfigPaths.get(dir);
-		if (value === null || value.length || value.then) {
+	getConfigPath(dir, configName = 'tsconfig.json') {
+		const key = `${dir}/${configName}`;
+		const value = this.#configPaths.get(key);
+		if (value == null || value.length || value.then) {
 			return value;
 		} else {
 			throw value;
@@ -14157,19 +14217,21 @@ class TSConfckCache {
 	 * @internal
 	 * @private
 	 * @param {string} dir
-	 * @param {Promise<string|null>} tsconfigPath
+	 * @param {Promise<string|null>} configPath
+	 * @param {string} [configName=tsconfig.json]
 	 */
-	setTSConfigPath(dir, tsconfigPath) {
-		this.#tsconfigPaths.set(dir, tsconfigPath);
-		tsconfigPath
+	setConfigPath(dir, configPath, configName = 'tsconfig.json') {
+		const key = `${dir}/${configName}`;
+		this.#configPaths.set(key, configPath);
+		configPath
 			.then((path) => {
-				if (this.#tsconfigPaths.get(dir) === tsconfigPath) {
-					this.#tsconfigPaths.set(dir, path);
+				if (this.#configPaths.get(key) === configPath) {
+					this.#configPaths.set(key, path);
 				}
 			})
 			.catch((e) => {
-				if (this.#tsconfigPaths.get(dir) === tsconfigPath) {
-					this.#tsconfigPaths.set(dir, e);
+				if (this.#configPaths.get(key) === configPath) {
+					this.#configPaths.set(key, e);
 				}
 			});
 	}
@@ -14180,7 +14242,7 @@ class TSConfckCache {
 	 * @private
 	 * @type{Map<string,(Promise<string|null>|string|null)>}
 	 */
-	#tsconfigPaths = new Map();
+	#configPaths = new Map();
 
 	/**
 	 * map files to their parsed tsconfig result
@@ -14192,8 +14254,9 @@ class TSConfckCache {
 }
 
 const debug$g = createDebugger('vite:esbuild');
-// IIFE content looks like `var MyLib = function() {`. Spaces are removed when minified
-const IIFE_BEGIN_RE = /(const|var)\s+\S+\s*=\s*function\(\)\s*\{.*"use strict";/s;
+// IIFE content looks like `var MyLib = function() {`.
+// Spaces are removed and parameters are mangled when minified
+const IIFE_BEGIN_RE = /(const|var)\s+\S+\s*=\s*function\([^()]*\)\s*\{\s*"use strict";/;
 const validExtensionRE = /\.\w+$/;
 const jsxExtensionsRE = /\.(?:j|t)sx\b/;
 let server;
@@ -15579,16 +15642,35 @@ class Mappings {
 
 	addEdit(sourceIndex, content, loc, nameIndex) {
 		if (content.length) {
+			let contentLineEnd = content.indexOf('\n', 0);
+			let previousContentLineEnd = -1;
+			while (contentLineEnd >= 0) {
+				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+				if (nameIndex >= 0) {
+					segment.push(nameIndex);
+				}
+				this.rawSegments.push(segment);
+
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+
+				previousContentLineEnd = contentLineEnd;
+				contentLineEnd = content.indexOf('\n', contentLineEnd + 1);
+			}
+
 			const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
 			if (nameIndex >= 0) {
 				segment.push(nameIndex);
 			}
 			this.rawSegments.push(segment);
+
+			this.advance(content.slice(previousContentLineEnd + 1));
 		} else if (this.pending) {
 			this.rawSegments.push(this.pending);
+			this.advance(content);
 		}
 
-		this.advance(content);
 		this.pending = null;
 	}
 
@@ -27857,7 +27939,7 @@ function stringifyQuery(query) {
 }
 
 new Set(builtinModules);
-function matchAll(regex, string, addition) {
+function matchAll$1(regex, string, addition) {
   const matches = [];
   for (const match of string.matchAll(regex)) {
     matches.push({
@@ -28396,7 +28478,7 @@ pathToFileURL(process.cwd());
 const ESM_STATIC_IMPORT_RE = /(?<=\s|^|;)import\s*([\s"']*(?<imports>[\p{L}\p{M}\w\t\n\r $*,/{}@.]+)from\s*)?["']\s*(?<specifier>(?<="\s*)[^"]*[^\s"](?=\s*")|(?<='\s*)[^']*[^\s'](?=\s*'))\s*["'][\s;]*/gmu;
 const TYPE_RE = /^\s*?type\s/;
 function findStaticImports(code) {
-  return matchAll(ESM_STATIC_IMPORT_RE, code, { type: "static" });
+  return matchAll$1(ESM_STATIC_IMPORT_RE, code, { type: "static" });
 }
 function parseStaticImport(matched) {
   const cleanedImports = clearImports(matched.imports);
@@ -28461,10 +28543,15 @@ function resolvePlugin(resolveOptions) {
             const targetWeb = !ssr || ssrTarget === 'webworker';
             // this is passed by @rollup/plugin-commonjs
             const isRequire = resolveOpts?.custom?.['node-resolve']?.isRequire ?? false;
+            // end user can configure different conditions for ssr and client.
+            // falls back to client conditions if no ssr conditions supplied
+            const ssrConditions = resolveOptions.ssrConfig?.resolve?.conditions ||
+                resolveOptions.conditions;
             const options = {
                 isRequire,
                 ...resolveOptions,
                 scan: resolveOpts?.scan ?? resolveOptions.scan,
+                conditions: ssr ? ssrConditions : resolveOptions.conditions,
             };
             const resolvedImports = resolveSubpathImports(id, importer, options, targetWeb);
             if (resolvedImports) {
@@ -28852,7 +28939,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = f
             ...options,
             isRequire: false,
             mainFields: DEFAULT_MAIN_FIELDS,
-            extensions: DEFAULT_EXTENSIONS$1,
+            extensions: DEFAULT_EXTENSIONS,
         });
     }
     if (!resolved) {
@@ -37957,6 +38044,31 @@ function buildHtmlPlugin(config) {
                 const publicBase = getBaseInHTML(relativeUrlPath, config);
                 const publicToRelative = (filename, importer) => publicBase + filename;
                 const toOutputPublicFilePath = (url) => toOutputFilePathInHtml(url.slice(1), 'public', relativeUrlPath, 'html', config, publicToRelative);
+                // Determines true start position for the node, either the < character
+                // position, or the newline at the end of the previous line's node.
+                const nodeStartWithLeadingWhitespace = (node) => {
+                    if (node.sourceCodeLocation.startOffset === 0)
+                        return node.sourceCodeLocation.startOffset;
+                    // Gets the offset for the start of the line including the
+                    // newline trailing the previous node
+                    const lineStartOffset = node.sourceCodeLocation.startOffset -
+                        node.sourceCodeLocation.startCol;
+                    const line = s.slice(lineStartOffset, node.sourceCodeLocation.startOffset);
+                    // <previous-line-node></previous-line-node>
+                    // <target-node></target-node>
+                    //
+                    // Here we want to target the newline at the end of the previous line
+                    // as the start position for our target.
+                    //
+                    // <previous-node></previous-node>
+                    // <doubled-up-node></doubled-up-node><target-node></target-node>
+                    //
+                    // However, if there is content between our target node start and the
+                    // previous newline, we cannot strip it out without risking content deletion.
+                    return line.trim()
+                        ? node.sourceCodeLocation.startOffset
+                        : lineStartOffset;
+                };
                 // pre-transform
                 html = await applyHtmlTransforms(html, preHooks, {
                     path: publicPath,
@@ -38052,7 +38164,7 @@ function buildHtmlPlugin(config) {
                                         const importExpression = `\nimport ${JSON.stringify(url)}`;
                                         styleUrls.push({
                                             url,
-                                            start: node.sourceCodeLocation.startOffset,
+                                            start: nodeStartWithLeadingWhitespace(node),
                                             end: node.sourceCodeLocation.endOffset,
                                         });
                                         js += importExpression;
@@ -38107,7 +38219,7 @@ function buildHtmlPlugin(config) {
                     if (shouldRemove) {
                         // remove the script tag from the html. we are going to inject new
                         // ones in the end.
-                        s.remove(node.sourceCodeLocation.startOffset, node.sourceCodeLocation.endOffset);
+                        s.remove(nodeStartWithLeadingWhitespace(node), node.sourceCodeLocation.endOffset);
                     }
                 });
                 isAsyncScriptMap.get(config).set(id, everyScriptIsAsync);
@@ -39047,13 +39159,7 @@ function cssPostPlugin(config) {
                     .filter((chunk) => chunk.type === 'chunk')
                     .map((chunk) => [chunk.preliminaryFileName, chunk.fileName]));
                 const pureCssChunkNames = [...pureCssChunks].map((pureCssChunk) => prelimaryNameToChunkMap[pureCssChunk.fileName]);
-                const emptyChunkFiles = pureCssChunkNames
-                    .map((file) => path$o.basename(file))
-                    .join('|')
-                    .replace(/\./g, '\\.');
-                const emptyChunkRE = new RegExp(opts.format === 'es'
-                    ? `\\bimport\\s*["'][^"']*(?:${emptyChunkFiles})["'];\n?`
-                    : `\\brequire\\(\\s*["'][^"']*(?:${emptyChunkFiles})["']\\);\n?`, 'g');
+                const replaceEmptyChunk = getEmptyChunkReplacer(pureCssChunkNames, opts.format);
                 for (const file in bundle) {
                     const chunk = bundle[file];
                     if (chunk.type === 'chunk') {
@@ -39069,9 +39175,7 @@ function cssPostPlugin(config) {
                             }
                             return true;
                         });
-                        chunk.code = chunk.code.replace(emptyChunkRE, 
-                        // remove css import while preserving source map location
-                        (m) => `/* empty css ${''.padEnd(m.length - 15)}*/`);
+                        chunk.code = replaceEmptyChunk(chunk.code);
                     }
                 }
                 const removedPureCssFiles = removedPureCssFilesCache.get(config);
@@ -39112,6 +39216,23 @@ function cssPostPlugin(config) {
         },
     };
 }
+/**
+ * Create a replacer function that takes code and replaces given pure CSS chunk imports
+ * @param pureCssChunkNames The chunks that only contain pure CSS and should be replaced
+ * @param outputFormat The module output format to decide whether to replace `import` or `require`
+ */
+function getEmptyChunkReplacer(pureCssChunkNames, outputFormat) {
+    const emptyChunkFiles = pureCssChunkNames
+        .map((file) => path$o.basename(file))
+        .join('|')
+        .replace(/\./g, '\\.');
+    const emptyChunkRE = new RegExp(outputFormat === 'es'
+        ? `\\bimport\\s*["'][^"']*(?:${emptyChunkFiles})["'];\n?`
+        : `\\brequire\\(\\s*["'][^"']*(?:${emptyChunkFiles})["']\\);\n?`, 'g');
+    return (code) => code.replace(emptyChunkRE, 
+    // remove css import while preserving source map location
+    (m) => `/* empty css ${''.padEnd(m.length - 15)}*/`);
+}
 function createCSSResolvers(config) {
     let cssResolve;
     let sassResolve;
@@ -39407,8 +39528,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-a86a117b.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-ae1dfb84.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-ce41d4ea.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-c3c41c00.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 /**
  * @experimental
@@ -40745,11 +40866,13 @@ function createIsConfiguredAsSsrExternal(config) {
     const noExternalFilter = noExternal !== 'undefined' &&
         typeof noExternal !== 'boolean' &&
         createFilter(undefined, noExternal, { resolve: false });
+    const targetConditions = config.ssr.resolve?.externalConditions || [];
     const resolveOptions = {
         ...config.resolve,
         root,
         isProduction: false,
         isBuild: true,
+        conditions: targetConditions,
     };
     const isExternalizable = (id, importer, configuredAsExternal) => {
         if (!bareImportRE.test(id) || id.includes('\0')) {
@@ -42299,6 +42422,9 @@ function importAnalysisPlugin(config) {
                     importerModule.isSelfAccepting = false;
                     return this.error(`Failed to resolve import "${url}" from "${path$o.relative(process.cwd(), importerFile)}". Does the file exist?`, pos);
                 }
+                if (isExternalUrl(resolved.id)) {
+                    return [resolved.id, resolved.id];
+                }
                 const isRelative = url[0] === '.';
                 const isSelfImport = !isRelative && cleanUrl(url) === cleanUrl(importer);
                 // normalize all imports into resolved URLs
@@ -42316,9 +42442,6 @@ function importAnalysisPlugin(config) {
                 else {
                     url = resolved.id;
                 }
-                if (isExternalUrl(url)) {
-                    return [url, url];
-                }
                 // if the resolved id is not a valid browser import specifier,
                 // prefix it to make it valid. We will strip this before feeding it
                 // back into the transform pipeline
@@ -42516,7 +42639,10 @@ function importAnalysisPlugin(config) {
                                 return;
                             }
                             // Unexpected error, log the issue but avoid an unhandled exception
-                            config.logger.error(e.message, { error: e });
+                            config.logger.error(`Pre-transform error: ${e.message}`, {
+                                error: e,
+                                timestamp: true,
+                            });
                         });
                     }
                 }
@@ -45018,7 +45144,8 @@ async function computeEntries(config) {
     }
     // Non-supported entry file types and virtual files should not be scanned for
     // dependencies.
-    entries = entries.filter((entry) => isScannable(entry) && fs$l.existsSync(entry));
+    entries = entries.filter((entry) => isScannable(entry, config.optimizeDeps.extensions) &&
+        fs$l.existsSync(entry));
     return entries;
 }
 async function prepareEsbuildScanner(config, entries, deps, missing, scanContext) {
@@ -45148,12 +45275,11 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                     namespace: 'html',
                 };
             });
-            // extract scripts inside HTML-like files and treat it as a js module
-            build.onLoad({ filter: htmlTypesRE, namespace: 'html' }, async ({ path }) => {
-                let raw = await fsp.readFile(path, 'utf-8');
+            const htmlTypeOnLoadCallback = async ({ path: p }) => {
+                let raw = await fsp.readFile(p, 'utf-8');
                 // Avoid matching the content of the comment
                 raw = raw.replace(commentRE, '<!---->');
-                const isHtml = path.endsWith('.html');
+                const isHtml = p.endsWith('.html');
                 scriptRE.lastIndex = 0;
                 let js = '';
                 let scriptId = 0;
@@ -45179,7 +45305,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                     if (lang === 'ts' || lang === 'tsx' || lang === 'jsx') {
                         loader = lang;
                     }
-                    else if (path.endsWith('.astro')) {
+                    else if (p.endsWith('.astro')) {
                         loader = 'ts';
                     }
                     const srcMatch = openTag.match(srcRE);
@@ -45197,11 +45323,12 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                         // since they may be used in the template
                         const contents = content +
                             (loader.startsWith('ts') ? extractImportPaths(content) : '');
-                        const key = `${path}?id=${scriptId++}`;
+                        const key = `${p}?id=${scriptId++}`;
                         if (contents.includes('import.meta.glob')) {
                             scripts[key] = {
                                 loader: 'js',
-                                contents: await doTransformGlobImport(contents, path, loader),
+                                contents: await doTransformGlobImport(contents, p, loader),
+                                resolveDir: normalizePath$3(path$o.dirname(p)),
                                 pluginData: {
                                     htmlType: { loader },
                                 },
@@ -45211,6 +45338,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                             scripts[key] = {
                                 loader,
                                 contents,
+                                resolveDir: normalizePath$3(path$o.dirname(p)),
                                 pluginData: {
                                     htmlType: { loader },
                                 },
@@ -45223,7 +45351,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                         // Especially for Svelte files, exports in <script context="module"> means module exports,
                         // exports in <script> means component props. To avoid having two same export name from the
                         // star exports, we need to ignore exports in <script>
-                        if (path.endsWith('.svelte') && context !== 'module') {
+                        if (p.endsWith('.svelte') && context !== 'module') {
                             js += `import ${virtualModulePath}\n`;
                         }
                         else {
@@ -45235,14 +45363,20 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                 // anywhere in a string. Svelte and Astro files can't have
                 // `export default` as code so we know if it's encountered it's a
                 // false positive (e.g. contained in a string)
-                if (!path.endsWith('.vue') || !js.includes('export default')) {
+                if (!p.endsWith('.vue') || !js.includes('export default')) {
                     js += '\nexport default {}';
                 }
                 return {
                     loader: 'js',
                     contents: js,
                 };
-            });
+            };
+            // extract scripts inside HTML-like files and treat it as a js module
+            build.onLoad({ filter: htmlTypesRE, namespace: 'html' }, htmlTypeOnLoadCallback);
+            // the onResolve above will use namespace=html but esbuild doesn't
+            // call onResolve for glob imports and those will use namespace=file
+            // https://github.com/evanw/esbuild/issues/3317
+            build.onLoad({ filter: htmlTypesRE, namespace: 'file' }, htmlTypeOnLoadCallback);
             // bare imports: record and externalize ----------------------------------
             build.onResolve({
                 // avoid matching windows volume
@@ -45270,7 +45404,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                         }
                         return externalUnlessEntry({ path: id });
                     }
-                    else if (isScannable(resolved)) {
+                    else if (isScannable(resolved, config.optimizeDeps.extensions)) {
                         const namespace = htmlTypesRE.test(resolved) ? 'html' : undefined;
                         // linked package, keep crawling
                         return {
@@ -45315,7 +45449,8 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                     },
                 });
                 if (resolved) {
-                    if (shouldExternalizeDep(resolved, id) || !isScannable(resolved)) {
+                    if (shouldExternalizeDep(resolved, id) ||
+                        !isScannable(resolved, config.optimizeDeps.extensions)) {
                         return externalUnlessEntry({ path: id });
                     }
                     const namespace = htmlTypesRE.test(resolved) ? 'html' : undefined;
@@ -45387,8 +45522,11 @@ function shouldExternalizeDep(resolvedId, rawId) {
     }
     return false;
 }
-function isScannable(id) {
-    return JS_TYPES_RE.test(id) || htmlTypesRE.test(id);
+function isScannable(id, extensions) {
+    return (JS_TYPES_RE.test(id) ||
+        htmlTypesRE.test(id) ||
+        extensions?.includes(path$o.extname(id)) ||
+        false);
 }
 // esbuild v0.18 only transforms decorators when `experimentalDecorators` is set to `true`.
 // To preserve compat with the esbuild breaking change, we set `experimentalDecorators` to
@@ -47326,6 +47464,23 @@ function buildImportAnalysisPlugin(config) {
                     }
                     const s = new MagicString(code);
                     const rewroteMarkerStartPos = new Set(); // position of the leading double quote
+                    const fileDeps = [];
+                    const addFileDep = (url, runtime = false) => {
+                        const index = fileDeps.findIndex((dep) => dep.url === url);
+                        if (index === -1) {
+                            return fileDeps.push({ url, runtime }) - 1;
+                        }
+                        else {
+                            return index;
+                        }
+                    };
+                    const getFileDep = (index) => {
+                        const fileDep = fileDeps[index];
+                        if (!fileDep) {
+                            throw new Error(`Cannot find file dep at index ${index}`);
+                        }
+                        return fileDep;
+                    };
                     if (imports.length) {
                         for (let index = 0; index < imports.length; index++) {
                             // To handle escape sequences in specifier strings, the .n field will be provided where possible.
@@ -47353,12 +47508,12 @@ function buildImportAnalysisPlugin(config) {
                                     analyzed.add(filename);
                                     const chunk = bundle[filename];
                                     if (chunk) {
-                                        deps.add(chunk.fileName);
+                                        deps.add(addFileDep(chunk.fileName));
                                         chunk.imports.forEach(addDeps);
                                         // Ensure that the css imported by current chunk is loaded after the dependencies.
                                         // So the style of current chunk won't be overwritten unexpectedly.
                                         chunk.viteMetadata.importedCss.forEach((file) => {
-                                            deps.add(file);
+                                            deps.add(addFileDep(file));
                                         });
                                     }
                                     else {
@@ -47367,7 +47522,7 @@ function buildImportAnalysisPlugin(config) {
                                         if (chunk) {
                                             if (chunk.viteMetadata.importedCss.size) {
                                                 chunk.viteMetadata.importedCss.forEach((file) => {
-                                                    deps.add(file);
+                                                    deps.add(addFileDep(file));
                                                 });
                                                 hasRemovedPureCssChunk = true;
                                             }
@@ -47390,7 +47545,7 @@ function buildImportAnalysisPlugin(config) {
                                     ? modulePreload === false
                                         ? // CSS deps use the same mechanism as module preloads, so even if disabled,
                                             // we still need to pass these deps to the preload helper in dynamic imports.
-                                            [...deps].filter((d) => d.endsWith('.css'))
+                                            [...deps].filter((d) => getFileDep(d).url.endsWith('.css'))
                                         : [...deps]
                                     : [];
                                 let renderedDeps;
@@ -47406,13 +47561,18 @@ function buildImportAnalysisPlugin(config) {
                                         const cssDeps = [];
                                         const otherDeps = [];
                                         for (const dep of depsArray) {
-                                            (dep.endsWith('.css') ? cssDeps : otherDeps).push(dep);
+                                            if (getFileDep(dep).url.endsWith('.css')) {
+                                                cssDeps.push(dep);
+                                            }
+                                            else {
+                                                otherDeps.push(dep);
+                                            }
                                         }
                                         resolvedDeps = [
-                                            ...resolveDependencies(normalizedFile, otherDeps, {
+                                            ...resolveDependencies(normalizedFile, otherDeps.map((otherDep) => getFileDep(otherDep).url), {
                                                 hostId: file,
                                                 hostType: 'js',
-                                            }),
+                                            }).map((otherDep) => addFileDep(otherDep)),
                                             ...cssDeps,
                                         ];
                                     }
@@ -47420,26 +47580,36 @@ function buildImportAnalysisPlugin(config) {
                                         resolvedDeps = depsArray;
                                     }
                                     renderedDeps = resolvedDeps.map((dep) => {
-                                        const replacement = toOutputFilePathInJS(dep, 'asset', chunk.fileName, 'js', config, toRelativePath);
-                                        const replacementString = typeof replacement === 'string'
-                                            ? JSON.stringify(replacement)
-                                            : replacement.runtime;
-                                        return replacementString;
+                                        const replacement = toOutputFilePathInJS(getFileDep(dep).url, 'asset', chunk.fileName, 'js', config, toRelativePath);
+                                        if (typeof replacement === 'string') {
+                                            return addFileDep(replacement);
+                                        }
+                                        return addFileDep(replacement.runtime, true);
                                     });
                                 }
                                 else {
                                     renderedDeps = depsArray.map((d) => 
                                     // Don't include the assets dir if the default asset file names
                                     // are used, the path will be reconstructed by the import preload helper
-                                    JSON.stringify(optimizeModulePreloadRelativePaths
-                                        ? toRelativePath(d, file)
-                                        : d));
+                                    optimizeModulePreloadRelativePaths
+                                        ? addFileDep(toRelativePath(getFileDep(d).url, file))
+                                        : d);
                                 }
-                                s.update(markerStartPos, markerStartPos + preloadMarker.length + 2, `[${renderedDeps.join(',')}]`);
+                                s.update(markerStartPos, markerStartPos + preloadMarker.length + 2, `__vite__mapDeps([${renderedDeps.join(',')}])`);
                                 rewroteMarkerStartPos.add(markerStartPos);
                             }
                         }
                     }
+                    const fileDepsCode = `[${fileDeps
+                        .map((fileDep) => fileDep.runtime ? fileDep.url : JSON.stringify(fileDep.url))
+                        .join(',')}]`;
+                    s.append(`\
+function __vite__mapDeps(indexes) {
+  if (!__vite__mapDeps.viteFileDeps) {
+    __vite__mapDeps.viteFileDeps = ${fileDepsCode}
+  }
+  return indexes.map((i) => __vite__mapDeps.viteFileDeps[i])
+}`);
                     // there may still be markers due to inlined dynamic imports, remove
                     // all the markers regardless
                     let markerStartPos = indexOfMatchInSlice(code, preloadMarkerWithQuote);
@@ -54689,206 +54859,249 @@ chokidar.watch = watch;
 
 var shellQuote$1 = {};
 
-shellQuote$1.quote = function (xs) {
-    return xs.map(function (s) {
-        if (s && typeof s === 'object') {
-            return s.op.replace(/(.)/g, '\\$1');
-        }
-        else if (/["\s]/.test(s) && !/'/.test(s)) {
-            return "'" + s.replace(/(['\\])/g, '\\$1') + "'";
-        }
-        else if (/["'\s]/.test(s)) {
-            return '"' + s.replace(/(["\\$`!])/g, '\\$1') + '"';
-        }
-        else {
-            return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@\[\\\]^`{|}])/g, '$1\\$2');
-        }
-    }).join(' ');
+var quote = function quote(xs) {
+	return xs.map(function (s) {
+		if (s && typeof s === 'object') {
+			return s.op.replace(/(.)/g, '\\$1');
+		}
+		if ((/["\s]/).test(s) && !(/'/).test(s)) {
+			return "'" + s.replace(/(['\\])/g, '\\$1') + "'";
+		}
+		if ((/["'\s]/).test(s)) {
+			return '"' + s.replace(/(["\\$`!])/g, '\\$1') + '"';
+		}
+		return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, '$1\\$2');
+	}).join(' ');
 };
 
 // '<(' is process substitution operator and
 // can be parsed the same as control operator
 var CONTROL = '(?:' + [
-    '\\|\\|', '\\&\\&', ';;', '\\|\\&', '\\<\\(', '>>', '>\\&', '[&;()|<>]'
+	'\\|\\|',
+	'\\&\\&',
+	';;',
+	'\\|\\&',
+	'\\<\\(',
+	'\\<\\<\\<',
+	'>>',
+	'>\\&',
+	'<\\&',
+	'[&;()|<>]'
 ].join('|') + ')';
+var controlRE = new RegExp('^' + CONTROL + '$');
 var META = '|&;()<> \\t';
-var BAREWORD = '(\\\\[\'"' + META + ']|[^\\s\'"' + META + '])+';
 var SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
 var DOUBLE_QUOTE = '\'((\\\\\'|[^\'])*?)\'';
+var hash = /^#$/;
+
+var SQ = "'";
+var DQ = '"';
+var DS = '$';
 
 var TOKEN = '';
+var mult = 0x100000000; // Math.pow(16, 8);
 for (var i = 0; i < 4; i++) {
-    TOKEN += (Math.pow(16,8)*Math.random()).toString(16);
+	TOKEN += (mult * Math.random()).toString(16);
 }
+var startsWithToken = new RegExp('^' + TOKEN);
 
-shellQuote$1.parse = function (s, env, opts) {
-    var mapped = parse$5(s, env, opts);
-    if (typeof env !== 'function') return mapped;
-    return mapped.reduce(function (acc, s) {
-        if (typeof s === 'object') return acc.concat(s);
-        var xs = s.split(RegExp('(' + TOKEN + '.*?' + TOKEN + ')', 'g'));
-        if (xs.length === 1) return acc.concat(xs[0]);
-        return acc.concat(xs.filter(Boolean).map(function (x) {
-            if (RegExp('^' + TOKEN).test(x)) {
-                return JSON.parse(x.split(TOKEN)[1]);
-            }
-            else return x;
-        }));
-    }, []);
-};
+function matchAll(s, r) {
+	var origIndex = r.lastIndex;
 
-function parse$5 (s, env, opts) {
-    var chunker = new RegExp([
-        '(' + CONTROL + ')', // control chars
-        '(' + BAREWORD + '|' + SINGLE_QUOTE + '|' + DOUBLE_QUOTE + ')*'
-    ].join('|'), 'g');
-    var match = s.match(chunker).filter(Boolean);
-    var commented = false;
+	var matches = [];
+	var matchObj;
 
-    if (!match) return [];
-    if (!env) env = {};
-    if (!opts) opts = {};
-    return match.map(function (s, j) {
-        if (commented) {
-            return;
-        }
-        if (RegExp('^' + CONTROL + '$').test(s)) {
-            return { op: s };
-        }
+	while ((matchObj = r.exec(s))) {
+		matches.push(matchObj);
+		if (r.lastIndex === matchObj.index) {
+			r.lastIndex += 1;
+		}
+	}
 
-        // Hand-written scanner/parser for Bash quoting rules:
-        //
-        //  1. inside single quotes, all characters are printed literally.
-        //  2. inside double quotes, all characters are printed literally
-        //     except variables prefixed by '$' and backslashes followed by
-        //     either a double quote or another backslash.
-        //  3. outside of any quotes, backslashes are treated as escape
-        //     characters and not printed (unless they are themselves escaped)
-        //  4. quote context can switch mid-token if there is no whitespace
-        //     between the two quote contexts (e.g. all'one'"token" parses as
-        //     "allonetoken")
-        var SQ = "'";
-        var DQ = '"';
-        var DS = '$';
-        var BS = opts.escape || '\\';
-        var quote = false;
-        var esc = false;
-        var out = '';
-        var isGlob = false;
-
-        for (var i = 0, len = s.length; i < len; i++) {
-            var c = s.charAt(i);
-            isGlob = isGlob || (!quote && (c === '*' || c === '?'));
-            if (esc) {
-                out += c;
-                esc = false;
-            }
-            else if (quote) {
-                if (c === quote) {
-                    quote = false;
-                }
-                else if (quote == SQ) {
-                    out += c;
-                }
-                else { // Double quote
-                    if (c === BS) {
-                        i += 1;
-                        c = s.charAt(i);
-                        if (c === DQ || c === BS || c === DS) {
-                            out += c;
-                        } else {
-                            out += BS + c;
-                        }
-                    }
-                    else if (c === DS) {
-                        out += parseEnvVar();
-                    }
-                    else {
-                        out += c;
-                    }
-                }
-            }
-            else if (c === DQ || c === SQ) {
-                quote = c;
-            }
-            else if (RegExp('^' + CONTROL + '$').test(c)) {
-                return { op: s };
-            }
-            else if (RegExp('^#$').test(c)) {
-                commented = true;
-                if (out.length){
-                    return [out, { comment: s.slice(i+1) + match.slice(j+1).join(' ') }];
-                }
-                return [{ comment: s.slice(i+1) + match.slice(j+1).join(' ') }];
-            }
-            else if (c === BS) {
-                esc = true;
-            }
-            else if (c === DS) {
-                out += parseEnvVar();
-            }
-            else out += c;
-        }
+	r.lastIndex = origIndex;
 
-        if (isGlob) return {op: 'glob', pattern: out};
+	return matches;
+}
 
-        return out;
+function getVar(env, pre, key) {
+	var r = typeof env === 'function' ? env(key) : env[key];
+	if (typeof r === 'undefined' && key != '') {
+		r = '';
+	} else if (typeof r === 'undefined') {
+		r = '$';
+	}
 
-        function parseEnvVar() {
-            i += 1;
-            var varend, varname;
-            //debugger
-            if (s.charAt(i) === '{') {
-                i += 1;
-                if (s.charAt(i) === '}') {
-                    throw new Error("Bad substitution: " + s.substr(i - 2, 3));
-                }
-                varend = s.indexOf('}', i);
-                if (varend < 0) {
-                    throw new Error("Bad substitution: " + s.substr(i));
-                }
-                varname = s.substr(i, varend - i);
-                i = varend;
-            }
-            else if (/[*@#?$!_\-]/.test(s.charAt(i))) {
-                varname = s.charAt(i);
-                i += 1;
-            }
-            else {
-                varend = s.substr(i).match(/[^\w\d_]/);
-                if (!varend) {
-                    varname = s.substr(i);
-                    i = s.length;
-                } else {
-                    varname = s.substr(i, varend.index);
-                    i += varend.index - 1;
-                }
-            }
-            return getVar(null, '', varname);
-        }
-    })
-    // finalize parsed aruments
-    .reduce(function(prev, arg){
-        if (arg === undefined){
-            return prev;
-        }
-        return prev.concat(arg);
-    },[]);
+	if (typeof r === 'object') {
+		return pre + TOKEN + JSON.stringify(r) + TOKEN;
+	}
+	return pre + r;
+}
 
-    function getVar (_, pre, key) {
-        var r = typeof env === 'function' ? env(key) : env[key];
-        if (r === undefined && key != '')
-            r = '';
-        else if (r === undefined)
-            r = '$';
+function parseInternal(string, env, opts) {
+	if (!opts) {
+		opts = {};
+	}
+	var BS = opts.escape || '\\';
+	var BAREWORD = '(\\' + BS + '[\'"' + META + ']|[^\\s\'"' + META + '])+';
 
-        if (typeof r === 'object') {
-            return pre + TOKEN + JSON.stringify(r) + TOKEN;
-        }
-        else return pre + r;
-    }
+	var chunker = new RegExp([
+		'(' + CONTROL + ')', // control chars
+		'(' + BAREWORD + '|' + SINGLE_QUOTE + '|' + DOUBLE_QUOTE + ')+'
+	].join('|'), 'g');
+
+	var matches = matchAll(string, chunker);
+
+	if (matches.length === 0) {
+		return [];
+	}
+	if (!env) {
+		env = {};
+	}
+
+	var commented = false;
+
+	return matches.map(function (match) {
+		var s = match[0];
+		if (!s || commented) {
+			return void undefined;
+		}
+		if (controlRE.test(s)) {
+			return { op: s };
+		}
+
+		// Hand-written scanner/parser for Bash quoting rules:
+		//
+		// 1. inside single quotes, all characters are printed literally.
+		// 2. inside double quotes, all characters are printed literally
+		//    except variables prefixed by '$' and backslashes followed by
+		//    either a double quote or another backslash.
+		// 3. outside of any quotes, backslashes are treated as escape
+		//    characters and not printed (unless they are themselves escaped)
+		// 4. quote context can switch mid-token if there is no whitespace
+		//     between the two quote contexts (e.g. all'one'"token" parses as
+		//     "allonetoken")
+		var quote = false;
+		var esc = false;
+		var out = '';
+		var isGlob = false;
+		var i;
+
+		function parseEnvVar() {
+			i += 1;
+			var varend;
+			var varname;
+			var char = s.charAt(i);
+
+			if (char === '{') {
+				i += 1;
+				if (s.charAt(i) === '}') {
+					throw new Error('Bad substitution: ' + s.slice(i - 2, i + 1));
+				}
+				varend = s.indexOf('}', i);
+				if (varend < 0) {
+					throw new Error('Bad substitution: ' + s.slice(i));
+				}
+				varname = s.slice(i, varend);
+				i = varend;
+			} else if ((/[*@#?$!_-]/).test(char)) {
+				varname = char;
+				i += 1;
+			} else {
+				var slicedFromI = s.slice(i);
+				varend = slicedFromI.match(/[^\w\d_]/);
+				if (!varend) {
+					varname = slicedFromI;
+					i = s.length;
+				} else {
+					varname = slicedFromI.slice(0, varend.index);
+					i += varend.index - 1;
+				}
+			}
+			return getVar(env, '', varname);
+		}
+
+		for (i = 0; i < s.length; i++) {
+			var c = s.charAt(i);
+			isGlob = isGlob || (!quote && (c === '*' || c === '?'));
+			if (esc) {
+				out += c;
+				esc = false;
+			} else if (quote) {
+				if (c === quote) {
+					quote = false;
+				} else if (quote == SQ) {
+					out += c;
+				} else { // Double quote
+					if (c === BS) {
+						i += 1;
+						c = s.charAt(i);
+						if (c === DQ || c === BS || c === DS) {
+							out += c;
+						} else {
+							out += BS + c;
+						}
+					} else if (c === DS) {
+						out += parseEnvVar();
+					} else {
+						out += c;
+					}
+				}
+			} else if (c === DQ || c === SQ) {
+				quote = c;
+			} else if (controlRE.test(c)) {
+				return { op: s };
+			} else if (hash.test(c)) {
+				commented = true;
+				var commentObj = { comment: string.slice(match.index + i + 1) };
+				if (out.length) {
+					return [out, commentObj];
+				}
+				return [commentObj];
+			} else if (c === BS) {
+				esc = true;
+			} else if (c === DS) {
+				out += parseEnvVar();
+			} else {
+				out += c;
+			}
+		}
+
+		if (isGlob) {
+			return { op: 'glob', pattern: out };
+		}
+
+		return out;
+	}).reduce(function (prev, arg) { // finalize parsed arguments
+		// TODO: replace this whole reduce with a concat
+		return typeof arg === 'undefined' ? prev : prev.concat(arg);
+	}, []);
 }
 
+var parse$5 = function parse(s, env, opts) {
+	var mapped = parseInternal(s, env, opts);
+	if (typeof env !== 'function') {
+		return mapped;
+	}
+	return mapped.reduce(function (acc, s) {
+		if (typeof s === 'object') {
+			return acc.concat(s);
+		}
+		var xs = s.split(RegExp('(' + TOKEN + '.*?' + TOKEN + ')', 'g'));
+		if (xs.length === 1) {
+			return acc.concat(xs[0]);
+		}
+		return acc.concat(xs.filter(Boolean).map(function (x) {
+			if (startsWithToken.test(x)) {
+				return JSON.parse(x.split(TOKEN)[1]);
+			}
+			return x;
+		}));
+	}, []);
+};
+
+shellQuote$1.quote = quote;
+shellQuote$1.parse = parse$5;
+
 var osx = {
   '/Applications/Atom.app/Contents/MacOS/Atom': 'atom',
   '/Applications/Atom Beta.app/Contents/MacOS/Atom Beta':
@@ -54932,10 +55145,10 @@ var osx = {
 var linux = {
   atom: 'atom',
   Brackets: 'brackets',
-  code: 'code',
   'code-insiders': 'code-insiders',
-  codium: 'codium',
+  code: 'code',
   vscodium: 'vscodium',
+  codium: 'codium',
   emacs: 'emacs',
   gvim: 'gvim',
   'idea.sh': 'idea',
@@ -56529,18 +56742,20 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     };
     urlStack = urlStack.concat(url);
     const isCircular = (url) => urlStack.includes(url);
-    const { isProduction, resolve: { dedupe, preserveSymlinks }, root, } = server.config;
+    const { isProduction, resolve: { dedupe, preserveSymlinks }, root, ssr, } = server.config;
+    const overrideConditions = ssr.resolve?.externalConditions || [];
     const resolveOptions = {
         mainFields: ['main'],
         browserField: true,
         conditions: [],
-        overrideConditions: ['production', 'development'],
+        overrideConditions: [...overrideConditions, 'production', 'development'],
         extensions: ['.js', '.cjs', '.json'],
         dedupe,
         preserveSymlinks,
         isBuild: false,
         isProduction,
         root,
+        ssrConfig: ssr,
     };
     // Since dynamic imports can happen in parallel, we need to
     // account for multiple pending deps and duplicate imports.
@@ -56638,22 +56853,13 @@ async function nodeImport(id, importer, resolveOptions) {
         url = id;
     }
     else {
-        const resolved = tryNodeResolve(id, importer, 
-        // Non-external modules can import ESM-only modules, but only outside
-        // of test runs, because we use Node `require` in Jest to avoid segfault.
-        // @ts-expect-error jest only exists when running Jest
-        typeof jest === 'undefined'
-            ? { ...resolveOptions, tryEsmOnly: true }
-            : resolveOptions, false);
+        const resolved = tryNodeResolve(id, importer, { ...resolveOptions, tryEsmOnly: true }, false, undefined, true);
         if (!resolved) {
             const err = new Error(`Cannot find module '${id}' imported from '${importer}'`);
             err.code = 'ERR_MODULE_NOT_FOUND';
             throw err;
         }
-        url = resolved.id;
-        if (usingDynamicImport) {
-            url = pathToFileURL(url).toString();
-        }
+        url = pathToFileURL(resolved.id).toString();
     }
     const mod = await dynamicImport(url);
     return proxyESM(mod);
@@ -65015,7 +65221,7 @@ function transformMiddleware(server) {
                     }
                     else {
                         warning =
-                            `files in the public directory are served at the root path.\n` +
+                            `Files in the public directory are served at the root path.\n` +
                                 `Instead of ${colors$1.cyan(url)}, use ${colors$1.cyan(url.replace(publicPath, '/'))}.`;
                     }
                     logger.warn(colors$1.yellow(warning));
@@ -65340,7 +65546,10 @@ function preTransformRequest(server, url, base) {
             return;
         }
         // Unexpected error, log the issue but avoid an unhandled exception
-        server.config.logger.error(e.message);
+        server.config.logger.error(`Pre-transform error: ${e.message}`, {
+            error: e,
+            timestamp: true,
+        });
     });
 }
 
@@ -66453,7 +66662,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         mainFields: config.resolve?.mainFields ?? DEFAULT_MAIN_FIELDS,
         browserField: config.resolve?.browserField ?? true,
         conditions: config.resolve?.conditions ?? [],
-        extensions: config.resolve?.extensions ?? DEFAULT_EXTENSIONS$1,
+        extensions: config.resolve?.extensions ?? DEFAULT_EXTENSIONS,
         dedupe: config.resolve?.dedupe ?? [],
         preserveSymlinks: config.resolve?.preserveSymlinks ?? false,
         alias: resolvedAlias,
@@ -66661,12 +66870,6 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
     else if (middlewareMode === 'html') {
         logger.warn(colors$1.yellow(`Setting server.middlewareMode to 'html' is deprecated, set server.middlewareMode to \`true\` instead`));
     }
-    if (config.server?.force &&
-        !isBuild &&
-        config.optimizeDeps?.force === undefined) {
-        resolved.optimizeDeps.force = true;
-        logger.warn(colors$1.yellow(`server.force is deprecated, use optimizeDeps.force instead`));
-    }
     debug?.(`using resolved config: %O`, {
         ...resolved,
         plugins: resolved.plugins.map((p) => p.name),
@@ -66848,7 +67051,7 @@ async function bundleConfigFile(fileName, isESM) {
                             conditions: [],
                             overrideConditions: ['node'],
                             dedupe: [],
-                            extensions: DEFAULT_EXTENSIONS$1,
+                            extensions: DEFAULT_EXTENSIONS,
                             preserveSymlinks: false,
                             packageCache,
                             isRequire,