vite 5.0.0-beta.1 → 5.0.0-beta.2

package/dist/node/chunks/{dep-e31699fa.js → dep-82f73734.js}

@@ -1,15 +1,15 @@
-import fs$l from 'node:fs';
+import fs$l, { promises as promises$1 } from 'node:fs';
 import fsp from 'node:fs/promises';
-import path$o, { dirname as dirname$2, join as join$2, posix as posix$1, isAbsolute as isAbsolute$2, relative as relative$2, basename as basename$2, extname as extname$1 } from 'node:path';
+import path$o, { posix as posix$1, isAbsolute as isAbsolute$2, join as join$2, relative as relative$2, dirname as dirname$2, basename as basename$2, extname as extname$1 } from 'node:path';
 import { fileURLToPath, URL as URL$3, URLSearchParams, parse as parse$i, pathToFileURL } from 'node:url';
 import { promisify as promisify$4, format as format$2, inspect } from 'node:util';
 import { performance } from 'node:perf_hooks';
 import { createRequire as createRequire$1, builtinModules } from 'node:module';
 import require$$0$3 from 'tty';
 import esbuild, { transform as transform$1, formatMessages, build as build$3 } from 'esbuild';
-import require$$0$4, { win32, posix, isAbsolute as isAbsolute$1, resolve as resolve$3, relative as relative$1, basename as basename$1, extname, dirname as dirname$1, join as join$1, sep as sep$1, normalize } from 'path';
+import require$$0$4, { win32, posix, isAbsolute as isAbsolute$1, resolve as resolve$3, relative as relative$1, basename as basename$1, extname, dirname as dirname$1, join as join$1, sep, normalize } from 'path';
 import * as require$$0$2 from 'fs';
-import require$$0__default, { existsSync, readFileSync, statSync as statSync$1, promises as promises$1, readdir as readdir$4, readdirSync } from 'fs';
+import require$$0__default, { existsSync, readFileSync, statSync as statSync$1, readdirSync } from 'fs';
 import require$$0$5 from 'events';
 import require$$5 from 'assert';
 import require$$0$6 from 'util';
@@ -31,13 +31,13 @@ import assert$1 from 'node:assert';
 import process$1 from 'node:process';
 import v8 from 'node:v8';
 import { VERSION } from 'rollup';
-import require$$1 from 'worker_threads';
 import { createServer as createServer$3, STATUS_CODES } from 'node:http';
 import { createServer as createServer$2 } from 'node:https';
 import require$$0$a from 'zlib';
 import require$$0$b from 'buffer';
 import require$$1$2 from 'https';
 import require$$4$1 from 'tls';
+import require$$1 from 'worker_threads';
 import * as qs from 'querystring';
 import readline from 'node:readline';
 import zlib$1, { gzip } from 'node:zlib';
@@ -420,7 +420,7 @@ let SyncWalker$1 = class SyncWalker extends WalkerBase$1 {
  * }} walker
  * @returns {BaseNode}
  */
-function walk$4(ast, { enter, leave }) {
+function walk$3(ast, { enter, leave }) {
 	const instance = new SyncWalker$1(enter, leave);
 	return instance.visit(ast, null);
 }
@@ -2559,7 +2559,7 @@ let Scope$1 = class Scope {
 };
 const attachScopes = function attachScopes(ast, propertyName = 'scope') {
     let scope = new Scope$1();
-    walk$4(ast, {
+    walk$3(ast, {
         enter(n, parent) {
             const node = n;
             // function foo () {...}
@@ -7796,7 +7796,7 @@ function getEsImportProxy(id, defaultIsModuleExports) {
 /* eslint-disable no-param-reassign, no-undefined */
 
 function getCandidatesForExtension(resolved, extension) {
-  return [resolved + extension, `${resolved}${sep$1}index${extension}`];
+  return [resolved + extension, `${resolved}${sep}index${extension}`];
 }
 
 function getCandidates(resolved, extensions) {
@@ -8849,7 +8849,7 @@ async function transformCommonjs(
   const importedVariables = new Set();
   const indentExclusionRanges = [];
 
-  walk$4(ast, {
+  walk$3(ast, {
     enter(node, parent) {
       if (skippedNodes.has(node)) {
         this.skip();
@@ -11549,7 +11549,7 @@ if (typeof process === 'undefined' || process.type === 'renderer' || process.bro
 }
 
 var srcExports$1 = src$2.exports;
-var debug$g = /*@__PURE__*/getDefaultExportFromCjs(srcExports$1);
+var debug$h = /*@__PURE__*/getDefaultExportFromCjs(srcExports$1);
 
 let pnp;
 if (process.versions.pnp) {
@@ -11707,7 +11707,7 @@ function watchPackageDataPlugin(packageCache) {
     let watchFile = watchFileStub;
     const setPackageData = packageCache.set.bind(packageCache);
     packageCache.set = (id, pkg) => {
-        if (!isInNodeModules(pkg.dir) && !watchedDirs.has(pkg.dir)) {
+        if (!isInNodeModules$1(pkg.dir) && !watchedDirs.has(pkg.dir)) {
             watchedDirs.add(pkg.dir);
             watchFile(path$o.join(pkg.dir, 'package.json'));
         }
@@ -11857,7 +11857,7 @@ function isBuiltin(id) {
         ? id.slice(NODE_BUILTIN_NAMESPACE.length)
         : id);
 }
-function isInNodeModules(id) {
+function isInNodeModules$1(id) {
     return id.includes('node_modules');
 }
 function moduleListContains(moduleList, id) {
@@ -11876,7 +11876,7 @@ const _require$3 = createRequire$1(import.meta.url);
 const filter = process.env.VITE_DEBUG_FILTER;
 const DEBUG = process.env.DEBUG;
 function createDebugger(namespace, options = {}) {
-    const log = debug$g(namespace);
+    const log = debug$h(namespace);
     const { onlyWhenFocused } = options;
     let enabled = log.enabled;
     if (enabled && onlyWhenFocused) {
@@ -12693,7 +12693,7 @@ const isNonDriveRelativeAbsolutePath = (p) => {
 };
 /**
  * Determine if a file is being requested with the correct case, to ensure
- * consistent behaviour between dev and prod and across operating systems.
+ * consistent behavior between dev and prod and across operating systems.
  */
 function shouldServeFile(filePath, root) {
     // can skip case check on Linux
@@ -13003,7 +13003,7 @@ function buildReporterPlugin(config) {
                         // the same chunk. The intersecting dynamic importers' dynamic import is not
                         // expected to work. Note we're only detecting the direct ineffective
                         // dynamic import here.
-                        const detectedIneffectiveDynamicImport = module.dynamicImporters.some((id) => !isInNodeModules(id) && chunk.moduleIds.includes(id));
+                        const detectedIneffectiveDynamicImport = module.dynamicImporters.some((id) => !isInNodeModules$1(id) && chunk.moduleIds.includes(id));
                         if (detectedIneffectiveDynamicImport) {
                             this.warn(`\n(!) ${module.id} is dynamically imported by ${module.dynamicImporters.join(', ')} but also statically imported by ${module.importers.join(', ')}, dynamic import will not move module into another chunk.\n`);
                         }
@@ -13172,635 +13172,988 @@ function displayTime(time) {
     return `${mins}m${seconds < 1 ? '' : ` ${seconds.toFixed(0)}s`}`;
 }
 
-// src/find.ts
-async function find(filename, options) {
-  let dir = require$$0$4.dirname(require$$0$4.resolve(filename));
-  const root = (options == null ? void 0 : options.root) ? require$$0$4.resolve(options.root) : null;
-  while (dir) {
-    const tsconfig = await tsconfigInDir(dir, options);
-    if (tsconfig) {
-      return tsconfig;
-    } else {
-      if (root === dir) {
-        break;
-      }
-      const parent = require$$0$4.dirname(dir);
-      if (parent === dir) {
-        break;
-      } else {
-        dir = parent;
-      }
-    }
-  }
-  throw new Error(`no tsconfig file found for ${filename}`);
+const POSIX_SEP_RE = new RegExp('\\' + path$o.posix.sep, 'g');
+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 IS_POSIX = path$o.posix.sep === path$o.sep;
+
+/**
+ * @template T
+ * @returns {{resolve:(result:T)=>void, reject:(error:any)=>void, promise: Promise<T>}}
+ */
+function makePromise() {
+	let resolve, reject;
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	return { promise, resolve, reject };
 }
-async function tsconfigInDir(dir, options) {
-  const tsconfig = require$$0$4.join(dir, "tsconfig.json");
-  if (options == null ? void 0 : options.tsConfigPaths) {
-    return options.tsConfigPaths.has(tsconfig) ? tsconfig : void 0;
-  }
-  try {
-    const stat = await promises$1.stat(tsconfig);
-    if (stat.isFile() || stat.isFIFO()) {
-      return tsconfig;
-    }
-  } catch (e) {
-    if (e.code !== "ENOENT") {
-      throw e;
-    }
-  }
+
+/**
+ * @param {string} filename
+ * @param {import('./cache.js').TSConfckCache} [cache]
+ * @returns {Promise<string|void>}
+ */
+async function resolveTSConfigJson(filename, cache) {
+	if (path$o.extname(filename) !== '.json') {
+		return; // ignore files that are not json
+	}
+	const tsconfig = path$o.resolve(filename);
+	if (cache) {
+		if (cache.hasParseResult(tsconfig) || cache.hasParseResult(filename)) {
+			return tsconfig;
+		}
+	}
+	return promises$1.stat(tsconfig).then((stat) => {
+		if (stat.isFile() || stat.isFIFO()) {
+			return tsconfig;
+		} else {
+			throw new Error(`${filename} exists but is not a regular file.`);
+		}
+	});
 }
-var sep = require$$0$4.sep;
-async function findAll(dir, options) {
-  const state = {
-    files: [],
-    calls: 0,
-    skip: options == null ? void 0 : options.skip,
-    err: false
-  };
-  return new Promise((resolve, reject) => {
-    walk$3(require$$0$4.resolve(dir), state, (err, files) => err ? reject(err) : resolve(files));
-  });
+
+/**
+ *
+ * @param {string} dir an absolute directory path
+ * @returns {boolean}  if dir path includes a node_modules segment
+ */
+const isInNodeModules = IS_POSIX
+	? (dir) => dir.includes('/node_modules/')
+	: (dir) => dir.match(/[/\\]node_modules[/\\]/);
+
+/**
+ * convert posix separator to native separator
+ *
+ * eg.
+ * windows: C:/foo/bar -> c:\foo\bar
+ * linux: /foo/bar -> /foo/bar
+ *
+ * @param {string} filename with posix separators
+ * @returns {string} filename with native separators
+ */
+const posix2native = IS_POSIX
+	? (filename) => filename
+	: (filename) => filename.replace(POSIX_SEP_RE, path$o.sep);
+
+/**
+ * convert native separator to posix separator
+ *
+ * eg.
+ * windows: C:\foo\bar -> c:/foo/bar
+ * linux: /foo/bar -> /foo/bar
+ *
+ * @param {string} filename - filename with native separators
+ * @returns {string} filename with posix separators
+ */
+const native2posix = IS_POSIX
+	? (filename) => filename
+	: (filename) => filename.replace(NATIVE_SEP_RE, path$o.posix.sep);
+
+/**
+ * converts params to native separator, resolves path and converts native back to posix
+ *
+ * needed on windows to handle posix paths in tsconfig
+ *
+ * @param dir {string|null} directory to resolve from
+ * @param filename {string} filename or pattern to resolve
+ * @returns string
+ */
+const resolve2posix = IS_POSIX
+	? (dir, filename) => (dir ? path$o.resolve(dir, filename) : path$o.resolve(filename))
+	: (dir, filename) =>
+			native2posix(
+				dir
+					? path$o.resolve(posix2native(dir), posix2native(filename))
+					: path$o.resolve(posix2native(filename))
+			);
+
+/**
+ *
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @returns {string[]}
+ */
+function resolveReferencedTSConfigFiles(result) {
+	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');
+		return resolve2posix(dir, refPath);
+	});
 }
-function walk$3(dir, state, done) {
-  if (state.err) {
-    return;
-  }
-  state.calls++;
-  readdir$4(dir, { withFileTypes: true }, (err, entries = []) => {
-    var _a;
-    if (state.err) {
-      return;
-    }
-    if (err && !(err.code === "ENOENT" || err.code === "EACCES" || err.code === "EPERM")) {
-      state.err = true;
-      done(err);
-    } else {
-      for (const ent of entries) {
-        if (ent.isDirectory() && !((_a = state.skip) == null ? void 0 : _a.call(state, ent.name))) {
-          walk$3(`${dir}${sep}${ent.name}`, state, done);
-        } else if (ent.isFile() && ent.name === "tsconfig.json") {
-          state.files.push(`${dir}${sep}tsconfig.json`);
-        }
-      }
-      if (--state.calls === 0) {
-        if (!state.err) {
-          done(null, state.files);
-        }
-      }
-    }
-  });
+
+/**
+ * @param {string} filename
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @returns {import('./public.d.ts').TSConfckParseResult}
+ */
+function resolveSolutionTSConfig(filename, result) {
+	if (
+		result.referenced &&
+		DEFAULT_EXTENSIONS.some((ext) => filename.endsWith(ext)) &&
+		!isIncluded(filename, result)
+	) {
+		const solutionTSConfig = result.referenced.find((referenced) =>
+			isIncluded(filename, referenced)
+		);
+		if (solutionTSConfig) {
+			return solutionTSConfig;
+		}
+	}
+	return result;
+}
+
+/**
+ *
+ * @param {string} filename
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @returns {boolean}
+ */
+function isIncluded(filename, result) {
+	const dir = native2posix(path$o.dirname(result.tsconfigFile));
+	const files = (result.tsconfig.files || []).map((file) => resolve2posix(dir, file));
+	const absoluteFilename = resolve2posix(null, filename);
+	if (files.includes(filename)) {
+		return true;
+	}
+	const isIncluded = isGlobMatch(
+		absoluteFilename,
+		dir,
+		result.tsconfig.include || (result.tsconfig.files ? [] : [GLOB_ALL_PATTERN])
+	);
+	if (isIncluded) {
+		const isExcluded = isGlobMatch(absoluteFilename, dir, result.tsconfig.exclude || []);
+		return !isExcluded;
+	}
+	return false;
+}
+
+/**
+ * test filenames agains glob patterns in tsconfig
+ *
+ * @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
+ * @returns {boolean} true when at least one pattern matches filename
+ */
+function isGlobMatch(filename, dir, patterns) {
+	return patterns.some((pattern) => {
+		// filename must end with part of pattern that comes after last wildcard
+		let lastWildcardIndex = pattern.length;
+		let hasWildcard = false;
+		for (let i = pattern.length - 1; i > -1; i--) {
+			if (pattern[i] === '*' || pattern[i] === '?') {
+				lastWildcardIndex = i;
+				hasWildcard = true;
+				break;
+			}
+		}
+
+		// if pattern does not end with wildcard, filename must end with pattern after last wildcard
+		if (
+			lastWildcardIndex < pattern.length - 1 &&
+			!filename.endsWith(pattern.slice(lastWildcardIndex + 1))
+		) {
+			return false;
+		}
+
+		// if pattern ends with *, filename must end with a default extension
+		if (pattern.endsWith('*') && !DEFAULT_EXTENSIONS.some((ext) => filename.endsWith(ext))) {
+			return false;
+		}
+
+		// for **/* , filename must start with the dir
+		if (pattern === GLOB_ALL_PATTERN) {
+			return filename.startsWith(`${dir}/`);
+		}
+
+		const resolvedPattern = resolve2posix(dir, pattern);
+
+		// filename must start with part of pattern that comes before first wildcard
+		let firstWildcardIndex = -1;
+		for (let i = 0; i < resolvedPattern.length; i++) {
+			if (resolvedPattern[i] === '*' || resolvedPattern[i] === '?') {
+				firstWildcardIndex = i;
+				hasWildcard = true;
+				break;
+			}
+		}
+		if (
+			firstWildcardIndex > 1 &&
+			!filename.startsWith(resolvedPattern.slice(0, firstWildcardIndex - 1))
+		) {
+			return false;
+		}
+
+		// if no wildcard in pattern, filename must be equal to resolved pattern
+		if (!hasWildcard) {
+			return filename === resolvedPattern;
+		}
+
+		// complex pattern, use regex to check it
+		if (PATTERN_REGEX_CACHE.has(resolvedPattern)) {
+			return PATTERN_REGEX_CACHE.get(resolvedPattern).test(filename);
+		}
+		const regex = pattern2regex(resolvedPattern);
+		PATTERN_REGEX_CACHE.set(resolvedPattern, regex);
+		return regex.test(filename);
+	});
+}
+
+/**
+ * @param {string} resolvedPattern
+ * @returns {RegExp}
+ */
+function pattern2regex(resolvedPattern) {
+	let regexStr = '^';
+	for (let i = 0; i < resolvedPattern.length; i++) {
+		const char = resolvedPattern[i];
+		if (char === '?') {
+			regexStr += '[^\\/]';
+			continue;
+		}
+		if (char === '*') {
+			if (resolvedPattern[i + 1] === '*' && resolvedPattern[i + 2] === '/') {
+				i += 2;
+				regexStr += '(?:[^\\/]*\\/)*'; // zero or more path segments
+				continue;
+			}
+			regexStr += '[^\\/]*';
+			continue;
+		}
+		if ('/.+^${}()|[]\\'.includes(char)) {
+			regexStr += `\\`;
+		}
+		regexStr += char;
+	}
+
+	// add known file endings if pattern ends on *
+	if (resolvedPattern.endsWith('*')) {
+		regexStr += DEFAULT_EXTENSIONS_RE_GROUP;
+	}
+	regexStr += '$';
+
+	return new RegExp(regexStr);
+}
+
+/**
+ * find the closest tsconfig.json file
+ *
+ * @param {string} filename - path to file to find tsconfig for (absolute or relative to cwd)
+ * @param {import('./public.d.ts').TSConfckFindOptions} [options] - options
+ * @returns {Promise<string|null>} absolute path to closest tsconfig.json or null if not found
+ */
+async function find(filename, options) {
+	let dir = path$o.dirname(path$o.resolve(filename));
+	if (options?.ignoreNodeModules && isInNodeModules(dir)) {
+		return null;
+	}
+	const cache = options?.cache;
+	if (cache?.hasTSConfigPath(dir)) {
+		return cache.getTSConfigPath(dir);
+	}
+	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);
+	return promise;
+}
+
+/**
+ *
+ * @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]
+ */
+function findUp(dir, { resolve, reject, promise }, cache, root) {
+	const tsconfig = path$o.join(dir, 'tsconfig.json');
+	if (cache) {
+		if (cache.hasTSConfigPath(dir)) {
+			let cached;
+			try {
+				cached = cache.getTSConfigPath(dir);
+			} catch (e) {
+				reject(e);
+				return;
+			}
+			if (cached?.then) {
+				cached.then(resolve).catch(reject);
+			} else {
+				resolve(cached);
+			}
+		} else {
+			cache.setTSConfigPath(dir, promise);
+		}
+	}
+	fs$l.stat(tsconfig, (err, stats) => {
+		if (stats && (stats.isFile() || stats.isFIFO())) {
+			resolve(tsconfig);
+		} else if (err?.code !== 'ENOENT') {
+			reject(err);
+		} else {
+			let parent;
+			if (root === dir || (parent = path$o.dirname(dir)) === dir) {
+				resolve(null);
+			} else {
+				findUp(parent, { promise, resolve, reject }, cache, root);
+			}
+		}
+	});
 }
 
-// src/to-json.ts
+/*
+ this file contains code from strip-bom and strip-json-comments by Sindre Sorhus
+ https://github.com/sindresorhus/strip-json-comments/blob/v4.0.0/index.js
+ https://github.com/sindresorhus/strip-bom/blob/v5.0.0/index.js
+ licensed under MIT, see ../LICENSE
+*/
+
+/**
+ * convert content of tsconfig.json to regular json
+ *
+ * @param {string} tsconfigJson - content of tsconfig.json
+ * @returns {string} content as regular json, comments and dangling commas have been replaced with whitespace
+ */
 function toJson(tsconfigJson) {
-  const stripped = stripDanglingComma(stripJsonComments(stripBom(tsconfigJson)));
-  if (stripped.trim() === "") {
-    return "{}";
-  } else {
-    return stripped;
-  }
+	const stripped = stripDanglingComma(stripJsonComments(stripBom(tsconfigJson)));
+	if (stripped.trim() === '') {
+		// only whitespace left after stripping, return empty object so that JSON.parse still works
+		return '{}';
+	} else {
+		return stripped;
+	}
 }
+
+/**
+ * replace dangling commas from pseudo-json string with single space
+ * implementation heavily inspired by strip-json-comments
+ *
+ * @param {string} pseudoJson
+ * @returns {string}
+ */
 function stripDanglingComma(pseudoJson) {
-  let insideString = false;
-  let offset = 0;
-  let result = "";
-  let danglingCommaPos = null;
-  for (let i = 0; i < pseudoJson.length; i++) {
-    const currentCharacter = pseudoJson[i];
-    if (currentCharacter === '"') {
-      const escaped = isEscaped(pseudoJson, i);
-      if (!escaped) {
-        insideString = !insideString;
-      }
-    }
-    if (insideString) {
-      danglingCommaPos = null;
-      continue;
-    }
-    if (currentCharacter === ",") {
-      danglingCommaPos = i;
-      continue;
-    }
-    if (danglingCommaPos) {
-      if (currentCharacter === "}" || currentCharacter === "]") {
-        result += pseudoJson.slice(offset, danglingCommaPos) + " ";
-        offset = danglingCommaPos + 1;
-        danglingCommaPos = null;
-      } else if (!currentCharacter.match(/\s/)) {
-        danglingCommaPos = null;
-      }
-    }
-  }
-  return result + pseudoJson.substring(offset);
+	let insideString = false;
+	let offset = 0;
+	let result = '';
+	let danglingCommaPos = null;
+	for (let i = 0; i < pseudoJson.length; i++) {
+		const currentCharacter = pseudoJson[i];
+		if (currentCharacter === '"') {
+			const escaped = isEscaped(pseudoJson, i);
+			if (!escaped) {
+				insideString = !insideString;
+			}
+		}
+		if (insideString) {
+			danglingCommaPos = null;
+			continue;
+		}
+		if (currentCharacter === ',') {
+			danglingCommaPos = i;
+			continue;
+		}
+		if (danglingCommaPos) {
+			if (currentCharacter === '}' || currentCharacter === ']') {
+				result += pseudoJson.slice(offset, danglingCommaPos) + ' ';
+				offset = danglingCommaPos + 1;
+				danglingCommaPos = null;
+			} else if (!currentCharacter.match(/\s/)) {
+				danglingCommaPos = null;
+			}
+		}
+	}
+	return result + pseudoJson.substring(offset);
 }
+
+// start strip-json-comments
+/**
+ *
+ * @param {string} jsonString
+ * @param {number} quotePosition
+ * @returns {boolean}
+ */
 function isEscaped(jsonString, quotePosition) {
-  let index = quotePosition - 1;
-  let backslashCount = 0;
-  while (jsonString[index] === "\\") {
-    index -= 1;
-    backslashCount += 1;
-  }
-  return Boolean(backslashCount % 2);
+	let index = quotePosition - 1;
+	let backslashCount = 0;
+
+	while (jsonString[index] === '\\') {
+		index -= 1;
+		backslashCount += 1;
+	}
+
+	return Boolean(backslashCount % 2);
 }
+
+/**
+ *
+ * @param {string} string
+ * @param {number?} start
+ * @param {number?} end
+ */
 function strip(string, start, end) {
-  return string.slice(start, end).replace(/\S/g, " ");
+	return string.slice(start, end).replace(/\S/g, ' ');
 }
-var singleComment = Symbol("singleComment");
-var multiComment = Symbol("multiComment");
+
+const singleComment = Symbol('singleComment');
+const multiComment = Symbol('multiComment');
+
+/**
+ * @param {string} jsonString
+ * @returns {string}
+ */
 function stripJsonComments(jsonString) {
-  let isInsideString = false;
-  let isInsideComment = false;
-  let offset = 0;
-  let result = "";
-  for (let index = 0; index < jsonString.length; index++) {
-    const currentCharacter = jsonString[index];
-    const nextCharacter = jsonString[index + 1];
-    if (!isInsideComment && currentCharacter === '"') {
-      const escaped = isEscaped(jsonString, index);
-      if (!escaped) {
-        isInsideString = !isInsideString;
-      }
-    }
-    if (isInsideString) {
-      continue;
-    }
-    if (!isInsideComment && currentCharacter + nextCharacter === "//") {
-      result += jsonString.slice(offset, index);
-      offset = index;
-      isInsideComment = singleComment;
-      index++;
-    } else if (isInsideComment === singleComment && currentCharacter + nextCharacter === "\r\n") {
-      index++;
-      isInsideComment = false;
-      result += strip(jsonString, offset, index);
-      offset = index;
-    } else if (isInsideComment === singleComment && currentCharacter === "\n") {
-      isInsideComment = false;
-      result += strip(jsonString, offset, index);
-      offset = index;
-    } else if (!isInsideComment && currentCharacter + nextCharacter === "/*") {
-      result += jsonString.slice(offset, index);
-      offset = index;
-      isInsideComment = multiComment;
-      index++;
-    } else if (isInsideComment === multiComment && currentCharacter + nextCharacter === "*/") {
-      index++;
-      isInsideComment = false;
-      result += strip(jsonString, offset, index + 1);
-      offset = index + 1;
-    }
-  }
-  return result + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+	let isInsideString = false;
+	/** @type {false | symbol} */
+	let isInsideComment = false;
+	let offset = 0;
+	let result = '';
+
+	for (let index = 0; index < jsonString.length; index++) {
+		const currentCharacter = jsonString[index];
+		const nextCharacter = jsonString[index + 1];
+
+		if (!isInsideComment && currentCharacter === '"') {
+			const escaped = isEscaped(jsonString, index);
+			if (!escaped) {
+				isInsideString = !isInsideString;
+			}
+		}
+
+		if (isInsideString) {
+			continue;
+		}
+
+		if (!isInsideComment && currentCharacter + nextCharacter === '//') {
+			result += jsonString.slice(offset, index);
+			offset = index;
+			isInsideComment = singleComment;
+			index++;
+		} else if (isInsideComment === singleComment && currentCharacter + nextCharacter === '\r\n') {
+			index++;
+			isInsideComment = false;
+			result += strip(jsonString, offset, index);
+			offset = index;
+		} else if (isInsideComment === singleComment && currentCharacter === '\n') {
+			isInsideComment = false;
+			result += strip(jsonString, offset, index);
+			offset = index;
+		} else if (!isInsideComment && currentCharacter + nextCharacter === '/*') {
+			result += jsonString.slice(offset, index);
+			offset = index;
+			isInsideComment = multiComment;
+			index++;
+		} else if (isInsideComment === multiComment && currentCharacter + nextCharacter === '*/') {
+			index++;
+			isInsideComment = false;
+			result += strip(jsonString, offset, index + 1);
+			offset = index + 1;
+		}
+	}
+
+	return result + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
 }
+// end strip-json-comments
+
+// start strip-bom
+/**
+ * @param {string} string
+ * @returns {string}
+ */
 function stripBom(string) {
-  if (string.charCodeAt(0) === 65279) {
-    return string.slice(1);
-  }
-  return string;
-}
-var POSIX_SEP_RE = new RegExp("\\" + require$$0$4.posix.sep, "g");
-var NATIVE_SEP_RE = new RegExp("\\" + require$$0$4.sep, "g");
-var PATTERN_REGEX_CACHE = /* @__PURE__ */ new Map();
-var GLOB_ALL_PATTERN = `**/*`;
-var DEFAULT_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
-var DEFAULT_EXTENSIONS_RE_GROUP = `\\.(?:${DEFAULT_EXTENSIONS.map((ext) => ext.substring(1)).join(
-  "|"
-)})`;
-new Function("path", "return import(path).then(m => m.default)");
-async function resolveTSConfig(filename) {
-  if (require$$0$4.extname(filename) !== ".json") {
-    return;
-  }
-  const tsconfig = require$$0$4.resolve(filename);
-  try {
-    const stat = await promises$1.stat(tsconfig);
-    if (stat.isFile() || stat.isFIFO()) {
-      return tsconfig;
-    }
-  } catch (e) {
-    if (e.code !== "ENOENT") {
-      throw e;
-    }
-  }
-  throw new Error(`no tsconfig file found for ${filename}`);
-}
-function posix2native(filename) {
-  return require$$0$4.posix.sep !== require$$0$4.sep && filename.includes(require$$0$4.posix.sep) ? filename.replace(POSIX_SEP_RE, require$$0$4.sep) : filename;
-}
-function native2posix(filename) {
-  return require$$0$4.posix.sep !== require$$0$4.sep && filename.includes(require$$0$4.sep) ? filename.replace(NATIVE_SEP_RE, require$$0$4.posix.sep) : filename;
-}
-function resolve2posix(dir, filename) {
-  if (require$$0$4.sep === require$$0$4.posix.sep) {
-    return dir ? require$$0$4.resolve(dir, filename) : require$$0$4.resolve(filename);
-  }
-  return native2posix(
-    dir ? require$$0$4.resolve(posix2native(dir), posix2native(filename)) : require$$0$4.resolve(posix2native(filename))
-  );
-}
-function resolveReferencedTSConfigFiles(result) {
-  const dir = require$$0$4.dirname(result.tsconfigFile);
-  return result.tsconfig.references.map((ref) => {
-    const refPath = ref.path.endsWith(".json") ? ref.path : require$$0$4.join(ref.path, "tsconfig.json");
-    return resolve2posix(dir, refPath);
-  });
-}
-function resolveSolutionTSConfig(filename, result) {
-  if (result.referenced && DEFAULT_EXTENSIONS.some((ext) => filename.endsWith(ext)) && !isIncluded(filename, result)) {
-    const solutionTSConfig = result.referenced.find(
-      (referenced) => isIncluded(filename, referenced)
-    );
-    if (solutionTSConfig) {
-      return {
-        ...solutionTSConfig,
-        solution: result
-      };
-    }
-  }
-  return result;
-}
-function isIncluded(filename, result) {
-  const dir = native2posix(require$$0$4.dirname(result.tsconfigFile));
-  const files = (result.tsconfig.files || []).map((file) => resolve2posix(dir, file));
-  const absoluteFilename = resolve2posix(null, filename);
-  if (files.includes(filename)) {
-    return true;
-  }
-  const isIncluded2 = isGlobMatch(
-    absoluteFilename,
-    dir,
-    result.tsconfig.include || (result.tsconfig.files ? [] : [GLOB_ALL_PATTERN])
-  );
-  if (isIncluded2) {
-    const isExcluded = isGlobMatch(absoluteFilename, dir, result.tsconfig.exclude || []);
-    return !isExcluded;
-  }
-  return false;
-}
-function isGlobMatch(filename, dir, patterns) {
-  return patterns.some((pattern) => {
-    let lastWildcardIndex = pattern.length;
-    let hasWildcard = false;
-    for (let i = pattern.length - 1; i > -1; i--) {
-      if (pattern[i] === "*" || pattern[i] === "?") {
-        lastWildcardIndex = i;
-        hasWildcard = true;
-        break;
-      }
-    }
-    if (lastWildcardIndex < pattern.length - 1 && !filename.endsWith(pattern.slice(lastWildcardIndex + 1))) {
-      return false;
-    }
-    if (pattern.endsWith("*") && !DEFAULT_EXTENSIONS.some((ext) => filename.endsWith(ext))) {
-      return false;
-    }
-    if (pattern === GLOB_ALL_PATTERN) {
-      return filename.startsWith(`${dir}/`);
-    }
-    const resolvedPattern = resolve2posix(dir, pattern);
-    let firstWildcardIndex = -1;
-    for (let i = 0; i < resolvedPattern.length; i++) {
-      if (resolvedPattern[i] === "*" || resolvedPattern[i] === "?") {
-        firstWildcardIndex = i;
-        hasWildcard = true;
-        break;
-      }
-    }
-    if (firstWildcardIndex > 1 && !filename.startsWith(resolvedPattern.slice(0, firstWildcardIndex - 1))) {
-      return false;
-    }
-    if (!hasWildcard) {
-      return filename === resolvedPattern;
-    }
-    if (PATTERN_REGEX_CACHE.has(resolvedPattern)) {
-      return PATTERN_REGEX_CACHE.get(resolvedPattern).test(filename);
-    }
-    const regex = pattern2regex(resolvedPattern);
-    PATTERN_REGEX_CACHE.set(resolvedPattern, regex);
-    return regex.test(filename);
-  });
-}
-function pattern2regex(resolvedPattern) {
-  let regexStr = "^";
-  for (let i = 0; i < resolvedPattern.length; i++) {
-    const char = resolvedPattern[i];
-    if (char === "?") {
-      regexStr += "[^\\/]";
-      continue;
-    }
-    if (char === "*") {
-      if (resolvedPattern[i + 1] === "*" && resolvedPattern[i + 2] === "/") {
-        i += 2;
-        regexStr += "(?:[^\\/]*\\/)*";
-        continue;
-      }
-      regexStr += "[^\\/]*";
-      continue;
-    }
-    if ("/.+^${}()|[]\\".includes(char)) {
-      regexStr += `\\`;
-    }
-    regexStr += char;
-  }
-  if (resolvedPattern.endsWith("*")) {
-    regexStr += DEFAULT_EXTENSIONS_RE_GROUP;
-  }
-  regexStr += "$";
-  return new RegExp(regexStr);
+	// Catches EFBBBF (UTF-8 BOM) because the buffer-to-string
+	// conversion translates it to FEFF (UTF-16 BOM).
+	if (string.charCodeAt(0) === 0xfeff) {
+		return string.slice(1);
+	}
+	return string;
 }
+// end strip-bom
+
+const not_found_result = {
+	tsconfigFile: null,
+	tsconfig: {}
+};
 
-// src/parse.ts
+/**
+ * parse the closest tsconfig.json file
+ *
+ * @param {string} filename - path to a tsconfig .json or a source file or directory (absolute or relative to cwd)
+ * @param {import('./public.d.ts').TSConfckParseOptions} [options] - options
+ * @returns {Promise<import('./public.d.ts').TSConfckParseResult>}
+ * @throws {TSConfckParseError}
+ */
 async function parse$f(filename, options) {
-  const cache = options == null ? void 0 : options.cache;
-  if (cache == null ? void 0 : cache.has(filename)) {
-    return cache.get(filename);
-  }
-  let tsconfigFile;
-  if (options == null ? void 0 : options.resolveWithEmptyIfConfigNotFound) {
-    try {
-      tsconfigFile = await resolveTSConfig(filename) || await find(filename, options);
-    } catch (e) {
-      const notFoundResult = {
-        tsconfigFile: "no_tsconfig_file_found",
-        tsconfig: {}
-      };
-      cache == null ? void 0 : cache.set(filename, notFoundResult);
-      return notFoundResult;
-    }
-  } else {
-    tsconfigFile = await resolveTSConfig(filename) || await find(filename, options);
-  }
-  let result;
-  if (cache == null ? void 0 : cache.has(tsconfigFile)) {
-    result = cache.get(tsconfigFile);
-  } else {
-    result = await parseFile$1(tsconfigFile, cache);
-    await Promise.all([parseExtends(result, cache), parseReferences(result, cache)]);
-    cache == null ? void 0 : cache.set(tsconfigFile, result);
-  }
-  result = resolveSolutionTSConfig(filename, result);
-  cache == null ? void 0 : cache.set(filename, result);
-  return result;
+	/** @type {import('./cache.js').TSConfckCache} */
+	const cache = options?.cache;
+	if (cache?.hasParseResult(filename)) {
+		return cache.getParseResult(filename);
+	}
+	const {
+		resolve,
+		reject,
+		/** @type {Promise<import('./public.d.ts').TSConfckParseResult>}*/
+		promise
+	} = makePromise();
+	cache?.setParseResult(filename, promise);
+	try {
+		let tsconfigFile =
+			(await resolveTSConfigJson(filename, cache)) || (await find(filename, options));
+		if (!tsconfigFile) {
+			resolve(not_found_result);
+			return promise;
+		}
+		let result;
+		if (filename !== tsconfigFile && cache?.hasParseResult(tsconfigFile)) {
+			result = await cache.getParseResult(tsconfigFile);
+		} else {
+			result = await parseFile$1(tsconfigFile, cache, filename === tsconfigFile);
+			await Promise.all([parseExtends(result, cache), parseReferences(result, cache)]);
+		}
+		resolve(resolveSolutionTSConfig(filename, result));
+		return promise;
+	} catch (e) {
+		reject(e);
+		return promise;
+	}
 }
-async function parseFile$1(tsconfigFile, cache) {
-  if (cache == null ? void 0 : cache.has(tsconfigFile)) {
-    return cache.get(tsconfigFile);
-  }
-  try {
-    const tsconfigJson = await promises$1.readFile(tsconfigFile, "utf-8");
-    const json = toJson(tsconfigJson);
-    const result = {
-      tsconfigFile,
-      tsconfig: normalizeTSConfig(JSON.parse(json), require$$0$4.dirname(tsconfigFile))
-    };
-    cache == null ? void 0 : cache.set(tsconfigFile, result);
-    return result;
-  } catch (e) {
-    throw new TSConfckParseError(
-      `parsing ${tsconfigFile} failed: ${e}`,
-      "PARSE_FILE",
-      tsconfigFile,
-      e
-    );
-  }
+
+/**
+ *
+ * @param {string} tsconfigFile - path to tsconfig file
+ * @param {import('./cache.js').TSConfckCache} [cache] - cache
+ * @param {boolean} [skipCache] - skip cache
+ * @returns {Promise<import('./public.d.ts').TSConfckParseResult>}
+ */
+async function parseFile$1(tsconfigFile, cache, skipCache) {
+	if (!skipCache && cache?.hasParseResult(tsconfigFile)) {
+		return cache.getParseResult(tsconfigFile);
+	}
+	const promise = promises$1
+		.readFile(tsconfigFile, 'utf-8')
+		.then(toJson)
+		.then((json) => {
+			return {
+				tsconfigFile,
+				tsconfig: normalizeTSConfig(JSON.parse(json), path$o.dirname(tsconfigFile))
+			};
+		})
+		.catch((e) => {
+			throw new TSConfckParseError(
+				`parsing ${tsconfigFile} failed: ${e}`,
+				'PARSE_FILE',
+				tsconfigFile,
+				e
+			);
+		});
+	if (!skipCache) {
+		cache?.setParseResult(tsconfigFile, promise);
+	}
+	return promise;
 }
+
+/**
+ * normalize to match the output of ts.parseJsonConfigFileContent
+ *
+ * @param {any} tsconfig - typescript tsconfig output
+ * @param {string} dir - directory
+ */
 function normalizeTSConfig(tsconfig, dir) {
-  var _a;
-  if (((_a = tsconfig.compilerOptions) == null ? void 0 : _a.baseUrl) && !require$$0$4.isAbsolute(tsconfig.compilerOptions.baseUrl)) {
-    tsconfig.compilerOptions.baseUrl = resolve2posix(dir, tsconfig.compilerOptions.baseUrl);
-  }
-  return tsconfig;
+	// set baseUrl to absolute path
+	if (tsconfig.compilerOptions?.baseUrl && !path$o.isAbsolute(tsconfig.compilerOptions.baseUrl)) {
+		tsconfig.compilerOptions.baseUrl = resolve2posix(dir, tsconfig.compilerOptions.baseUrl);
+	}
+	return tsconfig;
 }
+
+/**
+ *
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @param {import('./cache.js').TSConfckCache} [cache]
+ * @returns {Promise<void>}
+ */
 async function parseReferences(result, cache) {
-  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)));
-  result.referenced = referenced;
+	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)));
+	referenced.forEach((ref) => {
+		ref.solution = result;
+	});
+	result.referenced = referenced;
 }
+
+/**
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @param {import('./cache.js').TSConfckCache}[cache]
+ * @returns {Promise<void>}
+ */
 async function parseExtends(result, cache) {
-  if (!result.tsconfig.extends) {
-    return;
-  }
-  const extended = [
-    { tsconfigFile: result.tsconfigFile, tsconfig: JSON.parse(JSON.stringify(result.tsconfig)) }
-  ];
-  let pos = 0;
-  const extendsPath = [];
-  let currentBranchDepth = 0;
-  while (pos < extended.length) {
-    const extending = extended[pos];
-    extendsPath.push(extending.tsconfigFile);
-    if (extending.tsconfig.extends) {
-      currentBranchDepth += 1;
-      let resolvedExtends;
-      if (!Array.isArray(extending.tsconfig.extends)) {
-        resolvedExtends = [resolveExtends(extending.tsconfig.extends, extending.tsconfigFile)];
-      } else {
-        resolvedExtends = extending.tsconfig.extends.reverse().map((ex) => resolveExtends(ex, extending.tsconfigFile));
-      }
-      const circularExtends = resolvedExtends.find(
-        (tsconfigFile) => extendsPath.includes(tsconfigFile)
-      );
-      if (circularExtends) {
-        const circle = extendsPath.concat([circularExtends]).join(" -> ");
-        throw new TSConfckParseError(
-          `Circular dependency in "extends": ${circle}`,
-          "EXTENDS_CIRCULAR",
-          result.tsconfigFile
-        );
-      }
-      extended.splice(
-        pos + 1,
-        0,
-        ...await Promise.all(resolvedExtends.map((file) => parseFile$1(file, cache)))
-      );
-    } else {
-      extendsPath.splice(-currentBranchDepth);
-      currentBranchDepth = 0;
-    }
-    pos = pos + 1;
-  }
-  result.extended = extended;
-  for (const ext of result.extended.slice(1)) {
-    extendTSConfig(result, ext);
-  }
+	if (!result.tsconfig.extends) {
+		return;
+	}
+	// use result as first element in extended
+	// but dereference tsconfig so that mergeExtended can modify the original without affecting extended[0]
+	/** @type {import('./public.d.ts').TSConfckParseResult[]} */
+	const extended = [
+		{ tsconfigFile: result.tsconfigFile, tsconfig: JSON.parse(JSON.stringify(result.tsconfig)) }
+	];
+
+	// flatten extends graph into extended
+	let pos = 0;
+	/** @type {string[]} */
+	const extendsPath = [];
+	let currentBranchDepth = 0;
+	while (pos < extended.length) {
+		const extending = extended[pos];
+		extendsPath.push(extending.tsconfigFile);
+		if (extending.tsconfig.extends) {
+			// keep following this branch
+			currentBranchDepth += 1;
+			/** @type {string[]} */
+			let resolvedExtends;
+			if (!Array.isArray(extending.tsconfig.extends)) {
+				resolvedExtends = [resolveExtends(extending.tsconfig.extends, extending.tsconfigFile)];
+			} else {
+				// reverse because typescript 5.0 treats ['a','b','c'] as c extends b extends a
+				resolvedExtends = extending.tsconfig.extends
+					.reverse()
+					.map((ex) => resolveExtends(ex, extending.tsconfigFile));
+			}
+
+			const circularExtends = resolvedExtends.find((tsconfigFile) =>
+				extendsPath.includes(tsconfigFile)
+			);
+			if (circularExtends) {
+				const circle = extendsPath.concat([circularExtends]).join(' -> ');
+				throw new TSConfckParseError(
+					`Circular dependency in "extends": ${circle}`,
+					'EXTENDS_CIRCULAR',
+					result.tsconfigFile
+				);
+			}
+			// add new extends to the list directly after current
+			extended.splice(
+				pos + 1,
+				0,
+				...(await Promise.all(resolvedExtends.map((file) => parseFile$1(file, cache))))
+			);
+		} else {
+			// reached a leaf, backtrack to the last branching point and continue
+			extendsPath.splice(-currentBranchDepth);
+			currentBranchDepth = 0;
+		}
+		pos = pos + 1;
+	}
+	result.extended = extended;
+	// skip first as it is the original config
+	for (const ext of result.extended.slice(1)) {
+		extendTSConfig(result, ext);
+	}
 }
+
+/**
+ *
+ * @param {string} extended
+ * @param {string} from
+ * @returns {string}
+ */
 function resolveExtends(extended, from) {
-  let error;
-  try {
-    return createRequire$2(from).resolve(extended);
-  } catch (e) {
-    error = e;
-  }
-  if (!require$$0$4.isAbsolute(extended) && !extended.startsWith("./") && !extended.startsWith("../")) {
-    try {
-      const fallbackExtended = require$$0$4.join(extended, "tsconfig.json");
-      return createRequire$2(from).resolve(fallbackExtended);
-    } catch (e) {
-      error = e;
-    }
-  }
-  throw new TSConfckParseError(
-    `failed to resolve "extends":"${extended}" in ${from}`,
-    "EXTENDS_RESOLVE",
-    from,
-    error
-  );
+	let error;
+
+	try {
+		return createRequire$2(from).resolve(extended);
+	} catch (e) {
+		error = e;
+	}
+
+	if (!path$o.isAbsolute(extended) && !extended.startsWith('./') && !extended.startsWith('../')) {
+		try {
+			const fallbackExtended = path$o.join(extended, 'tsconfig.json');
+			return createRequire$2(from).resolve(fallbackExtended);
+		} catch (e) {
+			error = e;
+		}
+	}
+
+	throw new TSConfckParseError(
+		`failed to resolve "extends":"${extended}" in ${from}`,
+		'EXTENDS_RESOLVE',
+		from,
+		error
+	);
 }
-var EXTENDABLE_KEYS = [
-  "compilerOptions",
-  "files",
-  "include",
-  "exclude",
-  "watchOptions",
-  "compileOnSave",
-  "typeAcquisition",
-  "buildOptions"
+
+// references, extends and custom keys are not carried over
+const EXTENDABLE_KEYS = [
+	'compilerOptions',
+	'files',
+	'include',
+	'exclude',
+	'watchOptions',
+	'compileOnSave',
+	'typeAcquisition',
+	'buildOptions'
 ];
+
+/**
+ *
+ * @param {import('./public.d.ts').TSConfckParseResult} extending
+ * @param {import('./public.d.ts').TSConfckParseResult} extended
+ * @returns void
+ */
 function extendTSConfig(extending, extended) {
-  const extendingConfig = extending.tsconfig;
-  const extendedConfig = extended.tsconfig;
-  const relativePath = native2posix(
-    require$$0$4.relative(require$$0$4.dirname(extending.tsconfigFile), require$$0$4.dirname(extended.tsconfigFile))
-  );
-  for (const key of Object.keys(extendedConfig).filter((key2) => EXTENDABLE_KEYS.includes(key2))) {
-    if (key === "compilerOptions") {
-      if (!extendingConfig.compilerOptions) {
-        extendingConfig.compilerOptions = {};
-      }
-      for (const option of Object.keys(extendedConfig.compilerOptions)) {
-        if (Object.prototype.hasOwnProperty.call(extendingConfig.compilerOptions, option)) {
-          continue;
-        }
-        extendingConfig.compilerOptions[option] = rebaseRelative(
-          option,
-          extendedConfig.compilerOptions[option],
-          relativePath
-        );
-      }
-    } else if (extendingConfig[key] === void 0) {
-      if (key === "watchOptions") {
-        extendingConfig.watchOptions = {};
-        for (const option of Object.keys(extendedConfig.watchOptions)) {
-          extendingConfig.watchOptions[option] = rebaseRelative(
-            option,
-            extendedConfig.watchOptions[option],
-            relativePath
-          );
-        }
-      } else {
-        extendingConfig[key] = rebaseRelative(key, extendedConfig[key], relativePath);
-      }
-    }
-  }
-}
-var REBASE_KEYS = [
-  // root
-  "files",
-  "include",
-  "exclude",
-  // compilerOptions
-  "baseUrl",
-  "rootDir",
-  "rootDirs",
-  "typeRoots",
-  "outDir",
-  "outFile",
-  "declarationDir",
-  // watchOptions
-  "excludeDirectories",
-  "excludeFiles"
-];
-function rebaseRelative(key, value, prependPath) {
-  if (!REBASE_KEYS.includes(key)) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((x) => rebasePath(x, prependPath));
-  } else {
-    return rebasePath(value, prependPath);
-  }
-}
-function rebasePath(value, prependPath) {
-  if (require$$0$4.isAbsolute(value)) {
-    return value;
-  } else {
-    return require$$0$4.posix.normalize(require$$0$4.posix.join(prependPath, value));
-  }
+	const extendingConfig = extending.tsconfig;
+	const extendedConfig = extended.tsconfig;
+	const relativePath = native2posix(
+		path$o.relative(path$o.dirname(extending.tsconfigFile), path$o.dirname(extended.tsconfigFile))
+	);
+	for (const key of Object.keys(extendedConfig).filter((key) => EXTENDABLE_KEYS.includes(key))) {
+		if (key === 'compilerOptions') {
+			if (!extendingConfig.compilerOptions) {
+				extendingConfig.compilerOptions = {};
+			}
+			for (const option of Object.keys(extendedConfig.compilerOptions)) {
+				if (Object.prototype.hasOwnProperty.call(extendingConfig.compilerOptions, option)) {
+					continue; // already set
+				}
+				extendingConfig.compilerOptions[option] = rebaseRelative(
+					option,
+					extendedConfig.compilerOptions[option],
+					relativePath
+				);
+			}
+		} else if (extendingConfig[key] === undefined) {
+			if (key === 'watchOptions') {
+				extendingConfig.watchOptions = {};
+				for (const option of Object.keys(extendedConfig.watchOptions)) {
+					extendingConfig.watchOptions[option] = rebaseRelative(
+						option,
+						extendedConfig.watchOptions[option],
+						relativePath
+					);
+				}
+			} else {
+				extendingConfig[key] = rebaseRelative(key, extendedConfig[key], relativePath);
+			}
+		}
+	}
 }
-var TSConfckParseError = class _TSConfckParseError extends Error {
-  constructor(message, code, tsconfigFile, cause) {
-    super(message);
-    Object.setPrototypeOf(this, _TSConfckParseError.prototype);
-    this.name = _TSConfckParseError.name;
-    this.code = code;
-    this.cause = cause;
-    this.tsconfigFile = tsconfigFile;
-  }
-};
 
-// 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',
+const REBASE_KEYS = [
+	// root
+	'files',
+	'include',
+	'exclude',
+	// compilerOptions
+	'baseUrl',
+	'rootDir',
+	'rootDirs',
+	'typeRoots',
+	'outDir',
+	'outFile',
+	'declarationDir',
+	// watchOptions
+	'excludeDirectories',
+	'excludeFiles'
 ];
-// 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 = join$2(root, 'package.json');
-    if (!isFileReadable(path)) {
-        return false;
-    }
-    const content = JSON.parse(fs$l.readFileSync(path, 'utf-8')) || {};
-    return !!content.workspaces;
-}
-function hasRootFile(root) {
-    return ROOT_FILES.some((file) => fs$l.existsSync(join$2(root, file)));
-}
-function hasPackageJSON(root) {
-    const path = join$2(root, 'package.json');
-    return fs$l.existsSync(path);
-}
+
+/** @typedef {string | string[]} PathValue */
+
 /**
- * Search up for the nearest `package.json`
+ *
+ * @param {string} key
+ * @param {PathValue} value
+ * @param {string} prependPath
+ * @returns {PathValue}
  */
-function searchForPackageRoot(current, root = current) {
-    if (hasPackageJSON(current))
-        return current;
-    const dir = dirname$2(current);
-    // reach the fs root
-    if (!dir || dir === current)
-        return root;
-    return searchForPackageRoot(dir, root);
+function rebaseRelative(key, value, prependPath) {
+	if (!REBASE_KEYS.includes(key)) {
+		return value;
+	}
+	if (Array.isArray(value)) {
+		return value.map((x) => rebasePath(x, prependPath));
+	} else {
+		return rebasePath(value, prependPath);
+	}
 }
+
 /**
- * Search up for the nearest workspace root
+ *
+ * @param {string} value
+ * @param {string} prependPath
+ * @returns {string}
  */
-function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
-    if (hasRootFile(current))
-        return current;
-    if (hasWorkspacePackageJSON(current))
-        return current;
-    const dir = dirname$2(current);
-    // reach the fs root
-    if (!dir || dir === current)
-        return root;
-    return searchForWorkspaceRoot(dir, root);
+function rebasePath(value, prependPath) {
+	if (path$o.isAbsolute(value)) {
+		return value;
+	} else {
+		// relative paths use posix syntax in tsconfig
+		return path$o.posix.normalize(path$o.posix.join(prependPath, value));
+	}
+}
+
+class TSConfckParseError extends Error {
+	/**
+	 * error code
+	 * @type {string}
+	 */
+	code;
+	/**
+	 * error cause
+	 * @type { Error | undefined}
+	 */
+	cause;
+
+	/**
+	 * absolute path of tsconfig file where the error happened
+	 * @type {string}
+	 */
+	tsconfigFile;
+	/**
+	 *
+	 * @param {string} message - error message
+	 * @param {string} code - error code
+	 * @param {string} tsconfigFile - path to tsconfig file
+	 * @param {Error?} cause - cause of this error
+	 */
+	constructor(message, code, tsconfigFile, cause) {
+		super(message);
+		// Set the prototype explicitly.
+		Object.setPrototypeOf(this, TSConfckParseError.prototype);
+		this.name = TSConfckParseError.name;
+		this.code = code;
+		this.cause = cause;
+		this.tsconfigFile = tsconfigFile;
+	}
+}
+
+/** @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.#parsed.clear();
+	}
+
+	/**
+	 * has cached closest tsconfig for files in dir
+	 * @param {string} dir
+	 * @returns {boolean}
+	 */
+	hasTSConfigPath(dir) {
+		return this.#tsconfigPaths.has(dir);
+	}
+
+	/**
+	 * get cached closest tsconfig for files in dir
+	 * @param {string} dir
+	 * @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) {
+			return value;
+		} else {
+			throw value;
+		}
+	}
+
+	/**
+	 * has parsed tsconfig for file
+	 * @param {string} file
+	 * @returns {boolean}
+	 */
+	hasParseResult(file) {
+		return this.#parsed.has(file);
+	}
+
+	/**
+	 * get parsed tsconfig for file
+	 * @param {string} file
+	 * @returns {Promise<T>|T}
+	 * @throws {unknown} if cached value is an error
+	 */
+	getParseResult(file) {
+		const value = this.#parsed.get(file);
+		if (value.then || value.tsconfig) {
+			return value;
+		} else {
+			throw value; // cached error, rethrow
+		}
+	}
+
+	/**
+	 * @internal
+	 * @private
+	 * @param file
+	 * @param {Promise<T>} result
+	 */
+	setParseResult(file, result) {
+		this.#parsed.set(file, result);
+		result
+			.then((parsed) => {
+				if (this.#parsed.get(file) === result) {
+					this.#parsed.set(file, parsed);
+				}
+			})
+			.catch((e) => {
+				if (this.#parsed.get(file) === result) {
+					this.#parsed.set(file, e);
+				}
+			});
+	}
+
+	/**
+	 * @internal
+	 * @private
+	 * @param {string} dir
+	 * @param {Promise<string|null>} tsconfigPath
+	 */
+	setTSConfigPath(dir, tsconfigPath) {
+		this.#tsconfigPaths.set(dir, tsconfigPath);
+		tsconfigPath
+			.then((path) => {
+				if (this.#tsconfigPaths.get(dir) === tsconfigPath) {
+					this.#tsconfigPaths.set(dir, path);
+				}
+			})
+			.catch((e) => {
+				if (this.#tsconfigPaths.get(dir) === tsconfigPath) {
+					this.#tsconfigPaths.set(dir, e);
+				}
+			});
+	}
+
+	/**
+	 * map directories to their closest tsconfig.json
+	 * @internal
+	 * @private
+	 * @type{Map<string,(Promise<string|null>|string|null)>}
+	 */
+	#tsconfigPaths = new Map();
+
+	/**
+	 * map files to their parsed tsconfig result
+	 * @internal
+	 * @private
+	 * @type {Map<string,(Promise<T>|T)> }
+	 */
+	#parsed = new Map();
 }
 
-const debug$f = createDebugger('vite:esbuild');
+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;
 const validExtensionRE = /\.\w+$/;
@@ -13936,7 +14289,7 @@ async function transformWithEsbuild(code, filename, options, inMap) {
         };
     }
     catch (e) {
-        debug$f?.(`esbuild error with options used: `, resolvedOptions);
+        debug$g?.(`esbuild error with options used: `, resolvedOptions);
         // patch error information
         if (e.errors) {
             e.frame = '';
@@ -13972,7 +14325,6 @@ function esbuildPlugin(config) {
         // tree-shaking. (#9164)
         keepNames: false,
     };
-    initTSConfck(config.root);
     return {
         name: 'vite:esbuild',
         configureServer(_server) {
@@ -14019,7 +14371,6 @@ const rollupToEsbuildFormatMap = {
     iife: undefined,
 };
 const buildEsbuildPlugin = (config) => {
-    initTSConfck(config.root);
     return {
         name: 'vite:esbuild-transpile',
         async renderChunk(code, chunk, opts) {
@@ -14157,40 +14508,26 @@ function prettifyMessage(m, code) {
     }
     return res + `\n`;
 }
-let tsconfckRoot;
-let tsconfckParseOptions = { resolveWithEmptyIfConfigNotFound: true };
-function initTSConfck(root, force = false) {
-    // bail if already cached
-    if (!force && root === tsconfckRoot)
-        return;
-    const workspaceRoot = searchForWorkspaceRoot(root);
-    tsconfckRoot = root;
-    tsconfckParseOptions = initTSConfckParseOptions(workspaceRoot);
-    // cached as the options value itself when promise is resolved
-    tsconfckParseOptions.then((options) => {
-        if (root === tsconfckRoot) {
-            tsconfckParseOptions = options;
-        }
-    });
-}
-async function initTSConfckParseOptions(workspaceRoot) {
-    const start = debug$f ? performance.now() : 0;
-    const options = {
-        cache: new Map(),
-        root: workspaceRoot,
-        tsConfigPaths: new Set(await findAll(workspaceRoot, {
-            skip: (dir) => dir === 'node_modules' || dir === '.git',
-        })),
-        resolveWithEmptyIfConfigNotFound: true,
-    };
-    debug$f?.(timeFrom(start), 'tsconfck init', colors$1.dim(workspaceRoot));
-    return options;
-}
+let tsconfckCache;
 async function loadTsconfigJsonForFile(filename) {
     try {
-        const result = await parse$f(filename, await tsconfckParseOptions);
+        if (tsconfckCache) {
+            // shortcut, the cache stores resolved TSConfckParseResult
+            // so getting it from the cache directly we bypass aysnc fn call wrapping it in a promise again
+            if (tsconfckCache.hasParseResult(filename)) {
+                const result = await tsconfckCache.getParseResult(filename);
+                return result.tsconfig;
+            }
+        }
+        else {
+            tsconfckCache = new TSConfckCache();
+        }
+        const result = await parse$f(filename, {
+            cache: tsconfckCache,
+            ignoreNodeModules: true,
+        });
         // tsconfig could be out of root, make sure it is watched on dev
-        if (server && result.tsconfigFile !== 'no_tsconfig_file_found') {
+        if (server && result.tsconfigFile) {
             ensureWatchedFile(server.watcher, result.tsconfigFile, server.config.root);
         }
         return result.tsconfig;
@@ -14213,12 +14550,12 @@ async function reloadOnTsconfigChange(changedFile) {
     // any json file in the tsconfig cache could have been used to compile ts
     if (path$o.basename(changedFile) === 'tsconfig.json' ||
         (changedFile.endsWith('.json') &&
-            (await tsconfckParseOptions)?.cache?.has(changedFile))) {
+            tsconfckCache?.hasParseResult(changedFile))) {
         server.config.logger.info(`changed tsconfig file detected: ${changedFile} - Clearing cache and forcing full-reload to ensure TypeScript is compiled with updated config values.`, { clear: server.config.clearScreen, timestamp: true });
         // clear module graph to remove code compiled with outdated config
         server.moduleGraph.invalidateAll();
         // reset tsconfck so that recompile works with up2date configs
-        initTSConfck(server.config.root, true);
+        tsconfckCache.clear();
         // server may not be available if vite config is updated at the same time
         if (server) {
             // force full reload
@@ -16735,7 +17072,7 @@ var convertSourceMap$1 = {};
 
 var convertSourceMap = /*@__PURE__*/getDefaultExportFromCjs(convertSourceMap$1);
 
-const debug$e = createDebugger('vite:sourcemap', {
+const debug$f = createDebugger('vite:sourcemap', {
     onlyWhenFocused: true,
 });
 // Virtual modules should be prefixed with a null byte to avoid a
@@ -16774,7 +17111,7 @@ async function injectSourcesContent(map, file, logger) {
     // …to log the missing sources.
     if (missingSources.length) {
         logger.warnOnce(`Sourcemap for "${file}" points to missing source files`);
-        debug$e?.(`Missing sources:\n  ` + missingSources.join(`\n  `));
+        debug$f?.(`Missing sources:\n  ` + missingSources.join(`\n  `));
     }
 }
 function genSourceMapUrl(map) {
@@ -16784,7 +17121,7 @@ function genSourceMapUrl(map) {
     return `data:application/json;base64,${Buffer.from(map).toString('base64')}`;
 }
 function getCodeWithSourcemap(type, code, map) {
-    if (debug$e) {
+    if (debug$f) {
         code += `\n/*${JSON.stringify(map, null, 2).replace(/\*\//g, '*\\/')}*/\n`;
     }
     if (type === 'js') {
@@ -22503,7 +22840,7 @@ pp$8.parseForStatement = function(node) {
 
 pp$8.parseFunctionStatement = function(node, isAsync, declarationPosition) {
   this.next();
-  return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)
+  return this.parseFunction(node, FUNC_STATEMENT$1 | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)
 };
 
 pp$8.parseIfStatement = function(node) {
@@ -22773,7 +23110,7 @@ pp$8.parseVarId = function(decl, kind) {
   this.checkLValPattern(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, false);
 };
 
-var FUNC_STATEMENT = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID = 4;
+var FUNC_STATEMENT$1 = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID$1 = 4;
 
 // Parse a function declaration or literal (depending on the
 // `statement & FUNC_STATEMENT`).
@@ -22789,8 +23126,8 @@ pp$8.parseFunction = function(node, statement, allowExpressionBody, isAsync, for
   if (this.options.ecmaVersion >= 8)
     { node.async = !!isAsync; }
 
-  if (statement & FUNC_STATEMENT) {
-    node.id = (statement & FUNC_NULLABLE_ID) && this.type !== types$1.name ? null : this.parseIdent();
+  if (statement & FUNC_STATEMENT$1) {
+    node.id = (statement & FUNC_NULLABLE_ID$1) && this.type !== types$1.name ? null : this.parseIdent();
     if (node.id && !(statement & FUNC_HANGING_STATEMENT))
       // If it is a regular function declaration in sloppy mode, then it is
       // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding
@@ -22805,7 +23142,7 @@ pp$8.parseFunction = function(node, statement, allowExpressionBody, isAsync, for
   this.awaitIdentPos = 0;
   this.enterScope(functionFlags(node.async, node.generator));
 
-  if (!(statement & FUNC_STATEMENT))
+  if (!(statement & FUNC_STATEMENT$1))
     { node.id = this.type === types$1.name ? this.parseIdent() : null; }
 
   this.parseFunctionParams(node);
@@ -22814,7 +23151,7 @@ pp$8.parseFunction = function(node, statement, allowExpressionBody, isAsync, for
   this.yieldPos = oldYieldPos;
   this.awaitPos = oldAwaitPos;
   this.awaitIdentPos = oldAwaitIdentPos;
-  return this.finishNode(node, (statement & FUNC_STATEMENT) ? "FunctionDeclaration" : "FunctionExpression")
+  return this.finishNode(node, (statement & FUNC_STATEMENT$1) ? "FunctionDeclaration" : "FunctionExpression")
 };
 
 pp$8.parseFunctionParams = function(node) {
@@ -23169,7 +23506,7 @@ pp$8.parseExportDefaultDeclaration = function() {
     var fNode = this.startNode();
     this.next();
     if (isAsync) { this.next(); }
-    return this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync)
+    return this.parseFunction(fNode, FUNC_STATEMENT$1 | FUNC_NULLABLE_ID$1, false, isAsync)
   } else if (this.type === types$1._class) {
     var cNode = this.startNode();
     return this.parseClass(cNode, "nullableID")
@@ -28037,7 +28374,7 @@ const browserExternalId = '__vite-browser-external';
 const optionalPeerDepId = '__vite-optional-peer-dep';
 const subpathImportsPrefix = '#';
 const startsWithWordCharRE = /^\w/;
-const debug$d = createDebugger('vite:resolve-details', {
+const debug$e = createDebugger('vite:resolve-details', {
     onlyWhenFocused: true,
 });
 function resolvePlugin(resolveOptions) {
@@ -28106,7 +28443,7 @@ function resolvePlugin(resolveOptions) {
                 // We don't need to resolve these paths since they are already resolved
                 // always return here even if res doesn't exist since /@fs/ is explicit
                 // if the file doesn't exist it should be a 404.
-                debug$d?.(`[@fs] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
+                debug$e?.(`[@fs] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
                 return ensureVersionQuery(res, id, options, depsOptimizer);
             }
             // URL
@@ -28116,7 +28453,7 @@ function resolvePlugin(resolveOptions) {
                 (rootInRoot || !id.startsWith(withTrailingSlash(root)))) {
                 const fsPath = path$o.resolve(root, id.slice(1));
                 if ((res = tryFsResolve(fsPath, options))) {
-                    debug$d?.(`[url] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
+                    debug$e?.(`[url] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
                     return ensureVersionQuery(res, id, options, depsOptimizer);
                 }
             }
@@ -28147,7 +28484,7 @@ function resolvePlugin(resolveOptions) {
                 }
                 if ((res = tryFsResolve(fsPath, options))) {
                     res = ensureVersionQuery(res, id, options, depsOptimizer);
-                    debug$d?.(`[relative] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
+                    debug$e?.(`[relative] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
                     // If this isn't a script imported from a .html file, include side effects
                     // hints so the non-used code is properly tree-shaken during build time.
                     if (!options.idOnly &&
@@ -28170,14 +28507,14 @@ function resolvePlugin(resolveOptions) {
                 const basedir = importer ? path$o.dirname(importer) : process.cwd();
                 const fsPath = path$o.resolve(basedir, id);
                 if ((res = tryFsResolve(fsPath, options))) {
-                    debug$d?.(`[drive-relative] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
+                    debug$e?.(`[drive-relative] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
                     return ensureVersionQuery(res, id, options, depsOptimizer);
                 }
             }
             // absolute fs paths
             if (isNonDriveRelativeAbsolutePath(id) &&
                 (res = tryFsResolve(id, options))) {
-                debug$d?.(`[fs] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
+                debug$e?.(`[fs] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
                 return ensureVersionQuery(res, id, options, depsOptimizer);
             }
             // external
@@ -28223,7 +28560,7 @@ function resolvePlugin(resolveOptions) {
                     }
                     else {
                         if (!asSrc) {
-                            debug$d?.(`externalized node built-in "${id}" to empty module. ` +
+                            debug$e?.(`externalized node built-in "${id}" to empty module. ` +
                                 `(imported by: ${colors$1.white(colors$1.dim(importer))})`);
                         }
                         else if (isProduction) {
@@ -28236,7 +28573,7 @@ function resolvePlugin(resolveOptions) {
                     }
                 }
             }
-            debug$d?.(`[fallthrough] ${colors$1.dim(id)}`);
+            debug$e?.(`[fallthrough] ${colors$1.dim(id)}`);
         },
         load(id) {
             if (id.startsWith(browserExternalId)) {
@@ -28290,7 +28627,7 @@ function ensureVersionQuery(resolved, id, options, depsOptimizer) {
         // as if they would have been imported through a bare import
         // Use the original id to do the check as the resolved id may be the real
         // file path after symlinks resolution
-        const isNodeModule = isInNodeModules(id) || isInNodeModules(resolved);
+        const isNodeModule = isInNodeModules$1(id) || isInNodeModules$1(resolved);
         if (isNodeModule && !resolved.match(DEP_VERSION_RE)) {
             const versionHash = depsOptimizer.metadata.browserHash;
             if (versionHash && isOptimizable(resolved, depsOptimizer.options)) {
@@ -28309,7 +28646,7 @@ function tryFsResolve(fsPath, options, tryIndex = true, targetWeb = true, skipPa
     // source code so we only need to perform the check for dependencies.
     // We don't support `?` in node_modules paths, so we only need to check in this branch.
     const hashIndex = fsPath.indexOf('#');
-    if (hashIndex >= 0 && isInNodeModules(fsPath)) {
+    if (hashIndex >= 0 && isInNodeModules$1(fsPath)) {
         const queryIndex = fsPath.indexOf('?');
         // We only need to check foo#bar?baz and foo#bar, ignore foo?bar#baz
         if (queryIndex < 0 || queryIndex > hashIndex) {
@@ -28405,7 +28742,9 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = f
     const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
     // check for deep import, e.g. "my-lib/foo"
     const deepMatch = id.match(deepImportRE);
-    const pkgId = deepMatch ? deepMatch[1] || deepMatch[2] : id;
+    // package name doesn't include postfixes
+    // trim them to support importing package with queries (e.g. `import css from 'normalize.css?inline'`)
+    const pkgId = deepMatch ? deepMatch[1] || deepMatch[2] : cleanUrl(id);
     let basedir;
     if (dedupe?.includes(pkgId)) {
         basedir = root;
@@ -28440,7 +28779,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = f
         return;
     }
     const resolveId = deepMatch ? resolveDeepImport : resolvePackageEntry;
-    const unresolvedId = deepMatch ? '.' + id.slice(pkgId.length) : pkgId;
+    const unresolvedId = deepMatch ? '.' + id.slice(pkgId.length) : id;
     let resolved;
     try {
         resolved = resolveId(unresolvedId, pkg, targetWeb, options);
@@ -28466,7 +28805,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = f
             return resolved;
         }
         // don't external symlink packages
-        if (!allowLinkedExternal && !isInNodeModules(resolved.id)) {
+        if (!allowLinkedExternal && !isInNodeModules$1(resolved.id)) {
             return resolved;
         }
         const resolvedExt = path$o.extname(resolved.id);
@@ -28484,7 +28823,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = f
             const index = resolved.id.indexOf(id);
             if (index > -1) {
                 resolvedId = resolved.id.slice(index);
-                debug$d?.(`[processResult] ${colors$1.cyan(id)} -> ${colors$1.dim(resolvedId)}`);
+                debug$e?.(`[processResult] ${colors$1.cyan(id)} -> ${colors$1.dim(resolvedId)}`);
             }
         }
         return { ...resolved, id: resolvedId, external: true };
@@ -28500,7 +28839,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = f
     }
     const ext = path$o.extname(resolved);
     if (!options.ssrOptimizeCheck &&
-        (!isInNodeModules(resolved) || // linked
+        (!isInNodeModules$1(resolved) || // linked
             !depsOptimizer || // resolving before listening to the server
             options.scan) // initial esbuild scan phase
     ) {
@@ -28519,7 +28858,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = f
     }
     const skipOptimization = depsOptimizer?.options.noDiscovery ||
         !isJsType ||
-        (importer && isInNodeModules(importer)) ||
+        (importer && isInNodeModules$1(importer)) ||
         exclude?.includes(pkgId) ||
         exclude?.includes(id) ||
         SPECIAL_QUERY_RE.test(resolved) ||
@@ -28613,9 +28952,10 @@ async function tryOptimizedResolve(depsOptimizer, id, importer, preserveSymlinks
     }
 }
 function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache }, targetWeb, options) {
+    const { file: idWithoutPostfix, postfix } = splitFileAndPostfix(id);
     const cached = getResolvedCache('.', targetWeb);
     if (cached) {
-        return cached;
+        return cached + postfix;
     }
     try {
         let entryPoint;
@@ -28703,9 +29043,9 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
             const entryPointPath = path$o.join(dir, entry);
             const resolvedEntryPoint = tryFsResolve(entryPointPath, options, true, true, skipPackageJson);
             if (resolvedEntryPoint) {
-                debug$d?.(`[package entry] ${colors$1.cyan(id)} -> ${colors$1.dim(resolvedEntryPoint)}`);
+                debug$e?.(`[package entry] ${colors$1.cyan(idWithoutPostfix)} -> ${colors$1.dim(resolvedEntryPoint)}${postfix !== '' ? ` (postfix: ${postfix})` : ''}`);
                 setResolvedCache('.', resolvedEntryPoint, targetWeb);
-                return resolvedEntryPoint;
+                return resolvedEntryPoint + postfix;
             }
         }
     }
@@ -28787,7 +29127,7 @@ function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolv
         const resolved = tryFsResolve(path$o.join(dir, relativeId), options, !exportsField, // try index only if no exports field
         targetWeb);
         if (resolved) {
-            debug$d?.(`[node/deep-import] ${colors$1.cyan(id)} -> ${colors$1.dim(resolved)}`);
+            debug$e?.(`[node/deep-import] ${colors$1.cyan(id)} -> ${colors$1.dim(resolved)}`);
             setResolvedCache(id, resolved, targetWeb);
             return resolved;
         }
@@ -28804,7 +29144,7 @@ function tryResolveBrowserMapping(id, importer, options, isFilePath, externalize
             if ((res = bareImportRE.test(browserMappedPath)
                 ? tryNodeResolve(browserMappedPath, importer, options, true)?.id
                 : tryFsResolve(path$o.join(pkg.dir, browserMappedPath), options))) {
-                debug$d?.(`[browser mapped] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
+                debug$e?.(`[browser mapped] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
                 let result = { id: res };
                 if (options.idOnly) {
                     return result;
@@ -37284,7 +37624,7 @@ function resolveEnvPrefix({ envPrefix = 'VITE_', }) {
 }
 
 const modulePreloadPolyfillId = 'vite/modulepreload-polyfill';
-const resolvedModulePreloadPolyfillId = '\0' + modulePreloadPolyfillId;
+const resolvedModulePreloadPolyfillId = '\0' + modulePreloadPolyfillId + '.js';
 function modulePreloadPolyfillPlugin(config) {
     // `isModernFlag` is only available during build since it is resolved by `vite:build-import-analysis`
     const skip = config.command !== 'build' || config.build.ssr;
@@ -38219,7 +38559,6 @@ const commonjsProxyRE = /\?commonjs-proxy/;
 const inlineRE = /[?&]inline\b/;
 const inlineCSSRE = /[?&]inline-css\b/;
 const styleAttrRE = /[?&]style-attr\b/;
-const usedRE = /[?&]used\b/;
 const varRE = /^var\(/i;
 const cssBundleName = 'style.css';
 const isCSSRequest = (request) => CSS_LANGS_RE.test(request);
@@ -38422,8 +38761,7 @@ function cssPostPlugin(config) {
                     `const __vite__css = ${JSON.stringify(cssContent)}`,
                     `__vite__updateStyle(__vite__id, __vite__css)`,
                     // css modules exports change on edit so it can't self accept
-                    `${modulesCode ||
-                        `import.meta.hot.accept()\nexport default __vite__css`}`,
+                    `${modulesCode || 'import.meta.hot.accept()'}`,
                     `import.meta.hot.prune(() => __vite__removeStyle(__vite__id))`,
                 ].join('\n');
                 return { code, map: { mappings: '' } };
@@ -38446,24 +38784,19 @@ function cssPostPlugin(config) {
                 styles.set(id, css);
             }
             let code;
-            if (usedRE.test(id)) {
-                if (modulesCode) {
-                    code = modulesCode;
-                }
-                else {
-                    let content = css;
-                    if (config.build.cssMinify) {
-                        content = await minifyCSS(content, config, true);
-                    }
-                    code = `export default ${JSON.stringify(content)}`;
+            if (modulesCode) {
+                code = modulesCode;
+            }
+            else if (inlined) {
+                let content = css;
+                if (config.build.cssMinify) {
+                    content = await minifyCSS(content, config, true);
                 }
+                code = `export default ${JSON.stringify(content)}`;
             }
             else {
-                // if moduleCode exists return it **even if** it does not have `?used`
-                // this will disable tree-shake to work with `import './foo.module.css'` but this usually does not happen
-                // this is a limitation of the current approach by `?used` to make tree-shake work
-                // See #8936 for more details
-                code = modulesCode || `export default ''`;
+                // empty module when it's not a CSS module nor `?inline`
+                code = '';
             }
             return {
                 code,
@@ -38653,9 +38986,9 @@ function cssPostPlugin(config) {
                         // chunks instead.
                         chunk.imports = chunk.imports.filter((file) => {
                             if (pureCssChunkNames.includes(file)) {
-                                const { importedCss } = bundle[file]
-                                    .viteMetadata;
+                                const { importedCss, importedAssets } = bundle[file].viteMetadata;
                                 importedCss.forEach((file) => chunk.viteMetadata.importedCss.add(file));
+                                importedAssets.forEach((file) => chunk.viteMetadata.importedAssets.add(file));
                                 return false;
                             }
                             return true;
@@ -38980,8 +39313,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-c457d7ce.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-6db0c752.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-13ae786e.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-5c5f3875.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 /**
  * @experimental
@@ -40061,7 +40394,248 @@ function esbuildCjsExternalPlugin(externals, platform) {
     };
 }
 
-const debug$c = createDebugger('vite:ssr-external');
+const leftCurlyBrace = "{".charCodeAt(0);
+const space = " ".charCodeAt(0);
+
+const keyword = "assert";
+const FUNC_STATEMENT = 1, FUNC_NULLABLE_ID = 4;
+
+function importAssertions(Parser) {
+  // Use supplied version acorn version if present, to avoid
+  // reference mismatches due to different acorn versions. This
+  // allows this plugin to be used with Rollup which supplies
+  // its own internal version of acorn and thereby sidesteps
+  // the package manager.
+  const acorn$1 = Parser.acorn || acorn;
+  const { tokTypes: tt, TokenType } = acorn$1;
+
+  return class extends Parser {
+    constructor(...args) {
+      super(...args);
+      this.assertToken = new TokenType(keyword);
+    }
+
+    _codeAt(i) {
+      return this.input.charCodeAt(i);
+    }
+
+    _eat(t) {
+      if (this.type !== t) {
+        this.unexpected();
+      }
+      this.next();
+    }
+
+    readToken(code) {
+      let i = 0;
+      for (; i < keyword.length; i++) {
+        if (this._codeAt(this.pos + i) !== keyword.charCodeAt(i)) {
+          return super.readToken(code);
+        }
+      }
+
+      // ensure that the keyword is at the correct location
+      // ie `assert{...` or `assert {...`
+      for (;; i++) {
+        if (this._codeAt(this.pos + i) === leftCurlyBrace) {
+          // Found '{'
+          break;
+        } else if (this._codeAt(this.pos + i) === space) {
+          // white space is allowed between `assert` and `{`, so continue.
+          continue;
+        } else {
+          return super.readToken(code);
+        }
+      }
+
+      // If we're inside a dynamic import expression we'll parse
+      // the `assert` keyword as a standard object property name
+      // ie `import(""./foo.json", { assert: { type: "json" } })`
+      if (this.type.label === "{") {
+        return super.readToken(code);
+      }
+
+      this.pos += keyword.length;
+      return this.finishToken(this.assertToken);
+    }
+
+    parseDynamicImport(node) {
+      this.next(); // skip `(`
+
+      // Parse node.source.
+      node.source = this.parseMaybeAssign();
+
+      if (this.eat(tt.comma)) {
+        const obj = this.parseObj(false);
+        node.arguments = [obj];
+      }
+      this._eat(tt.parenR);
+      return this.finishNode(node, "ImportExpression");
+    }
+
+    // ported from acorn/src/statement.js pp.parseExport
+    parseExport(node, exports) {
+      this.next();
+      // export * from '...'
+      if (this.eat(tt.star)) {
+        if (this.options.ecmaVersion >= 11) {
+          if (this.eatContextual("as")) {
+            node.exported = this.parseIdent(true);
+            this.checkExport(exports, node.exported.name, this.lastTokStart);
+          } else {
+            node.exported = null;
+          }
+        }
+        this.expectContextual("from");
+        if (this.type !== tt.string) { this.unexpected(); }
+        node.source = this.parseExprAtom();
+
+        if (this.type === this.assertToken || this.type === tt._with) {
+          this.next();
+          const assertions = this.parseImportAssertions();
+          if (assertions) {
+            node.assertions = assertions;
+          }
+        }
+
+        this.semicolon();
+        return this.finishNode(node, "ExportAllDeclaration")
+      }
+      if (this.eat(tt._default)) { // export default ...
+        this.checkExport(exports, "default", this.lastTokStart);
+        var isAsync;
+        if (this.type === tt._function || (isAsync = this.isAsyncFunction())) {
+          var fNode = this.startNode();
+          this.next();
+          if (isAsync) { this.next(); }
+          node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);
+        } else if (this.type === tt._class) {
+          var cNode = this.startNode();
+          node.declaration = this.parseClass(cNode, "nullableID");
+        } else {
+          node.declaration = this.parseMaybeAssign();
+          this.semicolon();
+        }
+        return this.finishNode(node, "ExportDefaultDeclaration")
+      }
+      // export var|const|let|function|class ...
+      if (this.shouldParseExportStatement()) {
+        node.declaration = this.parseStatement(null);
+        if (node.declaration.type === "VariableDeclaration")
+          { this.checkVariableExport(exports, node.declaration.declarations); }
+        else
+          { this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }
+        node.specifiers = [];
+        node.source = null;
+      } else { // export { x, y as z } [from '...']
+        node.declaration = null;
+        node.specifiers = this.parseExportSpecifiers(exports);
+        if (this.eatContextual("from")) {
+          if (this.type !== tt.string) { this.unexpected(); }
+          node.source = this.parseExprAtom();
+
+          if (this.type === this.assertToken || this.type === tt._with) {
+            this.next();
+            const assertions = this.parseImportAssertions();
+            if (assertions) {
+              node.assertions = assertions;
+            }
+          }
+        } else {
+          for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
+            // check for keywords used as local names
+            var spec = list[i];
+
+            this.checkUnreserved(spec.local);
+            // check if export is defined
+            this.checkLocalExport(spec.local);
+          }
+
+          node.source = null;
+        }
+        this.semicolon();
+      }
+      return this.finishNode(node, "ExportNamedDeclaration")
+    }
+
+    parseImport(node) {
+      this.next();
+      // import '...'
+      if (this.type === tt.string) {
+        node.specifiers = [];
+        node.source = this.parseExprAtom();
+      } else {
+        node.specifiers = this.parseImportSpecifiers();
+        this.expectContextual("from");
+        node.source =
+          this.type === tt.string ? this.parseExprAtom() : this.unexpected();
+      }
+
+      if (this.type === this.assertToken || this.type == tt._with) {
+        this.next();
+        const assertions = this.parseImportAssertions();
+        if (assertions) {
+          node.assertions = assertions;
+        }
+      }
+      this.semicolon();
+      return this.finishNode(node, "ImportDeclaration");
+    }
+
+    parseImportAssertions() {
+      this._eat(tt.braceL);
+      const attrs = this.parseAssertEntries();
+      this._eat(tt.braceR);
+      return attrs;
+    }
+
+    parseAssertEntries() {
+      const attrs = [];
+      const attrNames = new Set();
+
+      do {
+        if (this.type === tt.braceR) {
+          break;
+        }
+
+        const node = this.startNode();
+
+        // parse AssertionKey : IdentifierName, StringLiteral
+        let assertionKeyNode;
+        if (this.type === tt.string) {
+          assertionKeyNode = this.parseLiteral(this.value);
+        } else {
+          assertionKeyNode = this.parseIdent(true);
+        }
+        this.next();
+        node.key = assertionKeyNode;
+
+        // check if we already have an entry for an attribute
+        // if a duplicate entry is found, throw an error
+        // for now this logic will come into play only when someone declares `type` twice
+        if (attrNames.has(node.key.name)) {
+          this.raise(this.pos, "Duplicated key in assertions");
+        }
+        attrNames.add(node.key.name);
+
+        if (this.type !== tt.string) {
+          this.raise(
+            this.pos,
+            "Only string is supported as an assertion value"
+          );
+        }
+
+        node.value = this.parseLiteral(this.value);
+
+        attrs.push(this.finishNode(node, "ImportAttribute"));
+      } while (this.eat(tt.comma));
+
+      return attrs;
+    }
+  };
+}
+
+const debug$d = createDebugger('vite:ssr-external');
 /**
  * Converts "parent > child" syntax to just "child"
  */
@@ -40139,7 +40713,7 @@ function createIsConfiguredAsSsrExternal(config) {
         try {
             return !!tryNodeResolve(id, 
             // Skip passing importer in build to avoid externalizing non-hoisted dependencies
-            // unresolveable from root (which would be unresolvable from output bundles also)
+            // unresolvable from root (which would be unresolvable from output bundles also)
             config.command === 'build' ? undefined : importer, resolveOptions, ssr?.target === 'webworker', undefined, true, 
             // try to externalize, will return undefined or an object without
             // a external flag if it isn't externalizable
@@ -40149,7 +40723,7 @@ function createIsConfiguredAsSsrExternal(config) {
             !!configuredAsExternal)?.external;
         }
         catch (e) {
-            debug$c?.(`Failed to node resolve "${id}". Skipping externalizing it by default.`);
+            debug$d?.(`Failed to node resolve "${id}". Skipping externalizing it by default.`);
             // may be an invalid import that's resolved by a plugin
             return false;
         }
@@ -40240,7 +40814,7 @@ function cjsSsrCollectExternals(root, resolveOptions, ssrExternals, seen, logger
             // no main entry, but deep imports may be allowed
             const pkgDir = resolvePackageData(id, root)?.dir;
             if (pkgDir) {
-                if (isInNodeModules(pkgDir)) {
+                if (isInNodeModules$1(pkgDir)) {
                     ssrExternals.add(id);
                 }
                 else {
@@ -40249,7 +40823,7 @@ function cjsSsrCollectExternals(root, resolveOptions, ssrExternals, seen, logger
                 continue;
             }
             // resolve failed, assume include
-            debug$c?.(`Failed to resolve entries for package "${id}"\n`, e);
+            debug$d?.(`Failed to resolve entries for package "${id}"\n`, e);
             continue;
         }
         // no esm entry but has require entry
@@ -40257,7 +40831,7 @@ function cjsSsrCollectExternals(root, resolveOptions, ssrExternals, seen, logger
             ssrExternals.add(id);
         }
         // trace the dependencies of linked packages
-        else if (!isInNodeModules(esmEntry)) {
+        else if (!isInNodeModules$1(esmEntry)) {
             const pkgDir = resolvePackageData(id, root)?.dir;
             if (pkgDir) {
                 depsToTrace.add(pkgDir);
@@ -40368,7 +40942,7 @@ function jsonPlugin(options = {}, isBuild) {
 
 const ERR_OPTIMIZE_DEPS_PROCESSING_ERROR = 'ERR_OPTIMIZE_DEPS_PROCESSING_ERROR';
 const ERR_OUTDATED_OPTIMIZED_DEP = 'ERR_OUTDATED_OPTIMIZED_DEP';
-const debug$b = createDebugger('vite:optimize-deps');
+const debug$c = createDebugger('vite:optimize-deps');
 function optimizedDepsPlugin(config) {
     return {
         name: 'vite:optimized-deps',
@@ -40415,7 +40989,7 @@ function optimizedDepsPlugin(config) {
                         }
                     }
                 }
-                debug$b?.(`load ${colors$1.cyan(file)}`);
+                debug$c?.(`load ${colors$1.cyan(file)}`);
                 // Load the file from the cache instead of waiting for other plugin
                 // load hooks to avoid race conditions, once processing is resolved,
                 // we are sure that the file has been properly save to disk
@@ -40478,7 +41052,7 @@ function optimizedDepsBuildPlugin(config) {
             const info = optimizedDepInfoFromFile(depsOptimizer.metadata, file);
             if (info) {
                 await info.processing;
-                debug$b?.(`load ${colors$1.cyan(file)}`);
+                debug$c?.(`load ${colors$1.cyan(file)}`);
             }
             else {
                 throw new Error(`Something unexpected happened while optimizing "${id}".`);
@@ -40836,7 +41410,7 @@ function importGlobPlugin(config) {
         async transform(code, id) {
             if (!code.includes('import.meta.glob'))
                 return;
-            const result = await transformGlobImport(code, id, config.root, (im, _, options) => this.resolve(im, id, options).then((i) => i?.id || im), config.isProduction, config.experimental.importGlobRestoreExtension);
+            const result = await transformGlobImport(code, id, config.root, (im, _, options) => this.resolve(im, id, options).then((i) => i?.id || im), config.experimental.importGlobRestoreExtension);
             if (result) {
                 if (server) {
                     const allGlobs = result.matches.map((i) => i.globsResolved);
@@ -41017,18 +41591,10 @@ async function parseImportGlob(code, importer, root, resolveId) {
 }
 const importPrefix = '__vite_glob_';
 const { basename, dirname, relative, join } = posix$1;
-const warnedCSSDefaultImportVarName = '__vite_warned_css_default_import';
-const jsonStringifyInOneline = (input) => JSON.stringify(input).replace(/[{,:]/g, '$& ').replace(/\}/g, ' }');
-const createCssDefaultImportWarning = (globs, options) => `if (!${warnedCSSDefaultImportVarName}) {` +
-    `${warnedCSSDefaultImportVarName} = true;` +
-    `console.warn(${JSON.stringify('Default import of CSS without `?inline` is deprecated. ' +
-        "Add the `{ query: '?inline' }` glob option to fix this.\n" +
-        `For example: \`import.meta.glob(${jsonStringifyInOneline(globs.length === 1 ? globs[0] : globs)}, ${jsonStringifyInOneline({ ...options, query: '?inline' })})\``)});` +
-    `}`;
 /**
  * @param optimizeExport for dynamicImportVar plugin don't need to optimize export.
  */
-async function transformGlobImport(code, id, root, resolveId, isProduction, restoreQueryExtension = false) {
+async function transformGlobImport(code, id, root, resolveId, restoreQueryExtension = false) {
     id = slash$1(id);
     root = slash$1(root);
     const isVirtual = isVirtualModule(id);
@@ -41038,7 +41604,7 @@ async function transformGlobImport(code, id, root, resolveId, isProduction, rest
     if (!matches.length)
         return null;
     const s = new MagicString(code);
-    const staticImports = (await Promise.all(matches.map(async ({ globs, globsResolved, isRelative, options, index, start, end, }) => {
+    const staticImports = (await Promise.all(matches.map(async ({ globsResolved, isRelative, options, index, start, end }) => {
         const cwd = getCommonBase(globsResolved) ?? root;
         const files = (await glob(globsResolved, {
             cwd,
@@ -41080,7 +41646,6 @@ async function transformGlobImport(code, id, root, resolveId, isProduction, rest
             }
             return { filePath, importPath };
         };
-        let includesCSS = false;
         files.forEach((file, i) => {
             const paths = resolvePaths(file);
             const filePath = paths.filePath;
@@ -41092,8 +41657,6 @@ async function transformGlobImport(code, id, root, resolveId, isProduction, rest
                     importQuery = `${importQuery}&lang.${fileExtension}`;
             }
             importPath = `${importPath}${importQuery}`;
-            const isCSS = !query && isCSSRequest(file) && !isModuleCSSRequest(file);
-            includesCSS ||= isCSS;
             const importKey = options.import && options.import !== '*'
                 ? options.import
                 : undefined;
@@ -41103,23 +41666,13 @@ async function transformGlobImport(code, id, root, resolveId, isProduction, rest
                     ? `{ ${importKey} as ${variableName} }`
                     : `* as ${variableName}`;
                 staticImports.push(`import ${expression} from ${JSON.stringify(importPath)}`);
-                if (!isProduction && isCSS) {
-                    objectProps.push(`get ${JSON.stringify(filePath)}() { ${createCssDefaultImportWarning(globs, options)} return ${variableName} }`);
-                }
-                else {
-                    objectProps.push(`${JSON.stringify(filePath)}: ${variableName}`);
-                }
+                objectProps.push(`${JSON.stringify(filePath)}: ${variableName}`);
             }
             else {
                 let importStatement = `import(${JSON.stringify(importPath)})`;
                 if (importKey)
                     importStatement += `.then(m => m[${JSON.stringify(importKey)}])`;
-                if (!isProduction && isCSS) {
-                    objectProps.push(`${JSON.stringify(filePath)}: () => { ${createCssDefaultImportWarning(globs, options)} return ${importStatement}}`);
-                }
-                else {
-                    objectProps.push(`${JSON.stringify(filePath)}: () => ${importStatement}`);
-                }
+                objectProps.push(`${JSON.stringify(filePath)}: () => ${importStatement}`);
             }
         });
         files.forEach((i) => matchedFiles.add(i));
@@ -41127,19 +41680,7 @@ async function transformGlobImport(code, id, root, resolveId, isProduction, rest
         const lineBreaks = originalLineBreakCount > 0
             ? '\n'.repeat(originalLineBreakCount)
             : '';
-        let replacement;
-        if (!isProduction && includesCSS) {
-            replacement =
-                '/* #__PURE__ */ Object.assign(' +
-                    '(() => {' +
-                    `let ${warnedCSSDefaultImportVarName} = false;` +
-                    `return {${objectProps.join(',')}${lineBreaks}};` +
-                    '})()' +
-                    ')';
-        }
-        else {
-            replacement = `/* #__PURE__ */ Object.assign({${objectProps.join(',')}${lineBreaks}})`;
-        }
+        const replacement = `/* #__PURE__ */ Object.assign({${objectProps.join(',')}${lineBreaks}})`;
         s.overwrite(start, end, replacement);
         return staticImports;
     }))).flat();
@@ -41619,7 +42160,7 @@ async function readModifiedFile(file) {
     }
 }
 
-const debug$a = createDebugger('vite:import-analysis');
+const debug$b = createDebugger('vite:import-analysis');
 const clientDir = normalizePath$3(CLIENT_DIR);
 const skipRE = /\.(?:map|json)(?:$|\?)/;
 const canSkipImportAnalysis = (id) => skipRE.test(id) || isDirectCSSRequest(id);
@@ -41737,7 +42278,7 @@ function importAnalysisPlugin(config) {
             const ssr = options?.ssr === true;
             const prettyImporter = prettifyUrl(importer, root);
             if (canSkipImportAnalysis(importer)) {
-                debug$a?.(colors$1.dim(`[skipped] ${prettyImporter}`));
+                debug$b?.(colors$1.dim(`[skipped] ${prettyImporter}`));
                 return null;
             }
             const start = performance.now();
@@ -41777,7 +42318,7 @@ function importAnalysisPlugin(config) {
             }
             if (!imports.length && !this._addedImports) {
                 importerModule.isSelfAccepting = false;
-                debug$a?.(`${timeFrom(start)} ${colors$1.dim(`[no imports] ${prettyImporter}`)}`);
+                debug$b?.(`${timeFrom(start)} ${colors$1.dim(`[no imports] ${prettyImporter}`)}`);
                 return source;
             }
             let hasHMR = false;
@@ -41965,26 +42506,6 @@ function importAnalysisPlugin(config) {
                     }
                     // normalize
                     const [url, resolvedId] = await normalizeUrl(specifier, start);
-                    if (!isDynamicImport &&
-                        specifier &&
-                        !specifier.includes('?') && // ignore custom queries
-                        isCSSRequest(resolvedId) &&
-                        !isModuleCSSRequest(resolvedId)) {
-                        const sourceExp = source.slice(expStart, start);
-                        if (sourceExp.includes('from') && // check default and named imports
-                            !sourceExp.includes('__vite_glob_') // glob handles deprecation message itself
-                        ) {
-                            const newImport = sourceExp + specifier + `?inline` + source.slice(end, expEnd);
-                            this.warn(`\n` +
-                                colors$1.cyan(importerModule.file) +
-                                `\n` +
-                                colors$1.reset(generateCodeFrame(source, start)) +
-                                `\n` +
-                                colors$1.yellow(`Default and named imports from CSS files are deprecated. ` +
-                                    `Use the ?inline query instead. ` +
-                                    `For example: ${newImport}`));
-                        }
-                    }
                     // record as safe modules
                     // safeModulesPath should not include the base prefix.
                     // See https://github.com/vitejs/vite/issues/9438#issuecomment-1465270409
@@ -42008,7 +42529,7 @@ function importAnalysisPlugin(config) {
                                 }
                             }
                             else if (needsInterop) {
-                                debug$a?.(`${url} needs interop`);
+                                debug$b?.(`${url} needs interop`);
                                 interopNamedImports(str(), importSpecifier, url, index, importer, config);
                                 rewriteDone = true;
                             }
@@ -42059,7 +42580,7 @@ function importAnalysisPlugin(config) {
                     }
                 }
                 else if (!importer.startsWith(withTrailingSlash(clientDir))) {
-                    if (!isInNodeModules(importer)) {
+                    if (!isInNodeModules$1(importer)) {
                         // check @vite-ignore which suppresses dynamic import warning
                         const hasViteIgnore = hasViteIgnoreRE.test(
                         // complete expression inside parens
@@ -42144,7 +42665,7 @@ function importAnalysisPlugin(config) {
                     handlePrunedModules(prunedImports, server);
                 }
             }
-            debug$a?.(`${timeFrom(start)} ${colors$1.dim(`[${importedUrls.size} imports rewritten] ${prettyImporter}`)}`);
+            debug$b?.(`${timeFrom(start)} ${colors$1.dim(`[${importedUrls.size} imports rewritten] ${prettyImporter}`)}`);
             if (s) {
                 return transformStableResult(s, importer, config);
             }
@@ -42379,7 +42900,7 @@ function serializeDefine(define) {
     return res + `}`;
 }
 
-const wasmHelperId = '\0vite/wasm-helper';
+const wasmHelperId = '\0vite/wasm-helper.js';
 const wasmHelper = async (opts = {}, url) => {
     let result;
     if (url.startsWith('data:')) {
@@ -42667,7 +43188,10 @@ function webWorkerPlugin(config) {
                     ? 'module'
                     : 'classic'
                 : 'module';
-            const workerTypeOption = workerType === 'classic' ? undefined : 'module';
+            const workerTypeOption = `{
+        ${workerType === 'module' ? `type: "module",` : ''}
+        name: options?.name
+      }`;
             if (isBuild) {
                 getDepsOptimizer(config, ssr)?.registerWorkersSource(id);
                 if (query.inline != null) {
@@ -42677,33 +43201,39 @@ function webWorkerPlugin(config) {
                     // Using blob URL for SharedWorker results in multiple instances of a same worker
                     workerConstructor === 'Worker'
                         ? `${encodedJs}
-          const blob = typeof window !== "undefined" && window.Blob && new Blob([atob(encodedJs)], { type: "text/javascript;charset=utf-8" });
+          const blob = typeof window !== "undefined" && window.Blob && new Blob([${workerType === 'classic'
+                            ? ''
+                            : // `URL` is always available, in `Worker[type="module"]`
+                                `'URL.revokeObjectURL(import.meta.url);'+`}atob(encodedJs)], { type: "text/javascript;charset=utf-8" });
           export default function WorkerWrapper(options) {
             let objURL;
             try {
               objURL = blob && (window.URL || window.webkitURL).createObjectURL(blob);
               if (!objURL) throw ''
-              return new ${workerConstructor}(objURL, { name: options?.name })
+              const worker = new ${workerConstructor}(objURL, ${workerTypeOption});
+              worker.addEventListener("error", () => {
+                (window.URL || window.webkitURL).revokeObjectURL(objURL);
+              });
+              return worker;
             } catch(e) {
               return new ${workerConstructor}(
                 "data:application/javascript;base64," + encodedJs,
-                {
-                  ${workerTypeOption ? `type: "${workerTypeOption}",` : ''}
-                  name: options?.name
-                }
+                ${workerTypeOption}
               );
-            } finally {
-              objURL && (window.URL || window.webkitURL).revokeObjectURL(objURL);
-            }
+            }${
+                        // For module workers, we should not revoke the URL until the worker runs,
+                        // otherwise the worker fails to run
+                        workerType === 'classic'
+                            ? ` finally {
+                    objURL && (window.URL || window.webkitURL).revokeObjectURL(objURL);
+                  }`
+                            : ''}
           }`
                         : `${encodedJs}
           export default function WorkerWrapper(options) {
             return new ${workerConstructor}(
               "data:application/javascript;base64," + encodedJs,
-              {
-                ${workerTypeOption ? `type: "${workerTypeOption}",` : ''}
-                name: options?.name
-              }
+              ${workerTypeOption}
             );
           }
           `;
@@ -42732,10 +43262,7 @@ function webWorkerPlugin(config) {
                 code: `export default function WorkerWrapper(options) {
           return new ${workerConstructor}(
             ${JSON.stringify(url)},
-            {
-              ${workerTypeOption ? `type: "${workerTypeOption}",` : ''}
-              name: options?.name
-            }
+            ${workerTypeOption}
           );
         }`,
                 map: { mappings: '' }, // Empty sourcemap to suppress Rollup warning
@@ -42824,7 +43351,7 @@ function preAliasPlugin(config) {
                             fs$l.existsSync(resolvedId) &&
                             !moduleListContains(optimizeDeps.exclude, id) &&
                             path$o.isAbsolute(resolvedId) &&
-                            (isInNodeModules(resolvedId) ||
+                            (isInNodeModules$1(resolvedId) ||
                                 optimizeDeps.include?.includes(id)) &&
                             isOptimizable(resolvedId, optimizeDeps) &&
                             !(isBuild && ssr && isConfiguredAsExternal(id, importer)) &&
@@ -43133,7 +43660,9 @@ function workerImportMetaUrlPlugin(config) {
                         builtUrl = injectQuery(builtUrl, WORKER_FILE_ID);
                         builtUrl = injectQuery(builtUrl, `type=${workerType}`);
                     }
-                    s.update(urlIndex, urlIndex + exp.length, `new URL(${JSON.stringify(builtUrl)}, self.location)`);
+                    s.update(urlIndex, urlIndex + exp.length, 
+                    // add `'' +` to skip vite:asset-import-meta-url plugin
+                    `new URL('' + ${JSON.stringify(builtUrl)}, import.meta.url)`);
                 }
                 if (s) {
                     return transformStableResult(s, id, config);
@@ -43210,11 +43739,7 @@ function assetImportMetaUrlPlugin(config) {
                                 // A hack to allow 'as' & 'query' exist at the same time
                                 query: injectQuery(queryString, 'url'),
                             };
-                            // Note: native import.meta.url is not supported in the baseline
-                            // target so we use the global location here. It can be
-                            // window.location or self.location in case it is used in a Web Worker.
-                            // @see https://developer.mozilla.org/en-US/docs/Web/API/Window/self
-                            s.update(index, index + exp.length, `new URL((import.meta.glob(${JSON.stringify(pattern)}, ${JSON.stringify(globOptions)}))[${pureUrl}], self.location)`);
+                            s.update(index, index + exp.length, `new URL((import.meta.glob(${JSON.stringify(pattern)}, ${JSON.stringify(globOptions)}))[${pureUrl}], import.meta.url)`);
                             continue;
                         }
                     }
@@ -43259,7 +43784,7 @@ function assetImportMetaUrlPlugin(config) {
                         config.logger.warnOnce(`\n${rawExp} doesn't exist at build time, it will remain unchanged to be resolved at runtime`);
                         builtUrl = url;
                     }
-                    s.update(index, index + exp.length, `new URL(${JSON.stringify(builtUrl)}, self.location)`);
+                    s.update(index, index + exp.length, `new URL(${JSON.stringify(builtUrl)}, import.meta.url)`);
                 }
                 if (s) {
                     return transformStableResult(s, id, config);
@@ -43457,7 +43982,7 @@ function dynamicImportToGlob(node, sourceString) {
   return glob;
 }
 
-const dynamicImportHelperId = '\0vite/dynamic-import-helper';
+const dynamicImportHelperId = '\0vite/dynamic-import-helper.js';
 const relativePathRE = /^\.{1,2}\//;
 // fast path to check if source contains a dynamic import. we check for a
 // trailing slash too as a dynamic import statement can have comments between
@@ -43862,7 +44387,7 @@ function throwClosedServerError() {
     // send a 504 status code request timeout
     throw err;
 }
-let parser = Parser$1;
+let parser = Parser$1.extend(importAssertions);
 async function createPluginContainer(config, moduleGraph, watcher) {
     const { plugins, logger, root, build: { rollupOptions }, } = config;
     const { getSortedPluginHooks, getSortedPlugins } = createPluginHookUtils(plugins);
@@ -44243,7 +44768,7 @@ async function createPluginContainer(config, moduleGraph, watcher) {
                     (await handleHookPromise(optionsHook.call(minimalContext, options))) || options;
             }
             if (options.acornInjectPlugins) {
-                parser = Parser$1.extend(...arraify(options.acornInjectPlugins));
+                parser = Parser$1.extend(importAssertions, ...arraify(options.acornInjectPlugins));
             }
             return {
                 acorn,
@@ -44397,7 +44922,7 @@ async function createPluginContainer(config, moduleGraph, watcher) {
     return container;
 }
 
-const debug$9 = createDebugger('vite:deps');
+const debug$a = createDebugger('vite:deps');
 const htmlTypesRE = /\.(html|vue|svelte|astro|imba)$/;
 // A simple regex to detect import sources. This is only used on
 // <script lang="ts"> blocks in vue (setup only) or svelte files, since
@@ -44427,7 +44952,7 @@ function scanImports(config) {
         }
         if (scanContext.cancelled)
             return;
-        debug$9?.(`Crawling dependencies using entries: ${entries
+        debug$a?.(`Crawling dependencies using entries: ${entries
             .map((entry) => `\n  ${colors$1.dim(entry)}`)
             .join('')}`);
         return prepareEsbuildScanner(config, entries, deps, missing, scanContext);
@@ -44480,13 +45005,13 @@ function scanImports(config) {
         throw e;
     })
         .finally(() => {
-        if (debug$9) {
+        if (debug$a) {
             const duration = (performance.now() - start).toFixed(2);
             const depsStr = Object.keys(orderedDependencies(deps))
                 .sort()
                 .map((id) => `\n  ${colors$1.cyan(id)} -> ${colors$1.dim(deps[id])}`)
                 .join('') || colors$1.dim('no dependencies found');
-            debug$9(`Scan completed in ${duration}ms: ${depsStr}`);
+            debug$a(`Scan completed in ${duration}ms: ${depsStr}`);
         }
     });
     return {
@@ -44610,7 +45135,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
         else {
             transpiledContents = contents;
         }
-        const result = await transformGlobImport(transpiledContents, id, config.root, resolve, config.isProduction);
+        const result = await transformGlobImport(transpiledContents, id, config.root, resolve);
         return result?.s.toString() || transpiledContents;
     };
     return {
@@ -44646,7 +45171,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                 // It is possible for the scanner to scan html types in node_modules.
                 // If we can optimize this html type, skip it so it's handled by the
                 // bare import resolve, and recorded as optimization dep.
-                if (isInNodeModules(resolved) &&
+                if (isInNodeModules$1(resolved) &&
                     isOptimizable(resolved, config.optimizeDeps))
                     return;
                 return {
@@ -44769,7 +45294,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                     if (shouldExternalizeDep(resolved, id)) {
                         return externalUnlessEntry({ path: id });
                     }
-                    if (isInNodeModules(resolved) || include?.includes(id)) {
+                    if (isInNodeModules$1(resolved) || include?.includes(id)) {
                         // dependency or forced included, externalize and stop crawling
                         if (isOptimizable(resolved, config.optimizeDeps)) {
                             depImports[id] = resolved;
@@ -45047,7 +45572,7 @@ function nestedResolveBasedir(id, basedir, preserveSymlinks = false) {
     return basedir;
 }
 
-const debug$8 = createDebugger('vite:deps');
+const debug$9 = createDebugger('vite:deps');
 /**
  * The amount to wait for requests to register newly found dependencies before triggering
  * a re-bundle + page reload
@@ -45183,7 +45708,7 @@ async function createDepsOptimizer(config, server) {
             depsOptimizer.scanProcessing = new Promise((resolve) => {
                 (async () => {
                     try {
-                        debug$8?.(colors$1.green(`scanning for dependencies...`));
+                        debug$9?.(colors$1.green(`scanning for dependencies...`));
                         discover = discoverProjectDependencies(config);
                         const deps = await discover.result;
                         discover = undefined;
@@ -45326,7 +45851,7 @@ async function createDepsOptimizer(config, server) {
             };
             if (!needsReload) {
                 await commitProcessing();
-                if (!debug$8) {
+                if (!debug$9) {
                     if (newDepsToLogHandle)
                         clearTimeout(newDepsToLogHandle);
                     newDepsToLogHandle = setTimeout(() => {
@@ -45335,7 +45860,7 @@ async function createDepsOptimizer(config, server) {
                     }, 2 * debounceMs);
                 }
                 else {
-                    debug$8(colors$1.green(`✨ ${!isRerun
+                    debug$9(colors$1.green(`✨ ${!isRerun
                         ? `dependencies optimized`
                         : `optimized dependencies unchanged`}`));
                 }
@@ -45347,11 +45872,11 @@ async function createDepsOptimizer(config, server) {
                     // We don't resolve the processing promise, as they will be resolved
                     // once a rerun is committed
                     processingResult.cancel();
-                    debug$8?.(colors$1.green(`✨ delaying reload as new dependencies have been found...`));
+                    debug$9?.(colors$1.green(`✨ delaying reload as new dependencies have been found...`));
                 }
                 else {
                     await commitProcessing();
-                    if (!debug$8) {
+                    if (!debug$9) {
                         if (newDepsToLogHandle)
                             clearTimeout(newDepsToLogHandle);
                         newDepsToLogHandle = undefined;
@@ -45397,7 +45922,7 @@ async function createDepsOptimizer(config, server) {
         // optimizeDeps processing is finished
         const deps = Object.keys(metadata.discovered);
         const depsString = depsLogString(deps);
-        debug$8?.(colors$1.green(`new dependencies found: ${depsString}`));
+        debug$9?.(colors$1.green(`new dependencies found: ${depsString}`));
         runOptimizer();
     }
     function getDiscoveredBrowserHash(hash, deps, missing) {
@@ -45482,7 +46007,7 @@ async function createDepsOptimizer(config, server) {
         // On build time, a missing dep appearing after onCrawlEnd is an internal error
         // On dev, switch after this point to a simple debounce strategy
         crawlEndFinder = undefined;
-        debug$8?.(colors$1.green(`✨ static imports crawl ended`));
+        debug$9?.(colors$1.green(`✨ static imports crawl ended`));
         if (closed) {
             return;
         }
@@ -45496,7 +46021,7 @@ async function createDepsOptimizer(config, server) {
             const crawlDeps = Object.keys(metadata.discovered);
             const scanDeps = Object.keys(result.metadata.optimized);
             if (scanDeps.length === 0 && crawlDeps.length === 0) {
-                debug$8?.(colors$1.green(`✨ no dependencies found by the scanner or crawling static imports`));
+                debug$9?.(colors$1.green(`✨ no dependencies found by the scanner or crawling static imports`));
                 result.cancel();
                 firstRunCalled = true;
                 return;
@@ -45514,13 +46039,13 @@ async function createDepsOptimizer(config, server) {
                     }
                 }
                 if (scannerMissedDeps) {
-                    debug$8?.(colors$1.yellow(`✨ new dependencies were found while crawling that weren't detected by the scanner`));
+                    debug$9?.(colors$1.yellow(`✨ new dependencies were found while crawling that weren't detected by the scanner`));
                 }
-                debug$8?.(colors$1.green(`✨ re-running optimizer`));
+                debug$9?.(colors$1.green(`✨ re-running optimizer`));
                 debouncedProcessing(0);
             }
             else {
-                debug$8?.(colors$1.green(`✨ using post-scan optimizer result, the scanner found every used dependency`));
+                debug$9?.(colors$1.green(`✨ using post-scan optimizer result, the scanner found every used dependency`));
                 startNextDiscoveredBatch();
                 runOptimizer(result);
             }
@@ -45529,7 +46054,7 @@ async function createDepsOptimizer(config, server) {
             const crawlDeps = Object.keys(metadata.discovered);
             currentlyProcessing = false;
             if (crawlDeps.length === 0) {
-                debug$8?.(colors$1.green(`✨ no dependencies found while crawling the static imports`));
+                debug$9?.(colors$1.green(`✨ no dependencies found while crawling the static imports`));
                 firstRunCalled = true;
             }
             else {
@@ -45660,14 +46185,14 @@ function findInteropMismatches(discovered, optimized) {
                 // This only happens when a discovered dependency has mixed ESM and CJS syntax
                 // and it hasn't been manually added to optimizeDeps.needsInterop
                 needsInteropMismatch.push(dep);
-                debug$8?.(colors$1.cyan(`✨ needsInterop mismatch detected for ${dep}`));
+                debug$9?.(colors$1.cyan(`✨ needsInterop mismatch detected for ${dep}`));
             }
         }
     }
     return needsInteropMismatch;
 }
 
-const debug$7 = createDebugger('vite:deps');
+const debug$8 = createDebugger('vite:deps');
 const jsExtensionRE = /\.js$/i;
 const jsMapExtensionRE = /\.js\.map$/i;
 /**
@@ -45675,7 +46200,7 @@ const jsMapExtensionRE = /\.js\.map$/i;
  * Used by Vite CLI when running `vite optimize`.
  */
 async function optimizeDeps(config, force = config.optimizeDeps.force, asCommand = false) {
-    const log = asCommand ? config.logger.info : debug$7;
+    const log = asCommand ? config.logger.info : debug$8;
     const ssr = config.command === 'build' && !!config.build.ssr;
     const cachedMetadata = await loadCachedDepOptimizationMetadata(config, ssr, force, asCommand);
     if (cachedMetadata) {
@@ -45738,7 +46263,7 @@ let firstLoadCachedDepOptimizationMetadata = true;
  * if it exists and pre-bundling isn't forced
  */
 async function loadCachedDepOptimizationMetadata(config, ssr, force = config.optimizeDeps.force, asCommand = false) {
-    const log = asCommand ? config.logger.info : debug$7;
+    const log = asCommand ? config.logger.info : debug$8;
     if (firstLoadCachedDepOptimizationMetadata) {
         firstLoadCachedDepOptimizationMetadata = false;
         // Fire up a clean up of stale processing deps dirs if older process exited early
@@ -45946,7 +46471,7 @@ function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.command
                     }
                 }
             }
-            debug$7?.(`Dependencies bundled in ${(performance.now() - start).toFixed(2)}ms`);
+            debug$8?.(`Dependencies bundled in ${(performance.now() - start).toFixed(2)}ms`);
             return successfulResult;
         })
             .catch((e) => {
@@ -46305,7 +46830,7 @@ async function extractExportsData(filePath, config, ssr) {
     }
     catch {
         const loader = esbuildOptions.loader?.[path$o.extname(filePath)] || 'jsx';
-        debug$7?.(`Unable to parse: ${filePath}.\n Trying again with a ${loader} transform.`);
+        debug$8?.(`Unable to parse: ${filePath}.\n Trying again with a ${loader} transform.`);
         const transformed = await transformWithEsbuild(entryContent, filePath, {
             loader,
         });
@@ -46515,7 +47040,7 @@ var index$1 = {
 const isModernFlag = `__VITE_IS_MODERN__`;
 const preloadMethod = `__vitePreload`;
 const preloadMarker = `__VITE_PRELOAD__`;
-const preloadHelperId = '\0vite/preload-helper';
+const preloadHelperId = '\0vite/preload-helper.js';
 const preloadMarkerWithQuote = new RegExp(`['"]${preloadMarker}['"]`);
 const dynamicImportPrefixRE = /import\s*\(/;
 // TODO: abstract
@@ -46649,7 +47174,7 @@ function buildImportAnalysisPlugin(config) {
             }
         },
         async transform(source, importer) {
-            if (isInNodeModules(importer) && !dynamicImportPrefixRE.test(source)) {
+            if (isInNodeModules$1(importer) && !dynamicImportPrefixRE.test(source)) {
                 return;
             }
             await init;
@@ -46760,24 +47285,6 @@ function buildImportAnalysisPlugin(config) {
                         }
                     }
                 }
-                // Differentiate CSS imports that use the default export from those that
-                // do not by injecting a ?used query - this allows us to avoid including
-                // the CSS string when unnecessary (esbuild has trouble tree-shaking
-                // them)
-                if (specifier &&
-                    isCSSRequest(specifier) &&
-                    // always inject ?used query when it is a dynamic import
-                    // because there is no way to check whether the default export is used
-                    (source.slice(expStart, start).includes('from') || isDynamicImport) &&
-                    // already has ?used query (by import.meta.glob)
-                    !specifier.match(/\?used(&|$)/) &&
-                    // don't append ?used when SPECIAL_QUERY_RE exists
-                    !specifier.match(SPECIAL_QUERY_RE) &&
-                    // edge case for package names ending with .css (e.g normalize.css)
-                    !(bareImportRE.test(specifier) && !specifier.includes('/'))) {
-                    const url = specifier.replace(/\?|$/, (m) => `?used${m ? '&' : ''}`);
-                    str().update(start, end, isDynamicImport ? `'${url}'` : url);
-                }
             }
             if (needPreloadHelper &&
                 insertPreload &&
@@ -47268,6 +47775,9 @@ function stattag (stat) {
 
 var getEtag = /*@__PURE__*/getDefaultExportFromCjs(etag_1);
 
+const debug$7 = createDebugger('vite:send', {
+    onlyWhenFocused: true,
+});
 const alias = {
     js: 'application/javascript',
     css: 'text/css',
@@ -47298,11 +47808,22 @@ function send$2(req, res, content, type, options) {
             content = getCodeWithSourcemap(type, content.toString(), map);
         }
     }
-    else {
-        if (type === 'js' && (!map || map.mappings !== '')) {
+    // 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$7?.(`Skipped injecting fallback sourcemap for ${req.url}`);
+        }
+        else {
             const urlWithoutTimestamp = removeTimestampQuery(req.url);
-            const ms = new MagicString(content.toString());
-            content = getCodeWithSourcemap(type, content.toString(), ms.generateMap({ source: urlWithoutTimestamp, hires: 'boundary' }));
+            const ms = new MagicString(code);
+            content = getCodeWithSourcemap(type, code, ms.generateMap({
+                source: path$o.basename(urlWithoutTimestamp),
+                hires: 'boundary',
+                includeContent: true,
+            }));
         }
     }
     res.statusCode = 200;
@@ -47310,6 +47831,63 @@ function send$2(req, res, content, type, options) {
     return;
 }
 
+// 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',
+];
+// 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 = join$2(root, 'package.json');
+    if (!isFileReadable(path)) {
+        return false;
+    }
+    const content = JSON.parse(fs$l.readFileSync(path, 'utf-8')) || {};
+    return !!content.workspaces;
+}
+function hasRootFile(root) {
+    return ROOT_FILES.some((file) => fs$l.existsSync(join$2(root, file)));
+}
+function hasPackageJSON(root) {
+    const path = join$2(root, 'package.json');
+    return fs$l.existsSync(path);
+}
+/**
+ * Search up for the nearest `package.json`
+ */
+function searchForPackageRoot(current, root = current) {
+    if (hasPackageJSON(current))
+        return current;
+    const dir = dirname$2(current);
+    // reach the fs root
+    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 = dirname$2(current);
+    // reach the fs root
+    if (!dir || dir === current)
+        return root;
+    return searchForWorkspaceRoot(dir, root);
+}
+
 function totalist(dir, callback, pre='') {
 	dir = resolve$3('.', dir);
 	let arr = readdirSync(dir);
@@ -55104,6 +55682,63 @@ function createConvertSourceMapReadMap(originalFileName) {
     };
 }
 
+/**
+ * @param {import('estree').Node} param
+ * @returns {string[]}
+ */
+function extract_names(param) {
+	return extract_identifiers(param).map((node) => node.name);
+}
+
+/**
+ * @param {import('estree').Node} param
+ * @param {import('estree').Identifier[]} nodes
+ * @returns {import('estree').Identifier[]}
+ */
+function extract_identifiers(param, nodes = []) {
+	switch (param.type) {
+		case 'Identifier':
+			nodes.push(param);
+			break;
+
+		case 'MemberExpression':
+			let object = param;
+			while (object.type === 'MemberExpression') {
+				object = /** @type {any} */ (object.object);
+			}
+			nodes.push(/** @type {any} */ (object));
+			break;
+
+		case 'ObjectPattern':
+			for (const prop of param.properties) {
+				if (prop.type === 'RestElement') {
+					extract_identifiers(prop.argument, nodes);
+				} else {
+					extract_identifiers(prop.value, nodes);
+				}
+			}
+
+			break;
+
+		case 'ArrayPattern':
+			for (const element of param.elements) {
+				if (element) extract_identifiers(element, nodes);
+			}
+
+			break;
+
+		case 'RestElement':
+			extract_identifiers(param.argument, nodes);
+			break;
+
+		case 'AssignmentPattern':
+			extract_identifiers(param.left, nodes);
+			break;
+	}
+
+	return nodes;
+}
+
 /**
  * @typedef { import('estree').Node} Node
  * @typedef {{
@@ -55336,71 +55971,6 @@ function walk$1(ast, { enter, leave }) {
 	return instance.visit(ast, null);
 }
 
-/**
- * @param {import('estree').Node} param
- * @returns {string[]}
- */
-function extract_names(param) {
-	return extract_identifiers(param).map(node => node.name);
-}
-
-/**
- * @param {import('estree').Node} param
- * @param {import('estree').Identifier[]} nodes
- * @returns {import('estree').Identifier[]}
- */
-function extract_identifiers(param, nodes = []) {
-	switch (param.type) {
-		case 'Identifier':
-			nodes.push(param);
-			break;
-
-		case 'MemberExpression':
-			let object = param;
-			while (object.type === 'MemberExpression') {
-				object = /** @type {any} */ (object.object);
-			}
-			nodes.push(/** @type {any} */ (object));
-			break;
-
-		case 'ObjectPattern':
-			/** @param {import('estree').Property | import('estree').RestElement} prop */
-			const handle_prop = (prop) => {
-				if (prop.type === 'RestElement') {
-					extract_identifiers(prop.argument, nodes);
-				} else {
-					extract_identifiers(prop.value, nodes);
-				}
-			};
-
-			param.properties.forEach(handle_prop);
-			break;
-
-		case 'ArrayPattern':
-			/** @param {import('estree').Node} element */
-			const handle_element = (element) => {
-				if (element) extract_identifiers(element, nodes);
-			};
-
-			param.elements.forEach((element) => {
-				if (element) {
-					handle_element(element);
-				}
-			});
-			break;
-
-		case 'RestElement':
-			extract_identifiers(param.argument, nodes);
-			break;
-
-		case 'AssignmentPattern':
-			extract_identifiers(param.left, nodes);
-			break;
-	}
-
-	return nodes;
-}
-
 const ssrModuleExportsKey = `__vite_ssr_exports__`;
 const ssrImportKey = `__vite_ssr_import__`;
 const ssrDynamicImportKey = `__vite_ssr_dynamic_import__`;
@@ -65448,7 +66018,7 @@ function resolveServerOptions(root, raw, logger) {
         ...raw,
         sourcemapIgnoreList: raw?.sourcemapIgnoreList === false
             ? () => false
-            : raw?.sourcemapIgnoreList || isInNodeModules,
+            : raw?.sourcemapIgnoreList || isInNodeModules$1,
         middlewareMode: !!raw?.middlewareMode,
     };
     let allowDirs = server.fs?.allow;
@@ -65865,6 +66435,9 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
     });
     // resolve root
     const resolvedRoot = normalizePath$3(config.root ? path$o.resolve(config.root) : process.cwd());
+    if (resolvedRoot.includes('#')) {
+        logger.warn(colors$1.yellow(`The project root contains the "#" character (${colors$1.cyan(resolvedRoot)}), which may not work when running Vite. Consider renaming the directory to remove the "#".`));
+    }
     const clientAlias = [
         {
             find: /^\/?@vite\/env/,
@@ -66086,7 +66659,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
     if (middlewareMode === 'ssr') {
         logger.warn(colors$1.yellow(`Setting server.middlewareMode to 'ssr' is deprecated, set server.middlewareMode to \`true\`${config.appType === 'custom' ? '' : ` and appType to 'custom'`} instead`));
     }
-    if (middlewareMode === 'html') {
+    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 &&
@@ -66422,4 +66995,4 @@ function isDepsOptimizerEnabled(config, ssr) {
         (command === 'serve' && disabled === 'dev'));
 }
 
-export { loadEnv as A, resolveEnvPrefix as B, colors$1 as C, getDefaultExportFromCjs as D, commonjsGlobal as E, index$1 as F, build$1 as G, index as H, preview$1 as I, preprocessCSS as a, build as b, createServer as c, resolvePackageData as d, buildErrorMessage as e, formatPostcssSourceMap as f, defineConfig as g, resolveConfig as h, isInNodeModules as i, resolveBaseUrl as j, getDepOptimizationConfig as k, loadConfigFromFile as l, isDepsOptimizerEnabled as m, normalizePath$3 as n, optimizeDeps as o, preview as p, mergeConfig as q, resolvePackageEntry as r, sortUserPlugins as s, transformWithEsbuild as t, mergeAlias as u, createFilter as v, send$2 as w, createLogger as x, searchForWorkspaceRoot as y, isFileServingAllowed as z };
+export { loadEnv as A, resolveEnvPrefix as B, colors$1 as C, getDefaultExportFromCjs as D, commonjsGlobal as E, index$1 as F, build$1 as G, index as H, preview$1 as I, preprocessCSS as a, build as b, createServer as c, resolvePackageData as d, buildErrorMessage as e, formatPostcssSourceMap as f, defineConfig as g, resolveConfig as h, isInNodeModules$1 as i, resolveBaseUrl as j, getDepOptimizationConfig as k, loadConfigFromFile as l, isDepsOptimizerEnabled as m, normalizePath$3 as n, optimizeDeps as o, preview as p, mergeConfig as q, resolvePackageEntry as r, sortUserPlugins as s, transformWithEsbuild as t, mergeAlias as u, createFilter as v, send$2 as w, createLogger as x, searchForWorkspaceRoot as y, isFileServingAllowed as z };