vite 3.1.3 → 3.2.0-beta.0

package/dist/node/chunks/{dep-557f29e6.js → dep-92763d7a.js}

@@ -1,11 +1,11 @@
 import fs$l, { promises as promises$2 } from 'node:fs';
-import path$n, { posix as posix$2, isAbsolute as isAbsolute$2, resolve as resolve$6, join as join$2, relative as relative$2, dirname as dirname$2, basename as basename$2, extname as extname$1 } from 'node:path';
+import path$n, { posix as posix$2, isAbsolute as isAbsolute$3, resolve as resolve$6, join as join$2, relative as relative$2, dirname as dirname$2, basename as basename$2, extname as extname$1 } from 'node:path';
 import { URL as URL$3, pathToFileURL, URLSearchParams, parse as parse$k } from 'node:url';
 import { performance } from 'node:perf_hooks';
 import { createRequire as createRequire$1, builtinModules } from 'node:module';
 import require$$0$3 from 'tty';
 import { transform as transform$2, build as build$3, formatMessages } from 'esbuild';
-import require$$0$4, { sep, resolve as resolve$4, posix as posix$1, relative as relative$1, basename as basename$1, extname, dirname as dirname$1, join as join$1, win32 as win32$1, isAbsolute as isAbsolute$1, normalize } from 'path';
+import require$$0$4, { sep, resolve as resolve$4, posix as posix$1, relative as relative$1, basename as basename$1, extname, dirname as dirname$1, join as join$1, win32 as win32$1, isAbsolute as isAbsolute$2, normalize } from 'path';
 import * as require$$0$2 from 'fs';
 import require$$0__default, { existsSync, readFileSync, statSync as statSync$1, promises as promises$1, readdirSync } from 'fs';
 import require$$0$5 from 'events';
@@ -22,7 +22,7 @@ import { createHash as createHash$2 } from 'node:crypto';
 import { promisify as promisify$4 } from 'node:util';
 import { promises } from 'node:dns';
 import resolve$5 from 'resolve';
-import { CLIENT_ENTRY, OPTIMIZABLE_ENTRY_RE, DEFAULT_EXTENSIONS as DEFAULT_EXTENSIONS$1, wildcardHosts, loopbackHosts, VALID_ID_PREFIX, NULL_BYTE_PLACEHOLDER, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, ENV_ENTRY, DEFAULT_MAIN_FIELDS, DEP_VERSION_RE, SPECIAL_QUERY_RE, KNOWN_ASSET_TYPES, CLIENT_DIR, JS_TYPES_RE, ESBUILD_MODULES_TARGET, VERSION, VITE_PACKAGE_DIR, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
+import { CLIENT_ENTRY, OPTIMIZABLE_ENTRY_RE, DEFAULT_EXTENSIONS as DEFAULT_EXTENSIONS$1, wildcardHosts, loopbackHosts, VALID_ID_PREFIX, NULL_BYTE_PLACEHOLDER, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, ENV_ENTRY, DEFAULT_MAIN_FIELDS, SPECIAL_QUERY_RE, DEP_VERSION_RE, KNOWN_ASSET_TYPES, CLIENT_DIR, JS_TYPES_RE, ESBUILD_MODULES_TARGET, VERSION, VITE_PACKAGE_DIR, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
 import require$$5 from 'crypto';
 import require$$0$a from 'buffer';
 import { Buffer as Buffer$1 } from 'node:buffer';
@@ -210,7 +210,7 @@ function alias$1(options = {}) {
     };
 }
 
-var picomatch$4 = {exports: {}};
+var picomatch$5 = {exports: {}};
 
 var utils$k = {};
 
@@ -1960,9 +1960,9 @@ const isObject$4 = val => val && typeof val === 'object' && !Array.isArray(val);
  * @api public
  */
 
-const picomatch$3 = (glob, options, returnState = false) => {
+const picomatch$4 = (glob, options, returnState = false) => {
   if (Array.isArray(glob)) {
-    const fns = glob.map(input => picomatch$3(input, options, returnState));
+    const fns = glob.map(input => picomatch$4(input, options, returnState));
     const arrayMatcher = str => {
       for (const isMatch of fns) {
         const state = isMatch(str);
@@ -1982,8 +1982,8 @@ const picomatch$3 = (glob, options, returnState = false) => {
   const opts = options || {};
   const posix = utils$h.isWindows(options);
   const regex = isState
-    ? picomatch$3.compileRe(glob, options)
-    : picomatch$3.makeRe(glob, options, false, true);
+    ? picomatch$4.compileRe(glob, options)
+    : picomatch$4.makeRe(glob, options, false, true);
 
   const state = regex.state;
   delete regex.state;
@@ -1991,11 +1991,11 @@ const picomatch$3 = (glob, options, returnState = false) => {
   let isIgnored = () => false;
   if (opts.ignore) {
     const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-    isIgnored = picomatch$3(opts.ignore, ignoreOpts, returnState);
+    isIgnored = picomatch$4(opts.ignore, ignoreOpts, returnState);
   }
 
   const matcher = (input, returnObject = false) => {
-    const { isMatch, match, output } = picomatch$3.test(input, regex, options, { glob, posix });
+    const { isMatch, match, output } = picomatch$4.test(input, regex, options, { glob, posix });
     const result = { glob, state, regex, posix, input, output, match, isMatch };
 
     if (typeof opts.onResult === 'function') {
@@ -2045,7 +2045,7 @@ const picomatch$3 = (glob, options, returnState = false) => {
  * @api public
  */
 
-picomatch$3.test = (input, regex, options, { glob, posix } = {}) => {
+picomatch$4.test = (input, regex, options, { glob, posix } = {}) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected input to be a string');
   }
@@ -2066,7 +2066,7 @@ picomatch$3.test = (input, regex, options, { glob, posix } = {}) => {
 
   if (match === false || opts.capture === true) {
     if (opts.matchBase === true || opts.basename === true) {
-      match = picomatch$3.matchBase(input, regex, options, posix);
+      match = picomatch$4.matchBase(input, regex, options, posix);
     } else {
       match = regex.exec(output);
     }
@@ -2089,8 +2089,8 @@ picomatch$3.test = (input, regex, options, { glob, posix } = {}) => {
  * @api public
  */
 
-picomatch$3.matchBase = (input, glob, options, posix = utils$h.isWindows(options)) => {
-  const regex = glob instanceof RegExp ? glob : picomatch$3.makeRe(glob, options);
+picomatch$4.matchBase = (input, glob, options, posix = utils$h.isWindows(options)) => {
+  const regex = glob instanceof RegExp ? glob : picomatch$4.makeRe(glob, options);
   return regex.test(path$l.basename(input));
 };
 
@@ -2111,7 +2111,7 @@ picomatch$3.matchBase = (input, glob, options, posix = utils$h.isWindows(options
  * @api public
  */
 
-picomatch$3.isMatch = (str, patterns, options) => picomatch$3(patterns, options)(str);
+picomatch$4.isMatch = (str, patterns, options) => picomatch$4(patterns, options)(str);
 
 /**
  * Parse a glob pattern to create the source string for a regular
@@ -2127,8 +2127,8 @@ picomatch$3.isMatch = (str, patterns, options) => picomatch$3(patterns, options)
  * @api public
  */
 
-picomatch$3.parse = (pattern, options) => {
-  if (Array.isArray(pattern)) return pattern.map(p => picomatch$3.parse(p, options));
+picomatch$4.parse = (pattern, options) => {
+  if (Array.isArray(pattern)) return pattern.map(p => picomatch$4.parse(p, options));
   return parse$i(pattern, { ...options, fastpaths: false });
 };
 
@@ -2159,7 +2159,7 @@ picomatch$3.parse = (pattern, options) => {
  * @api public
  */
 
-picomatch$3.scan = (input, options) => scan$1(input, options);
+picomatch$4.scan = (input, options) => scan$1(input, options);
 
 /**
  * Compile a regular expression from the `state` object returned by the
@@ -2173,7 +2173,7 @@ picomatch$3.scan = (input, options) => scan$1(input, options);
  * @api public
  */
 
-picomatch$3.compileRe = (state, options, returnOutput = false, returnState = false) => {
+picomatch$4.compileRe = (state, options, returnOutput = false, returnState = false) => {
   if (returnOutput === true) {
     return state.output;
   }
@@ -2187,7 +2187,7 @@ picomatch$3.compileRe = (state, options, returnOutput = false, returnState = fal
     source = `^(?!${source}).*$`;
   }
 
-  const regex = picomatch$3.toRegex(source, options);
+  const regex = picomatch$4.toRegex(source, options);
   if (returnState === true) {
     regex.state = state;
   }
@@ -2214,7 +2214,7 @@ picomatch$3.compileRe = (state, options, returnOutput = false, returnState = fal
  * @api public
  */
 
-picomatch$3.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+picomatch$4.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
   if (!input || typeof input !== 'string') {
     throw new TypeError('Expected a non-empty string');
   }
@@ -2229,7 +2229,7 @@ picomatch$3.makeRe = (input, options = {}, returnOutput = false, returnState = f
     parsed = parse$i(input, options);
   }
 
-  return picomatch$3.compileRe(parsed, options, returnOutput, returnState);
+  return picomatch$4.compileRe(parsed, options, returnOutput, returnState);
 };
 
 /**
@@ -2249,7 +2249,7 @@ picomatch$3.makeRe = (input, options = {}, returnOutput = false, returnState = f
  * @api public
  */
 
-picomatch$3.toRegex = (source, options) => {
+picomatch$4.toRegex = (source, options) => {
   try {
     const opts = options || {};
     return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
@@ -2264,20 +2264,20 @@ picomatch$3.toRegex = (source, options) => {
  * @return {Object}
  */
 
-picomatch$3.constants = constants$4;
+picomatch$4.constants = constants$4;
 
 /**
  * Expose "picomatch"
  */
 
-var picomatch_1 = picomatch$3;
+var picomatch_1 = picomatch$4;
 
 (function (module) {
 
 	module.exports = picomatch_1;
-} (picomatch$4));
+} (picomatch$5));
 
-var pm = /*@__PURE__*/getDefaultExportFromCjs(picomatch$4.exports);
+var picomatch$3 = /*@__PURE__*/getDefaultExportFromCjs(picomatch$5.exports);
 
 function walk$4(ast, { enter, leave }) {
 	return visit$2(ast, null, enter, leave);
@@ -2576,7 +2576,7 @@ const createFilter$2 = function createFilter(include, exclude, options) {
             test: (what) => {
                 // this refactor is a tad overly verbose but makes for easy debugging
                 const pattern = getMatcherString$1(id, resolutionBase);
-                const fn = pm(pattern, { dot: true });
+                const fn = picomatch$3(pattern, { dot: true });
                 const result = fn(what);
                 return result;
             }
@@ -4327,7 +4327,7 @@ function ownProp (obj, field) {
 var fs$i = require$$0__default;
 var path$i = require$$0$4;
 var minimatch = minimatch_1;
-var isAbsolute = pathIsAbsolute.exports;
+var isAbsolute$1 = pathIsAbsolute.exports;
 var Minimatch = minimatch.Minimatch;
 
 function alphasort (a, b) {
@@ -4415,7 +4415,7 @@ function setopts (self, pattern, options) {
 
   // TODO: is an absolute `cwd` supposed to be resolved against `root`?
   // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
-  self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
+  self.cwdAbs = isAbsolute$1(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
   if (process.platform === "win32")
     self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
   self.nomount = !!options.nomount;
@@ -4514,7 +4514,7 @@ function makeAbs (self, f) {
   var abs = f;
   if (f.charAt(0) === '/') {
     abs = path$i.join(self.root, f);
-  } else if (isAbsolute(f) || f === '') {
+  } else if (isAbsolute$1(f) || f === '') {
     abs = f;
   } else if (self.changedCwd) {
     abs = path$i.resolve(self.cwd, f);
@@ -11473,7 +11473,7 @@ const normalizePath$4 = function normalizePath(filename) {
 };
 
 function getMatcherString(id, resolutionBase) {
-    if (resolutionBase === false || isAbsolute$1(id) || id.startsWith('*')) {
+    if (resolutionBase === false || isAbsolute$2(id) || id.startsWith('*')) {
         return normalizePath$4(id);
     }
     // resolve('') is valid and will default to process.cwd()
@@ -11494,7 +11494,7 @@ const createFilter$1 = function createFilter(include, exclude, options) {
             test: (what) => {
                 // this refactor is a tad overly verbose but makes for easy debugging
                 const pattern = getMatcherString(id, resolutionBase);
-                const fn = pm(pattern, { dot: true });
+                const fn = picomatch$3(pattern, { dot: true });
                 const result = fn(what);
                 return result;
             }
@@ -11995,16 +11995,46 @@ function isFileReadable(filename) {
         return false;
     }
 }
+const splitFirstDirRE = /(.+?)[\\/](.+)/;
 /**
  * Delete every file and subdirectory. **The given directory must exist.**
- * Pass an optional `skip` array to preserve files in the root directory.
+ * Pass an optional `skip` array to preserve files under the root directory.
  */
 function emptyDir(dir, skip) {
+    const skipInDir = [];
+    let nested = null;
+    if (skip?.length) {
+        for (const file of skip) {
+            if (path$n.dirname(file) !== '.') {
+                const matched = file.match(splitFirstDirRE);
+                if (matched) {
+                    nested ?? (nested = new Map());
+                    const [, nestedDir, skipPath] = matched;
+                    let nestedSkip = nested.get(nestedDir);
+                    if (!nestedSkip) {
+                        nestedSkip = [];
+                        nested.set(nestedDir, nestedSkip);
+                    }
+                    if (!nestedSkip.includes(skipPath)) {
+                        nestedSkip.push(skipPath);
+                    }
+                }
+            }
+            else {
+                skipInDir.push(file);
+            }
+        }
+    }
     for (const file of fs$l.readdirSync(dir)) {
-        if (skip?.includes(file)) {
+        if (skipInDir.includes(file)) {
             continue;
         }
-        fs$l.rmSync(path$n.resolve(dir, file), { recursive: true, force: true });
+        if (nested?.has(file)) {
+            emptyDir(path$n.resolve(dir, file), nested.get(file));
+        }
+        else {
+            fs$l.rmSync(path$n.resolve(dir, file), { recursive: true, force: true });
+        }
     }
 }
 function copyDir(srcDir, destDir) {
@@ -13363,6 +13393,7 @@ function esbuildPlugin(options = {}) {
     // Remove optimization options for dev as we only need to transpile them,
     // and for build as the final optimization is in `buildEsbuildPlugin`
     const transformOptions = {
+        target: 'esnext',
         ...options,
         minify: false,
         minifyIdentifiers: false,
@@ -15502,7 +15533,7 @@ var braces_1 = braces$2;
 
 const util$1 = require$$0$6;
 const braces$1 = braces_1;
-const picomatch$2 = picomatch$4.exports;
+const picomatch$2 = picomatch$5.exports;
 const utils$b = utils$k;
 const isEmptyString = val => val === '' || val === './';
 
@@ -26126,11 +26157,10 @@ class Chunk {
 		this.storeName = false;
 		this.edited = false;
 
-		// we make these non-enumerable, for sanity while debugging
-		Object.defineProperties(this, {
-			previous: { writable: true, value: null },
-			next: { writable: true, value: null },
-		});
+		{
+			this.previous = null;
+			this.next = null;
+		}
 	}
 
 	appendLeft(content) {
@@ -27141,7 +27171,7 @@ class MagicString {
 		return this.original !== this.toString();
 	}
 
-	replace(searchValue, replacement) {
+	_replaceRegexp(searchValue, replacement) {
 		function getReplacement(match, str) {
 			if (typeof replacement === 'string') {
 				return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
@@ -27164,7 +27194,7 @@ class MagicString {
 			}
 			return matches;
 		}
-		if (typeof searchValue !== 'string' && searchValue.global) {
+		if (searchValue.global) {
 			const matches = matchAll(searchValue, this.original);
 			matches.forEach((match) => {
 				if (match.index != null)
@@ -27185,6 +27215,53 @@ class MagicString {
 		}
 		return this;
 	}
+
+	_replaceString(string, replacement) {
+		const { original } = this;
+		const index = original.indexOf(string);
+
+		if (index !== -1) {
+			this.overwrite(index, index + string.length, replacement);
+		}
+
+		return this;
+	}
+
+	replace(searchValue, replacement) {
+		if (typeof searchValue === 'string') {
+			return this._replaceString(searchValue, replacement);
+		}
+
+		return this._replaceRegexp(searchValue, replacement);
+	}
+
+	_replaceAllString(string, replacement) {
+		const { original } = this;
+		const stringLength = string.length;
+		for (
+			let index = original.indexOf(string);
+			index !== -1;
+			index = original.indexOf(string, index + stringLength)
+		) {
+			this.overwrite(index, index + stringLength, replacement);
+		}
+
+		return this;
+	}
+
+	replaceAll(searchValue, replacement) {
+		if (typeof searchValue === 'string') {
+			return this._replaceAllString(searchValue, replacement);
+		}
+
+		if (!searchValue.global) {
+			throw new TypeError(
+				'MagicString.prototype.replaceAll called with a non-global RegExp argument'
+			);
+		}
+
+		return this._replaceRegexp(searchValue, replacement);
+	}
 }
 
 const isDebug$6 = !!process.env.DEBUG;
@@ -32874,7 +32951,7 @@ function stripLiteralAcorn(code) {
 }
 
 const multilineCommentsRE = /\/\*.*?\*\//gms;
-const singlelineCommentsRE = /\/\/.*$/gm;
+const singlelineCommentsRE = /(?:^|\n|\r)\s*\/\/.*(?:\r|\n|$)/gm;
 const templateLiteralRE = /\$\{(\s*(?:(?!\$\{).|\n|\r)*?\s*)\}/g;
 const quotesRE = [
   /(["'`])((?:\\\1|(?!\1)|.|\r)*?)\1/gm,
@@ -33322,6 +33399,7 @@ function lookup(extn) {
 }
 
 const assetUrlRE = /__VITE_ASSET__([a-z\d]{8})__(?:\$_(.*?)__)?/g;
+const duplicateAssets = new WeakMap();
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
 const assetCache = new WeakMap();
@@ -33340,6 +33418,7 @@ function registerCustomMime() {
     mimes$1['eot'] = 'application/vnd.ms-fontobject';
 }
 function renderAssetUrlInJS(ctx, config, chunk, opts, code) {
+    const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(opts.format);
     let match;
     let s;
     // Urls added with JS using e.g.
@@ -33355,7 +33434,7 @@ function renderAssetUrlInJS(ctx, config, chunk, opts, code) {
         const file = getAssetFilename(hash, config) || ctx.getFileName(hash);
         chunk.viteMetadata.importedAssets.add(cleanUrl(file));
         const filename = file + postfix;
-        const replacement = toOutputFilePathInString(filename, 'asset', chunk.fileName, 'js', config, opts.format);
+        const replacement = toOutputFilePathInJS(filename, 'asset', chunk.fileName, 'js', config, toRelativeRuntime);
         const replacementString = typeof replacement === 'string'
             ? JSON.stringify(replacement).slice(1, -1)
             : `"+${replacement.runtime}+"`;
@@ -33369,7 +33448,7 @@ function renderAssetUrlInJS(ctx, config, chunk, opts, code) {
         s || (s = new MagicString(code));
         const [full, hash] = match;
         const publicUrl = publicAssetUrlMap.get(hash).slice(1);
-        const replacement = toOutputFilePathInString(publicUrl, 'public', chunk.fileName, 'js', config, opts.format);
+        const replacement = toOutputFilePathInJS(publicUrl, 'public', chunk.fileName, 'js', config, toRelativeRuntime);
         const replacementString = typeof replacement === 'string'
             ? JSON.stringify(replacement).slice(1, -1)
             : `"+${replacement.runtime}+"`;
@@ -33391,6 +33470,7 @@ function assetPlugin(config) {
         buildStart() {
             assetCache.set(config, new Map());
             emittedHashMap.set(config, new Set());
+            duplicateAssets.set(config, new Map());
         },
         resolveId(id) {
             if (!config.assetsInclude(cleanUrl(id))) {
@@ -33650,8 +33730,9 @@ async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false
             map.set(contentHash, fileName);
         }
         const emittedSet = emittedHashMap.get(config);
+        const duplicates = duplicateAssets.get(config);
+        const name = normalizePath$3(path$n.relative(config.root, file));
         if (!emittedSet.has(contentHash)) {
-            const name = normalizePath$3(path$n.relative(config.root, file));
             pluginContext.emitFile({
                 name,
                 fileName,
@@ -33660,6 +33741,15 @@ async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false
             });
             emittedSet.add(contentHash);
         }
+        else {
+            duplicates.set(name, {
+                name,
+                fileName: map.get(contentHash),
+                type: 'asset',
+                source: content,
+                isAsset: true
+            });
+        }
         url = `__VITE_ASSET__${contentHash}__${postfix ? `$_${postfix}__` : ``}`; // TODO_BASE
     }
     cache.set(id, url);
@@ -34183,6 +34273,284 @@ function watchPackageDataPlugin(config) {
     };
 }
 
+const WORKER_FILE_ID = 'worker_file';
+const workerCache = new WeakMap();
+function isWorkerRequest(id) {
+    const query = parseRequest(id);
+    if (query && query[WORKER_FILE_ID] != null) {
+        return true;
+    }
+    return false;
+}
+function saveEmitWorkerAsset(config, asset) {
+    const fileName = asset.fileName;
+    const workerMap = workerCache.get(config.mainConfig || config);
+    workerMap.assets.set(fileName, asset);
+}
+async function bundleWorkerEntry(config, id, query) {
+    // bundle the file as entry to support imports
+    const { rollup } = await import('rollup');
+    const { plugins, rollupOptions, format } = config.worker;
+    const bundle = await rollup({
+        ...rollupOptions,
+        input: cleanUrl(id),
+        plugins,
+        onwarn(warning, warn) {
+            onRollupWarning(warning, warn, config);
+        },
+        preserveEntrySignatures: false
+    });
+    let chunk;
+    try {
+        const workerOutputConfig = config.worker.rollupOptions.output;
+        const workerConfig = workerOutputConfig
+            ? Array.isArray(workerOutputConfig)
+                ? workerOutputConfig[0] || {}
+                : workerOutputConfig
+            : {};
+        const { output: [outputChunk, ...outputChunks] } = await bundle.generate({
+            entryFileNames: path$n.posix.join(config.build.assetsDir, '[name].[hash].js'),
+            chunkFileNames: path$n.posix.join(config.build.assetsDir, '[name].[hash].js'),
+            assetFileNames: path$n.posix.join(config.build.assetsDir, '[name].[hash].[ext]'),
+            ...workerConfig,
+            format,
+            sourcemap: config.build.sourcemap
+        });
+        chunk = outputChunk;
+        outputChunks.forEach((outputChunk) => {
+            if (outputChunk.type === 'asset') {
+                saveEmitWorkerAsset(config, outputChunk);
+            }
+            else if (outputChunk.type === 'chunk') {
+                saveEmitWorkerAsset(config, {
+                    fileName: outputChunk.fileName,
+                    source: outputChunk.code,
+                    type: 'asset'
+                });
+            }
+        });
+    }
+    finally {
+        await bundle.close();
+    }
+    return emitSourcemapForWorkerEntry(config, query, chunk);
+}
+function emitSourcemapForWorkerEntry(config, query, chunk) {
+    const { map: sourcemap } = chunk;
+    if (sourcemap) {
+        if (config.build.sourcemap === 'inline') {
+            // Manually add the sourcemap to the code if configured for inline sourcemaps.
+            // TODO: Remove when https://github.com/rollup/rollup/issues/3913 is resolved
+            // Currently seems that it won't be resolved until Rollup 3
+            const dataUrl = sourcemap.toUrl();
+            chunk.code += `//# sourceMappingURL=${dataUrl}`;
+        }
+        else if (config.build.sourcemap === 'hidden' ||
+            config.build.sourcemap === true) {
+            const data = sourcemap.toString();
+            const mapFileName = chunk.fileName + '.map';
+            saveEmitWorkerAsset(config, {
+                fileName: mapFileName,
+                type: 'asset',
+                source: data
+            });
+            // Emit the comment that tells the JS debugger where it can find the
+            // sourcemap file.
+            // 'hidden' causes the sourcemap file to be created but
+            // the comment in the file to be omitted.
+            if (config.build.sourcemap === true) {
+                // inline web workers need to use the full sourcemap path
+                // non-inline web workers can use a relative path
+                const sourceMapUrl = query?.inline != null
+                    ? mapFileName
+                    : path$n.relative(config.build.assetsDir, mapFileName);
+                chunk.code += `//# sourceMappingURL=${sourceMapUrl}`;
+            }
+        }
+    }
+    return chunk;
+}
+const workerAssetUrlRE = /__VITE_WORKER_ASSET__([a-z\d]{8})__/g;
+function encodeWorkerAssetFileName(fileName, workerCache) {
+    const { fileNameHash } = workerCache;
+    const hash = getHash(fileName);
+    if (!fileNameHash.get(hash)) {
+        fileNameHash.set(hash, fileName);
+    }
+    return `__VITE_WORKER_ASSET__${hash}__`;
+}
+async function workerFileToUrl(config, id, query) {
+    const workerMap = workerCache.get(config.mainConfig || config);
+    let fileName = workerMap.bundle.get(id);
+    if (!fileName) {
+        const outputChunk = await bundleWorkerEntry(config, id, query);
+        fileName = outputChunk.fileName;
+        saveEmitWorkerAsset(config, {
+            fileName,
+            source: outputChunk.code,
+            type: 'asset'
+        });
+        workerMap.bundle.set(id, fileName);
+    }
+    return encodeWorkerAssetFileName(fileName, workerMap);
+}
+function webWorkerPlugin(config) {
+    const isBuild = config.command === 'build';
+    let server;
+    const isWorker = config.isWorker;
+    return {
+        name: 'vite:worker',
+        configureServer(_server) {
+            server = _server;
+        },
+        buildStart() {
+            if (isWorker) {
+                return;
+            }
+            workerCache.set(config, {
+                assets: new Map(),
+                bundle: new Map(),
+                fileNameHash: new Map()
+            });
+        },
+        load(id) {
+            if (isBuild) {
+                const parsedQuery = parseRequest(id);
+                if (parsedQuery &&
+                    (parsedQuery.worker ?? parsedQuery.sharedworker) != null) {
+                    return '';
+                }
+            }
+        },
+        async transform(raw, id, options) {
+            const ssr = options?.ssr === true;
+            const query = parseRequest(id);
+            if (query && query[WORKER_FILE_ID] != null) {
+                // if import worker by worker constructor will have query.type
+                // other type will be import worker by esm
+                const workerType = query['type'];
+                let injectEnv = '';
+                if (workerType === 'classic') {
+                    injectEnv = `importScripts('${ENV_PUBLIC_PATH}')\n`;
+                }
+                else if (workerType === 'module') {
+                    injectEnv = `import '${ENV_PUBLIC_PATH}'\n`;
+                }
+                else if (workerType === 'ignore') {
+                    if (isBuild) {
+                        injectEnv = '';
+                    }
+                    else if (server) {
+                        // dynamic worker type we can't know how import the env
+                        // so we copy /@vite/env code of server transform result into file header
+                        const { moduleGraph } = server;
+                        const module = moduleGraph.getModuleById(ENV_ENTRY);
+                        injectEnv = module?.transformResult?.code || '';
+                    }
+                }
+                return {
+                    code: injectEnv + raw
+                };
+            }
+            if (query == null ||
+                (query && (query.worker ?? query.sharedworker) == null)) {
+                return;
+            }
+            // stringified url or `new URL(...)`
+            let url;
+            const { format } = config.worker;
+            const workerConstructor = query.sharedworker != null ? 'SharedWorker' : 'Worker';
+            const workerType = isBuild
+                ? format === 'es'
+                    ? 'module'
+                    : 'classic'
+                : 'module';
+            const workerOptions = workerType === 'classic' ? '' : ',{type: "module"}';
+            if (isBuild) {
+                getDepsOptimizer(config, ssr)?.registerWorkersSource(id);
+                if (query.inline != null) {
+                    const chunk = await bundleWorkerEntry(config, id, query);
+                    // inline as blob data url
+                    return {
+                        code: `const encodedJs = "${Buffer.from(chunk.code).toString('base64')}";
+            const blob = typeof window !== "undefined" && window.Blob && new Blob([atob(encodedJs)], { type: "text/javascript;charset=utf-8" });
+            export default function WorkerWrapper() {
+              const objURL = blob && (window.URL || window.webkitURL).createObjectURL(blob);
+              try {
+                return objURL ? new ${workerConstructor}(objURL) : new ${workerConstructor}("data:application/javascript;base64," + encodedJs${workerOptions});
+              } finally {
+                objURL && (window.URL || window.webkitURL).revokeObjectURL(objURL);
+              }
+            }`,
+                        // Empty sourcemap to suppress Rollup warning
+                        map: { mappings: '' }
+                    };
+                }
+                else {
+                    url = await workerFileToUrl(config, id, query);
+                }
+            }
+            else {
+                url = await fileToUrl(cleanUrl(id), config, this);
+                url = injectQuery(url, WORKER_FILE_ID);
+                url = injectQuery(url, `type=${workerType}`);
+            }
+            if (query.url != null) {
+                return {
+                    code: `export default ${JSON.stringify(url)}`,
+                    map: { mappings: '' } // Empty sourcemap to suppress Rollup warning
+                };
+            }
+            return {
+                code: `export default function WorkerWrapper() {
+          return new ${workerConstructor}(${JSON.stringify(url)}${workerOptions})
+        }`,
+                map: { mappings: '' } // Empty sourcemap to suppress Rollup warning
+            };
+        },
+        renderChunk(code, chunk, outputOptions) {
+            let s;
+            const result = () => {
+                return (s && {
+                    code: s.toString(),
+                    map: config.build.sourcemap ? s.generateMap({ hires: true }) : null
+                });
+            };
+            if (code.match(workerAssetUrlRE) || code.includes('import.meta.url')) {
+                const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(outputOptions.format);
+                let match;
+                s = new MagicString(code);
+                // Replace "__VITE_WORKER_ASSET__5aa0ddc0__" using relative paths
+                const workerMap = workerCache.get(config.mainConfig || config);
+                const { fileNameHash } = workerMap;
+                while ((match = workerAssetUrlRE.exec(code))) {
+                    const [full, hash] = match;
+                    const filename = fileNameHash.get(hash);
+                    const replacement = toOutputFilePathInJS(filename, 'asset', chunk.fileName, 'js', config, toRelativeRuntime);
+                    const replacementString = typeof replacement === 'string'
+                        ? JSON.stringify(replacement).slice(1, -1)
+                        : `"+${replacement.runtime}+"`;
+                    s.overwrite(match.index, match.index + full.length, replacementString, {
+                        contentOnly: true
+                    });
+                }
+            }
+            return result();
+        },
+        generateBundle(opts) {
+            // @ts-ignore asset emits are skipped in legacy bundle
+            if (opts.__vite_skip_asset_emit__ || isWorker) {
+                return;
+            }
+            const workerMap = workerCache.get(config);
+            workerMap.assets.forEach((asset) => {
+                this.emitFile(asset);
+                workerMap.assets.delete(asset.fileName);
+            });
+        }
+    };
+}
+
 const normalizedClientEntry$1 = normalizePath$3(CLIENT_ENTRY);
 const normalizedEnvEntry$1 = normalizePath$3(ENV_ENTRY);
 // special id for paths marked with browser: false
@@ -34217,12 +34585,15 @@ function resolvePlugin(resolveOptions) {
                 scan: resolveOpts?.scan ?? resolveOptions.scan
             };
             if (importer) {
-                if (isTsRequest(importer) ||
+                const _importer = isWorkerRequest(importer)
+                    ? splitFileAndPostfix(importer).file
+                    : importer;
+                if (isTsRequest(_importer) ||
                     resolveOpts.custom?.depScan?.loader?.startsWith('ts')) {
                     options.isFromTsImporter = true;
                 }
                 else {
-                    const moduleLang = this.getModuleInfo(importer)?.meta?.vite?.lang;
+                    const moduleLang = this.getModuleInfo(_importer)?.meta?.vite?.lang;
                     options.isFromTsImporter = moduleLang && isTsRequest(`.${moduleLang}`);
                 }
             }
@@ -34293,6 +34664,7 @@ function resolvePlugin(resolveOptions) {
                     return normalizedFsPath;
                 }
                 if (targetWeb &&
+                    options.browserField &&
                     (res = tryResolveBrowserMapping(fsPath, importer, options, true))) {
                     return res;
                 }
@@ -34350,6 +34722,7 @@ function resolvePlugin(resolveOptions) {
                     return res;
                 }
                 if (targetWeb &&
+                    options.browserField &&
                     (res = tryResolveBrowserMapping(id, importer, options, false, external))) {
                     return res;
                 }
@@ -34437,7 +34810,7 @@ function tryFsResolve(fsPath, options, tryIndex = true, targetWeb = true) {
     if ((res = tryResolveFile(file, postfix, options, false, targetWeb, options.tryPrefix, options.skipPackageJson))) {
         return res;
     }
-    for (const ext of options.extensions || DEFAULT_EXTENSIONS$1) {
+    for (const ext of options.extensions) {
         if (postfix &&
             (res = tryResolveFile(fsPath + ext, '', options, false, targetWeb, options.tryPrefix, options.skipPackageJson))) {
             return res;
@@ -34617,7 +34990,9 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
         let resolvedId = id;
         if (isDeepImport) {
             if (!pkg?.data.exports && path$n.extname(id) !== resolvedExt) {
-                resolvedId += resolvedExt;
+                resolvedId = resolved.id.slice(resolved.id.indexOf(id));
+                isDebug$4 &&
+                    debug$c(`[processResult] ${picocolors.exports.cyan(id)} -> ${picocolors.exports.dim(resolvedId)}`);
             }
         }
         return { ...resolved, id: resolvedId, external: true };
@@ -34758,7 +35133,9 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
         // This is because .mjs files can technically import .cjs files which would
         // make them invalid for pure ESM environments - so if other module/browser
         // fields are present, prioritize those instead.
-        if (targetWeb && (!entryPoint || entryPoint.endsWith('.mjs'))) {
+        if (targetWeb &&
+            options.browserField &&
+            (!entryPoint || entryPoint.endsWith('.mjs'))) {
             // check browser field
             // https://github.com/defunctzombie/package-browser-field-spec
             const browserEntry = typeof data.browser === 'string'
@@ -34767,6 +35144,7 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
             if (browserEntry) {
                 // check if the package also has a "module" field.
                 if (!options.isRequire &&
+                    options.mainFields.includes('module') &&
                     typeof data.module === 'string' &&
                     data.module !== browserEntry) {
                     // if both are present, we may have a problem: some package points both
@@ -34794,7 +35172,9 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
             }
         }
         if (!entryPoint || entryPoint.endsWith('.mjs')) {
-            for (const field of options.mainFields || DEFAULT_MAIN_FIELDS) {
+            for (const field of options.mainFields) {
+                if (field === 'browser')
+                    continue; // already checked above
                 if (typeof data[field] === 'string') {
                     entryPoint = data[field];
                     break;
@@ -34809,14 +35189,14 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
             : ['index.js', 'index.json', 'index.node'];
         for (let entry of entryPoints) {
             // make sure we don't get scripts when looking for sass
-            if (options.mainFields?.[0] === 'sass' &&
-                !options.extensions?.includes(path$n.extname(entry))) {
+            if (options.mainFields[0] === 'sass' &&
+                !options.extensions.includes(path$n.extname(entry))) {
                 entry = '';
                 options.skipPackageJson = true;
             }
             // resolve object browser field in package.json
             const { browser: browserField } = data;
-            if (targetWeb && isObject$2(browserField)) {
+            if (targetWeb && options.browserField && isObject$2(browserField)) {
                 entry = mapWithBrowserField(entry, browserField) || entry;
             }
             const entryPointPath = path$n.join(dir, entry);
@@ -34844,12 +35224,12 @@ function resolveExports(pkg, key, options, targetWeb) {
     if (!options.isRequire) {
         conditions.push('module');
     }
-    if (options.conditions) {
+    if (options.conditions.length > 0) {
         conditions.push(...options.conditions);
     }
     return resolve(pkg, key, {
-        browser: targetWeb,
-        require: options.isRequire,
+        browser: targetWeb && !conditions.includes('node'),
+        require: options.isRequire && !conditions.includes('import'),
         conditions
     });
 }
@@ -34882,7 +35262,7 @@ function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolv
                 `${path$n.join(dir, 'package.json')}.`);
         }
     }
-    else if (targetWeb && isObject$2(browserField)) {
+    else if (targetWeb && options.browserField && isObject$2(browserField)) {
         // resolve without postfix (see #7098)
         const { file, postfix } = splitFileAndPostfix(relativeId);
         const mapped = mapWithBrowserField(file, browserField);
@@ -34906,7 +35286,7 @@ function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolv
 }
 function tryResolveBrowserMapping(id, importer, options, isFilePath, externalize) {
     let res;
-    const pkg = importer && idToPkgMap.get(importer);
+    const pkg = importer && (idToPkgMap.get(importer) || resolvePkg(importer, options));
     if (pkg && isObject$2(pkg.data.browser)) {
         const mapId = isFilePath ? './' + slash$1(path$n.relative(pkg.dir, id)) : id;
         const browserMappedPath = mapWithBrowserField(mapId, pkg.data.browser);
@@ -34957,6 +35337,36 @@ function getRealPath(resolved, preserveSymlinks) {
     }
     return normalizePath$3(resolved);
 }
+/**
+ * if importer was not resolved by vite's resolver previously
+ * (when esbuild resolved it)
+ * resolve importer's pkg and add to idToPkgMap
+ */
+function resolvePkg(importer, options) {
+    const { root, preserveSymlinks, packageCache } = options;
+    if (importer.includes('\x00')) {
+        return null;
+    }
+    const possiblePkgIds = [];
+    for (let prevSlashIndex = -1;;) {
+        const slashIndex = importer.indexOf(isWindows$4 ? '\\' : '/', prevSlashIndex);
+        if (slashIndex < 0) {
+            break;
+        }
+        prevSlashIndex = slashIndex + 1;
+        const possiblePkgId = importer.slice(0, slashIndex);
+        possiblePkgIds.push(possiblePkgId);
+    }
+    let pkg;
+    possiblePkgIds.reverse().find((pkgId) => {
+        pkg = resolvePackageData(pkgId, root, preserveSymlinks, packageCache);
+        return pkg;
+    });
+    if (pkg) {
+        idToPkgMap.set(importer, pkg);
+    }
+    return pkg;
+}
 
 const externalWithConversionNamespace = 'vite:dep-pre-bundle:external-conversion';
 const convertedExternalPrefix = 'vite-dep-pre-bundle-external:';
@@ -35253,7 +35663,7 @@ function cjsSsrResolveExternals(config, knownImports) {
         ssrExternals.add(id);
         seen.add(id);
     });
-    cjsSsrCollectExternals(config.root, config.resolve.preserveSymlinks, ssrExternals, seen, config.logger);
+    cjsSsrCollectExternals(config.root, config.resolve, ssrExternals, seen, config.logger);
     const importedDeps = knownImports.map(getNpmPackageName).filter(isDefined);
     for (const dep of importedDeps) {
         // Assume external if not yet seen
@@ -35291,8 +35701,8 @@ function createIsConfiguredAsSsrExternal(config) {
         typeof noExternal !== 'boolean' &&
         createFilter(undefined, noExternal, { resolve: false });
     const resolveOptions = {
+        ...config.resolve,
         root,
-        preserveSymlinks: config.resolve.preserveSymlinks,
         isProduction: false,
         isBuild: true
     };
@@ -35363,7 +35773,7 @@ function createIsSsrExternal(config) {
 }
 // When config.experimental.buildSsrCjsExternalHeuristics is enabled, this function
 // is used reverting to the Vite 2.9 SSR externalization heuristics
-function cjsSsrCollectExternals(root, preserveSymlinks, ssrExternals, seen, logger) {
+function cjsSsrCollectExternals(root, resolveOptions, ssrExternals, seen, logger) {
     const rootPkgContent = lookupFile(root, ['package.json']);
     if (!rootPkgContent) {
         return;
@@ -35373,9 +35783,9 @@ function cjsSsrCollectExternals(root, preserveSymlinks, ssrExternals, seen, logg
         ...rootPkg.devDependencies,
         ...rootPkg.dependencies
     };
-    const resolveOptions = {
+    const internalResolveOptions = {
+        ...resolveOptions,
         root,
-        preserveSymlinks,
         isProduction: false,
         isBuild: true
     };
@@ -35387,7 +35797,7 @@ function cjsSsrCollectExternals(root, preserveSymlinks, ssrExternals, seen, logg
         let esmEntry;
         let requireEntry;
         try {
-            esmEntry = tryNodeResolve(id, undefined, resolveOptions, true, // we set `targetWeb` to `true` to get the ESM entry
+            esmEntry = tryNodeResolve(id, undefined, internalResolveOptions, true, // we set `targetWeb` to `true` to get the ESM entry
             undefined, true)?.id;
             // normalizePath required for windows. tryNodeResolve uses normalizePath
             // which returns with '/', require.resolve returns with '\\'
@@ -35447,7 +35857,7 @@ function cjsSsrCollectExternals(root, preserveSymlinks, ssrExternals, seen, logg
         }
     }
     for (const depRoot of depsToTrace) {
-        cjsSsrCollectExternals(depRoot, preserveSymlinks, ssrExternals, seen, logger);
+        cjsSsrCollectExternals(depRoot, resolveOptions, ssrExternals, seen, logger);
     }
 }
 function cjsShouldExternalizeForSSR(id, externals) {
@@ -35679,11 +36089,11 @@ function throwOutdatedRequest(id) {
     throw err;
 }
 
-const { isMatch: isMatch$2, scan } = micromatch_1;
+const { isMatch: isMatch$1, scan } = micromatch_1;
 function getAffectedGlobModules(file, server) {
     const modules = [];
     for (const [id, allGlobs] of server._importGlobMap) {
-        if (allGlobs.some((glob) => isMatch$2(file, glob)))
+        if (allGlobs.some((glob) => isMatch$1(file, glob)))
             modules.push(...(server.moduleGraph.getModulesByFile(id) || []));
     }
     modules.forEach((i) => {
@@ -36035,7 +36445,7 @@ async function toAbsoluteGlob(glob, root, importer, resolveId) {
     if (glob.startsWith('**'))
         return pre + glob;
     const resolved = normalizePath$3((await resolveId(glob, importer)) || glob);
-    if (isAbsolute$2(resolved)) {
+    if (isAbsolute$3(resolved)) {
         return pre + globSafeResolvedPath(resolved, glob);
     }
     throw new Error(`Invalid glob: "${glob}" (resolved: "${resolved}"). It must start with '/' or './'`);
@@ -36160,11 +36570,11 @@ function updateModules(file, modules, timestamp, { config, ws }) {
         updates.push(...[...boundaries].map(({ boundary, acceptedVia }) => ({
             type: `${boundary.type}-update`,
             timestamp,
-            path: boundary.url,
+            path: normalizeHmrUrl(boundary.url),
             explicitImportRequired: boundary.type === 'js'
                 ? isExplicitImportRequired(acceptedVia.url)
                 : undefined,
-            acceptedPath: acceptedVia.url
+            acceptedPath: normalizeHmrUrl(acceptedVia.url)
         })));
     }
     if (needFullReload) {
@@ -36432,6 +36842,12 @@ function lexAcceptedHmrExports(code, start, exportNames) {
     }
     return urls.size > 0;
 }
+function normalizeHmrUrl(url) {
+    if (!url.startsWith('.') && !url.startsWith('/')) {
+        url = wrapId(url);
+    }
+    return url;
+}
 function error$1(pos) {
     const err = new Error(`import.meta.hot.accept() can only accept string literals or an ` +
         `Array of string literals.`);
@@ -36858,7 +37274,7 @@ function parse$a(req) {
 
 const noop$2 = () => {};
 
-function isMatch$1(uri, arr) {
+function isMatch(uri, arr) {
 	for (let i=0; i < arr.length; i++) {
 		if (arr[i].test(uri)) return true;
 	}
@@ -37024,7 +37440,7 @@ function sirv (dir, opts={}) {
 			catch (err) { /* malform uri */ }
 		}
 
-		let data = lookup(pathname, extns) || isSPA && !isMatch$1(pathname, ignores) && lookup(fallback, extns);
+		let data = lookup(pathname, extns) || isSPA && !isMatch(pathname, ignores) && lookup(fallback, extns);
 		if (!data) return next ? next() : isNotFound(req, res);
 
 		if (isEtag && req.headers['if-none-match'] === data.headers['ETag']) {
@@ -37041,7 +37457,6 @@ function sirv (dir, opts={}) {
 	};
 }
 
-const { isMatch } = micromatch_1;
 const sirvOptions = (headers) => {
     return {
         dev: true,
@@ -37150,12 +37565,11 @@ function serveRawFsMiddleware(server) {
         }
     };
 }
-const _matchOptions = { matchBase: true };
 function isFileServingAllowed(url, server) {
     if (!server.config.server.fs.strict)
         return true;
     const file = fsPathFromUrl(url);
-    if (server.config.server.fs.deny.some((i) => isMatch(file, i, _matchOptions)))
+    if (server._fsDenyGlob(file))
         return false;
     if (server.moduleGraph.safeModulesPath.has(file))
         return true;
@@ -37470,7 +37884,7 @@ function extractImportedBindings(id, source, importSpec, importedBindings) {
  *     ```
  *
  * - CSS imports are appended with `.js` since both the js module and the actual
- * css (referenced via <link>) may go through the transform pipeline:
+ * css (referenced via `<link>`) may go through the transform pipeline:
  *
  *     ```js
  *     import './style.css'
@@ -37504,8 +37918,8 @@ function importAnalysisPlugin(config) {
             }
             const start = performance.now();
             await init;
-            let imports = [];
-            let exports = [];
+            let imports;
+            let exports;
             source = stripBomTag(source);
             try {
                 [imports, exports] = parse$b(source);
@@ -37827,7 +38241,7 @@ function importAnalysisPlugin(config) {
                             : `[detected api usage]`} ${prettyImporter}`);
                 // inject hot context
                 str().prepend(`import { createHotContext as __vite__createHotContext } from "${clientPublicPath}";` +
-                    `import.meta.hot = __vite__createHotContext(${JSON.stringify(importerModule.url)});`);
+                    `import.meta.hot = __vite__createHotContext(${JSON.stringify(normalizeHmrUrl(importerModule.url))});`);
             }
             if (needQueryInjectHelper) {
                 str().prepend(`import { injectQuery as __vite__injectQuery } from "${clientPublicPath}";`);
@@ -38154,276 +38568,6 @@ const wasmFallbackPlugin = () => {
     };
 };
 
-const WORKER_FILE_ID = 'worker_file';
-const workerCache = new WeakMap();
-function saveEmitWorkerAsset(config, asset) {
-    const fileName = asset.fileName;
-    const workerMap = workerCache.get(config.mainConfig || config);
-    workerMap.assets.set(fileName, asset);
-}
-async function bundleWorkerEntry(config, id, query) {
-    // bundle the file as entry to support imports
-    const { rollup } = await import('rollup');
-    const { plugins, rollupOptions, format } = config.worker;
-    const bundle = await rollup({
-        ...rollupOptions,
-        input: cleanUrl(id),
-        plugins,
-        onwarn(warning, warn) {
-            onRollupWarning(warning, warn, config);
-        },
-        preserveEntrySignatures: false
-    });
-    let chunk;
-    try {
-        const workerOutputConfig = config.worker.rollupOptions.output;
-        const workerConfig = workerOutputConfig
-            ? Array.isArray(workerOutputConfig)
-                ? workerOutputConfig[0] || {}
-                : workerOutputConfig
-            : {};
-        const { output: [outputChunk, ...outputChunks] } = await bundle.generate({
-            entryFileNames: path$n.posix.join(config.build.assetsDir, '[name].[hash].js'),
-            chunkFileNames: path$n.posix.join(config.build.assetsDir, '[name].[hash].js'),
-            assetFileNames: path$n.posix.join(config.build.assetsDir, '[name].[hash].[ext]'),
-            ...workerConfig,
-            format,
-            sourcemap: config.build.sourcemap
-        });
-        chunk = outputChunk;
-        outputChunks.forEach((outputChunk) => {
-            if (outputChunk.type === 'asset') {
-                saveEmitWorkerAsset(config, outputChunk);
-            }
-            else if (outputChunk.type === 'chunk') {
-                saveEmitWorkerAsset(config, {
-                    fileName: outputChunk.fileName,
-                    source: outputChunk.code,
-                    type: 'asset'
-                });
-            }
-        });
-    }
-    finally {
-        await bundle.close();
-    }
-    return emitSourcemapForWorkerEntry(config, query, chunk);
-}
-function emitSourcemapForWorkerEntry(config, query, chunk) {
-    const { map: sourcemap } = chunk;
-    if (sourcemap) {
-        if (config.build.sourcemap === 'inline') {
-            // Manually add the sourcemap to the code if configured for inline sourcemaps.
-            // TODO: Remove when https://github.com/rollup/rollup/issues/3913 is resolved
-            // Currently seems that it won't be resolved until Rollup 3
-            const dataUrl = sourcemap.toUrl();
-            chunk.code += `//# sourceMappingURL=${dataUrl}`;
-        }
-        else if (config.build.sourcemap === 'hidden' ||
-            config.build.sourcemap === true) {
-            const data = sourcemap.toString();
-            const mapFileName = chunk.fileName + '.map';
-            saveEmitWorkerAsset(config, {
-                fileName: mapFileName,
-                type: 'asset',
-                source: data
-            });
-            // Emit the comment that tells the JS debugger where it can find the
-            // sourcemap file.
-            // 'hidden' causes the sourcemap file to be created but
-            // the comment in the file to be omitted.
-            if (config.build.sourcemap === true) {
-                // inline web workers need to use the full sourcemap path
-                // non-inline web workers can use a relative path
-                const sourceMapUrl = query?.inline != null
-                    ? mapFileName
-                    : path$n.relative(config.build.assetsDir, mapFileName);
-                chunk.code += `//# sourceMappingURL=${sourceMapUrl}`;
-            }
-        }
-    }
-    return chunk;
-}
-const workerAssetUrlRE = /__VITE_WORKER_ASSET__([a-z\d]{8})__/g;
-function encodeWorkerAssetFileName(fileName, workerCache) {
-    const { fileNameHash } = workerCache;
-    const hash = getHash(fileName);
-    if (!fileNameHash.get(hash)) {
-        fileNameHash.set(hash, fileName);
-    }
-    return `__VITE_WORKER_ASSET__${hash}__`;
-}
-async function workerFileToUrl(config, id, query) {
-    const workerMap = workerCache.get(config.mainConfig || config);
-    let fileName = workerMap.bundle.get(id);
-    if (!fileName) {
-        const outputChunk = await bundleWorkerEntry(config, id, query);
-        fileName = outputChunk.fileName;
-        saveEmitWorkerAsset(config, {
-            fileName,
-            source: outputChunk.code,
-            type: 'asset'
-        });
-        workerMap.bundle.set(id, fileName);
-    }
-    return encodeWorkerAssetFileName(fileName, workerMap);
-}
-function webWorkerPlugin(config) {
-    const isBuild = config.command === 'build';
-    let server;
-    const isWorker = config.isWorker;
-    return {
-        name: 'vite:worker',
-        configureServer(_server) {
-            server = _server;
-        },
-        buildStart() {
-            if (isWorker) {
-                return;
-            }
-            workerCache.set(config, {
-                assets: new Map(),
-                bundle: new Map(),
-                fileNameHash: new Map()
-            });
-        },
-        load(id) {
-            if (isBuild) {
-                const parsedQuery = parseRequest(id);
-                if (parsedQuery &&
-                    (parsedQuery.worker ?? parsedQuery.sharedworker) != null) {
-                    return '';
-                }
-            }
-        },
-        async transform(raw, id, options) {
-            const ssr = options?.ssr === true;
-            const query = parseRequest(id);
-            if (query && query[WORKER_FILE_ID] != null) {
-                // if import worker by worker constructor will have query.type
-                // other type will be import worker by esm
-                const workerType = query['type'];
-                let injectEnv = '';
-                if (workerType === 'classic') {
-                    injectEnv = `importScripts('${ENV_PUBLIC_PATH}')\n`;
-                }
-                else if (workerType === 'module') {
-                    injectEnv = `import '${ENV_PUBLIC_PATH}'\n`;
-                }
-                else if (workerType === 'ignore') {
-                    if (isBuild) {
-                        injectEnv = '';
-                    }
-                    else if (server) {
-                        // dynamic worker type we can't know how import the env
-                        // so we copy /@vite/env code of server transform result into file header
-                        const { moduleGraph } = server;
-                        const module = moduleGraph.getModuleById(ENV_ENTRY);
-                        injectEnv = module?.transformResult?.code || '';
-                    }
-                }
-                return {
-                    code: injectEnv + raw
-                };
-            }
-            if (query == null ||
-                (query && (query.worker ?? query.sharedworker) == null)) {
-                return;
-            }
-            // stringified url or `new URL(...)`
-            let url;
-            const { format } = config.worker;
-            const workerConstructor = query.sharedworker != null ? 'SharedWorker' : 'Worker';
-            const workerType = isBuild
-                ? format === 'es'
-                    ? 'module'
-                    : 'classic'
-                : 'module';
-            const workerOptions = workerType === 'classic' ? '' : ',{type: "module"}';
-            if (isBuild) {
-                getDepsOptimizer(config, ssr)?.registerWorkersSource(id);
-                if (query.inline != null) {
-                    const chunk = await bundleWorkerEntry(config, id, query);
-                    // inline as blob data url
-                    return {
-                        code: `const encodedJs = "${Buffer.from(chunk.code).toString('base64')}";
-            const blob = typeof window !== "undefined" && window.Blob && new Blob([atob(encodedJs)], { type: "text/javascript;charset=utf-8" });
-            export default function WorkerWrapper() {
-              const objURL = blob && (window.URL || window.webkitURL).createObjectURL(blob);
-              try {
-                return objURL ? new ${workerConstructor}(objURL) : new ${workerConstructor}("data:application/javascript;base64," + encodedJs${workerOptions});
-              } finally {
-                objURL && (window.URL || window.webkitURL).revokeObjectURL(objURL);
-              }
-            }`,
-                        // Empty sourcemap to suppress Rollup warning
-                        map: { mappings: '' }
-                    };
-                }
-                else {
-                    url = await workerFileToUrl(config, id, query);
-                }
-            }
-            else {
-                url = await fileToUrl(cleanUrl(id), config, this);
-                url = injectQuery(url, WORKER_FILE_ID);
-                url = injectQuery(url, `type=${workerType}`);
-            }
-            if (query.url != null) {
-                return {
-                    code: `export default ${JSON.stringify(url)}`,
-                    map: { mappings: '' } // Empty sourcemap to suppress Rollup warning
-                };
-            }
-            return {
-                code: `export default function WorkerWrapper() {
-          return new ${workerConstructor}(${JSON.stringify(url)}${workerOptions})
-        }`,
-                map: { mappings: '' } // Empty sourcemap to suppress Rollup warning
-            };
-        },
-        renderChunk(code, chunk, outputOptions) {
-            let s;
-            const result = () => {
-                return (s && {
-                    code: s.toString(),
-                    map: config.build.sourcemap ? s.generateMap({ hires: true }) : null
-                });
-            };
-            if (code.match(workerAssetUrlRE) || code.includes('import.meta.url')) {
-                let match;
-                s = new MagicString(code);
-                // Replace "__VITE_WORKER_ASSET__5aa0ddc0__" using relative paths
-                const workerMap = workerCache.get(config.mainConfig || config);
-                const { fileNameHash } = workerMap;
-                while ((match = workerAssetUrlRE.exec(code))) {
-                    const [full, hash] = match;
-                    const filename = fileNameHash.get(hash);
-                    const replacement = toOutputFilePathInString(filename, 'asset', chunk.fileName, 'js', config, outputOptions.format);
-                    const replacementString = typeof replacement === 'string'
-                        ? JSON.stringify(replacement).slice(1, -1)
-                        : `"+${replacement.runtime}+"`;
-                    s.overwrite(match.index, match.index + full.length, replacementString, {
-                        contentOnly: true
-                    });
-                }
-            }
-            return result();
-        },
-        generateBundle(opts) {
-            // @ts-ignore asset emits are skipped in legacy bundle
-            if (opts.__vite_skip_asset_emit__ || isWorker) {
-                return;
-            }
-            const workerMap = workerCache.get(config);
-            workerMap.assets.forEach((asset) => {
-                this.emitFile(asset);
-                workerMap.assets.delete(asset.fileName);
-            });
-        }
-    };
-}
-
 /**
  * A plugin to avoid an aliased AND optimized dep from being aliased in src
  */
@@ -38639,7 +38783,7 @@ function definePlugin(config) {
 function ssrRequireHookPlugin(config) {
     if (config.command !== 'build' ||
         !config.build.ssr ||
-        !config.resolve.dedupe?.length ||
+        !config.resolve.dedupe.length ||
         config.ssr?.noExternal === true ||
         config.ssr?.format !== 'cjs' ||
         isBuildOutputEsm(config)) {
@@ -40109,14 +40253,16 @@ function getWorkerType(raw, clean, i) {
         return 'classic';
     }
     // need to find in comment code
-    const workerOptString = raw.substring(commaIndex + 1, endIndex);
+    const workerOptString = raw
+        .substring(commaIndex + 1, endIndex)
+        .replace(/}[^]*,/g, '}'); // strip trailing comma for parsing
     const hasViteIgnore = ignoreFlagRE.test(workerOptString);
     if (hasViteIgnore) {
         return 'ignore';
     }
     // need to find in no comment code
-    const cleanWorkerOptString = clean.substring(commaIndex + 1, endIndex);
-    if (!cleanWorkerOptString.trim().length) {
+    const cleanWorkerOptString = clean.substring(commaIndex + 1, endIndex).trim();
+    if (!cleanWorkerOptString.length) {
         return 'classic';
     }
     let workerOpts = { type: 'classic' };
@@ -40135,6 +40281,7 @@ function getWorkerType(raw, clean, i) {
 }
 function workerImportMetaUrlPlugin(config) {
     const isBuild = config.command === 'build';
+    let workerResolver;
     return {
         name: 'vite:worker-import-meta-url',
         async transform(code, id, options) {
@@ -40160,20 +40307,33 @@ function workerImportMetaUrlPlugin(config) {
                     }
                     s || (s = new MagicString(code));
                     const workerType = getWorkerType(code, cleanString, index + allExp.length);
-                    const file = normalizePath$3(path$n.resolve(path$n.dirname(id), rawUrl.slice(1, -1)));
-                    let url;
+                    const url = rawUrl.slice(1, -1);
+                    let file;
+                    if (url.startsWith('.')) {
+                        file = path$n.resolve(path$n.dirname(id), url);
+                    }
+                    else {
+                        workerResolver ?? (workerResolver = config.createResolver({
+                            extensions: [],
+                            tryIndex: false,
+                            preferRelative: true
+                        }));
+                        file = await workerResolver(url, id);
+                        file ?? (file = url.startsWith('/')
+                            ? slash$1(path$n.join(config.publicDir, url))
+                            : slash$1(path$n.resolve(path$n.dirname(id), url)));
+                    }
+                    let builtUrl;
                     if (isBuild) {
                         getDepsOptimizer(config, ssr)?.registerWorkersSource(id);
-                        url = await workerFileToUrl(config, file, query);
+                        builtUrl = await workerFileToUrl(config, file, query);
                     }
                     else {
-                        url = await fileToUrl(cleanUrl(file), config, this);
-                        url = injectQuery(url, WORKER_FILE_ID);
-                        url = injectQuery(url, `type=${workerType}`);
+                        builtUrl = await fileToUrl(cleanUrl(file), config, this);
+                        builtUrl = injectQuery(builtUrl, WORKER_FILE_ID);
+                        builtUrl = injectQuery(builtUrl, `type=${workerType}`);
                     }
-                    s.overwrite(urlIndex, urlIndex + exp.length, JSON.stringify(url), {
-                        contentOnly: true
-                    });
+                    s.overwrite(urlIndex, urlIndex + exp.length, `new URL(${JSON.stringify(builtUrl)}, self.location)`, { contentOnly: true });
                 }
                 if (s) {
                     return transformStableResult(s, id, config);
@@ -40184,6 +40344,119 @@ function workerImportMetaUrlPlugin(config) {
     };
 }
 
+/**
+ * Convert `new URL('./foo.png', import.meta.url)` to its resolved built URL
+ *
+ * Supports template string with dynamic segments:
+ * ```
+ * new URL(`./dir/${name}.png`, import.meta.url)
+ * // transformed to
+ * import.meta.glob('./dir/**.png', { eager: true, import: 'default' })[`./dir/${name}.png`]
+ * ```
+ */
+function assetImportMetaUrlPlugin(config) {
+    const normalizedPublicDir = normalizePath$3(config.publicDir);
+    let assetResolver;
+    return {
+        name: 'vite:asset-import-meta-url',
+        async transform(code, id, options) {
+            if (!options?.ssr &&
+                id !== preloadHelperId &&
+                code.includes('new URL') &&
+                code.includes(`import.meta.url`)) {
+                let s;
+                const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*,?\s*\)/g;
+                const cleanString = stripLiteral(code);
+                let match;
+                while ((match = assetImportMetaUrlRE.exec(cleanString))) {
+                    const { 0: exp, 1: emptyUrl, index } = match;
+                    const urlStart = cleanString.indexOf(emptyUrl, index);
+                    const urlEnd = urlStart + emptyUrl.length;
+                    const rawUrl = code.slice(urlStart, urlEnd);
+                    if (!s)
+                        s = new MagicString(code);
+                    // potential dynamic template string
+                    if (rawUrl[0] === '`' && /\$\{/.test(rawUrl)) {
+                        const ast = this.parse(rawUrl);
+                        const templateLiteral = ast.body[0].expression;
+                        if (templateLiteral.expressions.length) {
+                            const pattern = JSON.stringify(buildGlobPattern(templateLiteral));
+                            // 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.overwrite(index, index + exp.length, `new URL((import.meta.glob(${pattern}, { eager: true, import: 'default', as: 'url' }))[${rawUrl}], self.location)`, { contentOnly: true });
+                            continue;
+                        }
+                    }
+                    const url = rawUrl.slice(1, -1);
+                    let file;
+                    if (url.startsWith('.')) {
+                        file = slash$1(path$n.resolve(path$n.dirname(id), url));
+                    }
+                    else {
+                        assetResolver ?? (assetResolver = config.createResolver({
+                            extensions: [],
+                            mainFields: [],
+                            tryIndex: false,
+                            preferRelative: true
+                        }));
+                        file = await assetResolver(url, id);
+                        file ?? (file = url.startsWith('/')
+                            ? slash$1(path$n.join(config.publicDir, url))
+                            : slash$1(path$n.resolve(path$n.dirname(id), url)));
+                    }
+                    // Get final asset URL. If the file does not exist,
+                    // we fall back to the initial URL and let it resolve in runtime
+                    let builtUrl;
+                    if (file) {
+                        try {
+                            if (isParentDirectory(normalizedPublicDir, file)) {
+                                const publicPath = '/' + path$n.posix.relative(normalizedPublicDir, file);
+                                builtUrl = await fileToUrl(publicPath, config, this);
+                            }
+                            else {
+                                builtUrl = await fileToUrl(file, config, this);
+                            }
+                        }
+                        catch {
+                            // do nothing, we'll log a warning after this
+                        }
+                    }
+                    if (!builtUrl) {
+                        const rawExp = code.slice(index, index + exp.length);
+                        config.logger.warnOnce(`\n${rawExp} doesn't exist at build time, it will remain unchanged to be resolved at runtime`);
+                        builtUrl = url;
+                    }
+                    s.overwrite(index, index + exp.length, `new URL(${JSON.stringify(builtUrl)}, self.location)`, { contentOnly: true });
+                }
+                if (s) {
+                    return transformStableResult(s, id, config);
+                }
+            }
+            return null;
+        }
+    };
+}
+function buildGlobPattern(ast) {
+    let pattern = '';
+    let lastElementIndex = -1;
+    for (const exp of ast.expressions) {
+        for (let i = lastElementIndex + 1; i < ast.quasis.length; i++) {
+            const el = ast.quasis[i];
+            if (el.end < exp.start) {
+                pattern += el.value.raw;
+                lastElementIndex = i;
+            }
+        }
+        pattern += '**';
+    }
+    for (let i = lastElementIndex + 1; i < ast.quasis.length; i++) {
+        pattern += ast.quasis[i].value.raw;
+    }
+    return pattern;
+}
+
 /**
  * plugin to ensure rollup can watch correctly.
  */
@@ -40365,6 +40638,12 @@ function parseDynamicImportPattern(strings) {
     if (rawQuery?.raw !== undefined) {
         globParams = { as: 'raw' };
     }
+    if (rawQuery?.url !== undefined) {
+        globParams = { as: 'url' };
+    }
+    if (rawQuery?.worker !== undefined) {
+        globParams = { as: 'worker' };
+    }
     return {
         globParams,
         userPattern,
@@ -40484,13 +40763,15 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
     const buildPlugins = isBuild
         ? (await Promise.resolve().then(function () { return build$1; })).resolveBuildPlugins(config)
         : { pre: [], post: [] };
+    const { modulePreload } = config.build;
     return [
         isWatch ? ensureWatchPlugin() : null,
         isBuild ? metadataPlugin() : null,
         preAliasPlugin(config),
         alias$1({ entries: config.resolve.alias }),
         ...prePlugins,
-        config.build.polyfillModulePreload
+        modulePreload === true ||
+            (typeof modulePreload === 'object' && modulePreload.polyfill)
             ? modulePreloadPolyfillPlugin(config)
             : null,
         ...(isDepsOptimizerEnabled(config, false) ||
@@ -40531,6 +40812,7 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
         isBuild && config.build.ssr ? ssrRequireHookPlugin(config) : null,
         isBuild && buildHtmlPlugin(config),
         workerImportMetaUrlPlugin(config),
+        assetImportMetaUrlPlugin(config),
         ...buildPlugins.pre,
         dynamicImportVarsPlugin(config),
         importGlobPlugin(config),
@@ -41461,7 +41743,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
             // may end with these extensions
             // css & json & wasm
             build.onResolve({
-                filter: /\.(css|less|sass|scss|styl|stylus|pcss|postcss|json|wasm)$/
+                filter: /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss|json|wasm)$/
             }, externalUnlessEntry);
             // known asset types
             build.onResolve({
@@ -41606,6 +41888,7 @@ async function createDepsOptimizer(config, server) {
     const sessionTimestamp = Date.now().toString();
     const cachedMetadata = loadCachedDepOptimizationMetadata(config, ssr);
     let handle;
+    let closed = false;
     let metadata = cachedMetadata || initDepsOptimizerMetadata(config, ssr, sessionTimestamp);
     const depsOptimizer = {
         metadata,
@@ -41618,6 +41901,7 @@ async function createDepsOptimizer(config, server) {
         delayDepsOptimizerUntil,
         resetRegisteredIds,
         ensureFirstRun,
+        close,
         options: getDepOptimizationConfig(config, ssr)
     };
     depsOptimizerMap.set(config, depsOptimizer);
@@ -41646,6 +41930,12 @@ async function createDepsOptimizer(config, server) {
     // If there wasn't a cache or it is outdated, we need to prepare a first run
     let firstRunCalled = !!cachedMetadata;
     let postScanOptimizationResult;
+    let optimizingNewDeps;
+    async function close() {
+        closed = true;
+        await postScanOptimizationResult;
+        await optimizingNewDeps;
+    }
     if (!cachedMetadata) {
         // Enter processing state until crawl of static imports ends
         currentlyProcessing = true;
@@ -41743,13 +42033,20 @@ async function createDepsOptimizer(config, server) {
         // Ensure that a rerun will not be issued for current discovered deps
         if (handle)
             clearTimeout(handle);
-        if (Object.keys(metadata.discovered).length === 0) {
+        if (closed || Object.keys(metadata.discovered).length === 0) {
             currentlyProcessing = false;
             return;
         }
         currentlyProcessing = true;
         try {
-            const processingResult = preRunResult ?? (await optimizeNewDeps());
+            const processingResult = preRunResult ?? (await (optimizingNewDeps = optimizeNewDeps()));
+            optimizingNewDeps = undefined;
+            if (closed) {
+                currentlyProcessing = false;
+                processingResult.cancel();
+                resolveEnqueuedProcessingPromises();
+                return;
+            }
             const newData = processingResult.metadata;
             const needsInteropMismatch = findInteropMismatches(metadata.discovered, newData.optimized);
             // After a re-optimization, if the internal bundled chunks change a full page reload
@@ -42018,7 +42315,7 @@ async function createDepsOptimizer(config, server) {
     function ensureFirstRun() {
         if (!firstRunEnsured && !firstRunCalled && registeredIds.length === 0) {
             setTimeout(() => {
-                if (registeredIds.length === 0) {
+                if (!closed && registeredIds.length === 0) {
                     onCrawlEnd();
                 }
             }, runOptimizerIfIdleAfterMs);
@@ -42049,7 +42346,7 @@ async function createDepsOptimizer(config, server) {
                 waitingOn = next.id;
                 const afterLoad = () => {
                     waitingOn = undefined;
-                    if (!workersSources.has(next.id)) {
+                    if (!closed && !workersSources.has(next.id)) {
                         if (registeredIds.length > 0) {
                             runOptimizerWhenIdle();
                         }
@@ -42085,6 +42382,7 @@ async function createDevSsrDepsOptimizer(config) {
         delayDepsOptimizerUntil: (id, done) => { },
         resetRegisteredIds: () => { },
         ensureFirstRun: () => { },
+        close: async () => { },
         options: config.ssr.optimizeDeps
     };
     devSsrDepsOptimizerMap.set(config, depsOptimizer);
@@ -42694,7 +42992,12 @@ function needsInterop(config, ssr, id, exportsData, output) {
 function isSingleDefaultExport(exports) {
     return exports.length === 1 && exports[0] === 'default';
 }
-const lockfileFormats = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml'];
+const lockfileFormats = [
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    'bun.lockb'
+];
 function getDepHash(config, ssr) {
     let content = lookupFile(config.root, lockfileFormats) || '';
     // also take config into account
@@ -42794,6 +43097,10 @@ const dynamicImportPrefixRE = /import\s*\(/;
 // TODO: abstract
 const optimizedDepChunkRE = /\/chunk-[A-Z0-9]{8}\.js/;
 const optimizedDepDynamicRE = /-[A-Z0-9]{8}\.js/;
+function toRelativePath(filename, importer) {
+    const relPath = path$n.relative(path$n.dirname(importer), filename);
+    return relPath.startsWith('.') ? relPath : `./${relPath}`;
+}
 /**
  * Helper for preloading CSS and direct imports of async chunks in parallel to
  * the async chunk itself.
@@ -42811,6 +43118,7 @@ function preload(baseModule, deps, importerUrl) {
     if (!__VITE_IS_MODERN__ || !deps || deps.length === 0) {
         return baseModule();
     }
+    const links = document.getElementsByTagName('link');
     return Promise.all(deps.map((dep) => {
         // @ts-ignore
         dep = assetsURL(dep, importerUrl);
@@ -42821,8 +43129,21 @@ function preload(baseModule, deps, importerUrl) {
         seen[dep] = true;
         const isCss = dep.endsWith('.css');
         const cssSelector = isCss ? '[rel="stylesheet"]' : '';
-        // @ts-ignore check if the file is already preloaded by SSR markup
-        if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) {
+        const isBaseRelative = !!importerUrl;
+        // check if the file is already preloaded by SSR markup
+        if (isBaseRelative) {
+            // When isBaseRelative is true then we have `importerUrl` and `dep` is
+            // already converted to an absolute URL by the `assetsURL` function
+            for (let i = links.length - 1; i >= 0; i--) {
+                const link = links[i];
+                // The `links[i].href` is an absolute URL thanks to browser doing the work
+                // for us. See https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#reflecting-content-attributes-in-idl-attributes:idl-domstring-5
+                if (link.href === dep && (!isCss || link.rel === 'stylesheet')) {
+                    return;
+                }
+            }
+        }
+        else if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) {
             return;
         }
         // @ts-ignore
@@ -42850,14 +43171,39 @@ function preload(baseModule, deps, importerUrl) {
 function buildImportAnalysisPlugin(config) {
     const ssr = !!config.build.ssr;
     const isWorker = config.isWorker;
-    const insertPreload = !(ssr || !!config.build.lib || isWorker);
-    const relativePreloadUrls = config.base === './' || config.base === '';
-    const scriptRel = config.build.polyfillModulePreload
+    const insertPreload = !(ssr ||
+        !!config.build.lib ||
+        isWorker ||
+        config.build.modulePreload === false);
+    const resolveModulePreloadDependencies = config.build.modulePreload && config.build.modulePreload.resolveDependencies;
+    const renderBuiltUrl = config.experimental.renderBuiltUrl;
+    const customModulePreloadPaths = !!(resolveModulePreloadDependencies || renderBuiltUrl);
+    const isRelativeBase = config.base === './' || config.base === '';
+    const optimizeModulePreloadRelativePaths = isRelativeBase && !customModulePreloadPaths;
+    const { modulePreload } = config.build;
+    const scriptRel = modulePreload && modulePreload.polyfill
         ? `'modulepreload'`
         : `(${detectScriptRel.toString()})()`;
-    const assetsURL = relativePreloadUrls
-        ? `function(dep,importerUrl) { return new URL(dep, importerUrl).href }`
-        : `function(dep) { return ${JSON.stringify(config.base)}+dep }`;
+    // There are three different cases for the preload list format in __vitePreload
+    //
+    // __vitePreload(() => import(asyncChunk), [ ...deps... ])
+    //
+    // This is maintained to keep backwards compatibility as some users developed plugins
+    // using regex over this list to workaround the fact that module preload wasn't
+    // configurable.
+    const assetsURL = customModulePreloadPaths
+        ? // If `experimental.renderBuiltUrl` or `build.modulePreload.resolveDependencies` are used
+            // the dependencies are already resolved. To avoid the need for `new URL(dep, import.meta.url)`
+            // a helper `__vitePreloadRelativeDep` is used to resolve from relative paths which can be minimized.
+            `function(dep, importerUrl) { return dep.startsWith('.') ? new URL(dep, importerUrl).href : dep }`
+        : optimizeModulePreloadRelativePaths
+            ? // If there isn't custom resolvers affecting the deps list, deps in the list are relative
+                // to the current chunk and are resolved to absolute URL by the __vitePreload helper itself.
+                // The importerUrl is passed as third parameter to __vitePreload in this case
+                `function(dep, importerUrl) { return new URL(dep, importerUrl).href }`
+            : // If the base isn't relative, then the deps are relative to the projects `outDir` and the base
+                // is appendended inside __vitePreload too.
+                `function(dep) { return ${JSON.stringify(config.base)}+dep }`;
     const preloadCode = `const scriptRel = ${scriptRel};const assetsURL = ${assetsURL};const seen = {};export const ${preloadMethod} = ${preload.toString()}`;
     return {
         name: 'vite:build-import-analysis',
@@ -42943,7 +43289,9 @@ function buildImportAnalysisPlugin(config) {
                 if (isDynamicImport && insertPreload) {
                     needPreloadHelper = true;
                     str().prependLeft(expStart, `${preloadMethod}(() => `);
-                    str().appendRight(expEnd, `,${isModernFlag}?"${preloadMarker}":void 0${relativePreloadUrls ? ',import.meta.url' : ''})`);
+                    str().appendRight(expEnd, `,${isModernFlag}?"${preloadMarker}":void 0${optimizeModulePreloadRelativePaths || customModulePreloadPaths
+                        ? ',import.meta.url'
+                        : ''})`);
                 }
                 // static import or valid string in dynamic import
                 // If resolvable, let's resolve it
@@ -43038,7 +43386,10 @@ function buildImportAnalysisPlugin(config) {
             return null;
         },
         generateBundle({ format }, bundle) {
-            if (format !== 'es' || ssr || isWorker) {
+            if (format !== 'es' ||
+                ssr ||
+                isWorker ||
+                config.build.modulePreload === false) {
                 return;
             }
             for (const file in bundle) {
@@ -43047,7 +43398,7 @@ function buildImportAnalysisPlugin(config) {
                 // dynamic import to constant json may get inlined.
                 if (chunk.type === 'chunk' && chunk.code.indexOf(preloadMarker) > -1) {
                     const code = chunk.code;
-                    let imports = [];
+                    let imports;
                     try {
                         imports = parse$b(code)[0].filter((i) => i.d > -1);
                     }
@@ -43069,7 +43420,9 @@ function buildImportAnalysisPlugin(config) {
                             }
                             const deps = new Set();
                             let hasRemovedPureCssChunk = false;
+                            let normalizedFile = undefined;
                             if (url) {
+                                normalizedFile = path$n.posix.join(path$n.posix.dirname(chunk.fileName), url);
                                 const ownerFilename = chunk.fileName;
                                 // literal import - trace direct imports and add to deps
                                 const analyzed = new Set();
@@ -43082,10 +43435,12 @@ function buildImportAnalysisPlugin(config) {
                                     const chunk = bundle[filename];
                                     if (chunk) {
                                         deps.add(chunk.fileName);
+                                        chunk.imports.forEach(addDeps);
+                                        // Ensure that the css imported by current chunk is loaded after the dependencies.
+                                        // So the style of current chunk won't be overwritten unexpectedly.
                                         chunk.viteMetadata.importedCss.forEach((file) => {
                                             deps.add(file);
                                         });
-                                        chunk.imports.forEach(addDeps);
                                     }
                                     else {
                                         const removedPureCssFiles = removedPureCssFilesCache.get(config);
@@ -43103,7 +43458,6 @@ function buildImportAnalysisPlugin(config) {
                                         }
                                     }
                                 };
-                                const normalizedFile = path$n.posix.join(path$n.posix.dirname(chunk.fileName), url);
                                 addDeps(normalizedFile);
                             }
                             let markerStartPos = code.indexOf(preloadMarkerWithQuote, end);
@@ -43112,19 +43466,53 @@ function buildImportAnalysisPlugin(config) {
                                 markerStartPos = code.indexOf(preloadMarkerWithQuote);
                             }
                             if (markerStartPos > 0) {
-                                s.overwrite(markerStartPos, markerStartPos + preloadMarkerWithQuote.length, 
-                                // the dep list includes the main chunk, so only need to reload when there are
-                                // actual other deps. Don't include the assets dir if the default asset file names
-                                // are used, the path will be reconstructed by the import preload helper
-                                deps.size > 1 ||
+                                // the dep list includes the main chunk, so only need to reload when there are actual other deps.
+                                const depsArray = deps.size > 1 ||
                                     // main chunk is removed
                                     (hasRemovedPureCssChunk && deps.size > 0)
-                                    ? `[${[...deps]
-                                        .map((d) => JSON.stringify(relativePreloadUrls
-                                        ? path$n.relative(path$n.dirname(file), d)
-                                        : d))
-                                        .join(',')}]`
-                                    : `[]`, { contentOnly: true });
+                                    ? [...deps]
+                                    : [];
+                                let renderedDeps;
+                                if (normalizedFile && customModulePreloadPaths) {
+                                    const { modulePreload } = config.build;
+                                    const resolveDependencies = modulePreload && modulePreload.resolveDependencies;
+                                    let resolvedDeps;
+                                    if (resolveDependencies) {
+                                        // We can't let the user remove css deps as these aren't really preloads, they are just using
+                                        // the same mechanism as module preloads for this chunk
+                                        const cssDeps = [];
+                                        const otherDeps = [];
+                                        for (const dep of depsArray) {
+                                            (dep.endsWith('.css') ? cssDeps : otherDeps).push(dep);
+                                        }
+                                        resolvedDeps = [
+                                            ...resolveDependencies(normalizedFile, otherDeps, {
+                                                hostId: file,
+                                                hostType: 'js'
+                                            }),
+                                            ...cssDeps
+                                        ];
+                                    }
+                                    else {
+                                        resolvedDeps = depsArray;
+                                    }
+                                    renderedDeps = resolvedDeps.map((dep) => {
+                                        const replacement = toOutputFilePathInJS(dep, 'asset', chunk.fileName, 'js', config, toRelativePath);
+                                        const replacementString = typeof replacement === 'string'
+                                            ? JSON.stringify(replacement)
+                                            : replacement.runtime;
+                                        return replacementString;
+                                    });
+                                }
+                                else {
+                                    renderedDeps = depsArray.map((d) => 
+                                    // Don't include the assets dir if the default asset file names
+                                    // are used, the path will be reconstructed by the import preload helper
+                                    JSON.stringify(optimizeModulePreloadRelativePaths
+                                        ? toRelativePath(d, file)
+                                        : d));
+                                }
+                                s.overwrite(markerStartPos, markerStartPos + preloadMarkerWithQuote.length, `[${renderedDeps.join(',')}]`, { contentOnly: true });
                                 rewroteMarkerStartPos.add(markerStartPos);
                             }
                         }
@@ -43609,7 +43997,9 @@ function buildHtmlPlugin(config) {
                 }
                 processedHtml.set(id, s.toString());
                 // inject module preload polyfill only when configured and needed
-                if (config.build.polyfillModulePreload &&
+                const { modulePreload } = config.build;
+                if ((modulePreload === true ||
+                    (typeof modulePreload === 'object' && modulePreload.polyfill)) &&
                     (someScriptsAreAsync || someScriptsAreDefer)) {
                     js = `import "${modulePreloadPolyfillId}";\n${js}`;
                 }
@@ -43640,12 +44030,12 @@ function buildHtmlPlugin(config) {
                     src: toOutputPath(chunk.fileName)
                 }
             });
-            const toPreloadTag = (chunk, toOutputPath) => ({
+            const toPreloadTag = (filename, toOutputPath) => ({
                 tag: 'link',
                 attrs: {
                     rel: 'modulepreload',
                     crossorigin: true,
-                    href: toOutputPath(chunk.fileName)
+                    href: toOutputPath(filename)
                 }
             });
             const getCssTagsForChunk = (chunk, toOutputPath, seen = new Set()) => {
@@ -43704,12 +44094,26 @@ function buildHtmlPlugin(config) {
                     // when not inlined, inject <script> for entry and modulepreload its dependencies
                     // when inlined, discard entry chunk and inject <script> for everything in post-order
                     const imports = getImportedChunks(chunk);
-                    const assetTags = canInlineEntry
-                        ? imports.map((chunk) => toScriptTag(chunk, toOutputAssetFilePath, isAsync))
-                        : [
+                    let assetTags;
+                    if (canInlineEntry) {
+                        assetTags = imports.map((chunk) => toScriptTag(chunk, toOutputAssetFilePath, isAsync));
+                    }
+                    else {
+                        const { modulePreload } = config.build;
+                        const resolveDependencies = typeof modulePreload === 'object' &&
+                            modulePreload.resolveDependencies;
+                        const importsFileNames = imports.map((chunk) => chunk.fileName);
+                        const resolvedDeps = resolveDependencies
+                            ? resolveDependencies(chunk.fileName, importsFileNames, {
+                                hostId: relativeUrlPath,
+                                hostType: 'html'
+                            })
+                            : importsFileNames;
+                        assetTags = [
                             toScriptTag(chunk, toOutputAssetFilePath, isAsync),
-                            ...imports.map((i) => toPreloadTag(i, toOutputAssetFilePath))
+                            ...resolvedDeps.map((i) => toPreloadTag(i, toOutputAssetFilePath))
                         ];
+                    }
                     assetTags.push(...getCssTagsForChunk(chunk, toOutputAssetFilePath));
                     result = injectToHead(result, assetTags);
                 }
@@ -43976,7 +44380,7 @@ function incrementIndent(indent = '') {
     return `${indent}${indent[0] === '\t' ? '\t' : '  '}`;
 }
 
-const cssLangs = `\\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\\?)`;
+const cssLangs = `\\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)($|\\?)`;
 const cssLangRE = new RegExp(cssLangs);
 const cssModuleRE = new RegExp(`\\.module${cssLangs}`);
 const directRequestRE = /(\?|&)direct\b/;
@@ -43993,7 +44397,7 @@ const isDirectRequest = (request) => directRequestRE.test(request);
 const cssModulesCache = new WeakMap();
 const removedPureCssFilesCache = new WeakMap();
 const cssEntryFilesCache = new WeakMap();
-const postcssConfigCache = new WeakMap();
+const postcssConfigCache = {};
 function encodePublicUrlsInCSS(config) {
     return config.command === 'build';
 }
@@ -44299,7 +44703,7 @@ function cssPostPlugin(config) {
                     // the legacy build should avoid inserting entry CSS modules here, they
                     // will be collected into `chunk.viteMetadata.importedCss` and injected
                     // later by the `'vite:build-html'` plugin into the `index.html`
-                    if (chunk.isEntry) {
+                    if (chunk.isEntry && !config.build.lib) {
                         return null;
                     }
                     chunkCSS = await finalizeCss(chunkCSS, true, config);
@@ -44431,8 +44835,8 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
     // crawl them in order to register watch dependencies.
     const needInlineImport = code.includes('@import');
     const hasUrl = cssUrlRE.test(code) || cssImageSetRE.test(code);
-    const postcssConfig = await resolvePostcssConfig(config);
     const lang = id.match(cssLangRE)?.[1];
+    const postcssConfig = await resolvePostcssConfig(config, getCssDialect(lang));
     // 1. plain css that needs no processing
     if (lang === 'css' &&
         !postcssConfig &&
@@ -44487,9 +44891,13 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
     }
     // 3. postcss
     const postcssOptions = (postcssConfig && postcssConfig.options) || {};
+    // for sugarss change parser
+    if (lang === 'sss') {
+        postcssOptions.parser = loadPreprocessor("sugarss" /* sss */, config.root);
+    }
     const postcssPlugins = postcssConfig && postcssConfig.plugins ? postcssConfig.plugins.slice() : [];
     if (needInlineImport) {
-        postcssPlugins.unshift((await import('./dep-42c2c4e4.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-39e6741e.js').then(function (n) { return n.i; })).default({
             async resolve(id, basedir) {
                 const publicFile = checkPublicFile(id, config);
                 if (publicFile) {
@@ -44511,7 +44919,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-0fc42251.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-553f6a62.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -44659,8 +45067,9 @@ async function finalizeCss(css, minify, config) {
     }
     return css;
 }
-async function resolvePostcssConfig(config) {
-    let result = postcssConfigCache.get(config);
+async function resolvePostcssConfig(config, dialect = 'css') {
+    postcssConfigCache[dialect] ?? (postcssConfigCache[dialect] = new WeakMap());
+    let result = postcssConfigCache[dialect].get(config);
     if (result !== undefined) {
         return result;
     }
@@ -44696,7 +45105,7 @@ async function resolvePostcssConfig(config) {
             result = null;
         }
     }
-    postcssConfigCache.set(config, result);
+    postcssConfigCache[dialect].set(config, result);
     return result;
 }
 // https://drafts.csswg.org/css-syntax-3/#identifier-code-point
@@ -44921,8 +45330,8 @@ const scss = async (source, root, options, resolvers) => {
     const importer = [internalImporter];
     if (options.importer) {
         Array.isArray(options.importer)
-            ? importer.push(...options.importer)
-            : importer.push(options.importer);
+            ? importer.unshift(...options.importer)
+            : importer.unshift(options.importer);
     }
     const { content: data, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap);
     const finalOptions = {
@@ -45195,6 +45604,9 @@ const preProcessors = Object.freeze({
 function isPreProcessor(lang) {
     return lang && lang in preProcessors;
 }
+function getCssDialect(lang) {
+    return lang === 'sss' ? 'sss' : 'css';
+}
 
 function manifestPlugin(config) {
     const manifest = {};
@@ -45281,6 +45693,10 @@ function manifestPlugin(config) {
                     manifest[chunk.name] = createAsset(chunk);
                 }
             }
+            duplicateAssets.get(config).forEach((asset) => {
+                const chunk = createAsset(asset);
+                manifest[asset.name] = chunk;
+            });
             outputCount++;
             const output = config.build.rollupOptions?.output;
             const outputLength = Array.isArray(output) ? output.length : 1;
@@ -45420,87 +45836,6 @@ function ssrManifestPlugin(config) {
     };
 }
 
-/**
- * Convert `new URL('./foo.png', import.meta.url)` to its resolved built URL
- *
- * Supports template string with dynamic segments:
- * ```
- * new URL(`./dir/${name}.png`, import.meta.url)
- * // transformed to
- * import.meta.glob('./dir/**.png', { eager: true, import: 'default' })[`./dir/${name}.png`]
- * ```
- */
-function assetImportMetaUrlPlugin(config) {
-    return {
-        name: 'vite:asset-import-meta-url',
-        async transform(code, id, options) {
-            if (!options?.ssr &&
-                id !== preloadHelperId &&
-                code.includes('new URL') &&
-                code.includes(`import.meta.url`)) {
-                let s;
-                const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*,?\s*\)/g;
-                const cleanString = stripLiteral(code);
-                let match;
-                while ((match = assetImportMetaUrlRE.exec(cleanString))) {
-                    const { 0: exp, 1: emptyUrl, index } = match;
-                    const urlStart = cleanString.indexOf(emptyUrl, index);
-                    const urlEnd = urlStart + emptyUrl.length;
-                    const rawUrl = code.slice(urlStart, urlEnd);
-                    if (!s)
-                        s = new MagicString(code);
-                    // potential dynamic template string
-                    if (rawUrl[0] === '`' && /\$\{/.test(rawUrl)) {
-                        const ast = this.parse(rawUrl);
-                        const templateLiteral = ast.body[0].expression;
-                        if (templateLiteral.expressions.length) {
-                            const pattern = JSON.stringify(buildGlobPattern(templateLiteral));
-                            // 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.overwrite(index, index + exp.length, `new URL((import.meta.glob(${pattern}, { eager: true, import: 'default', as: 'url' }))[${rawUrl}], self.location)`, { contentOnly: true });
-                            continue;
-                        }
-                    }
-                    const url = rawUrl.slice(1, -1);
-                    const file = path$n.resolve(path$n.dirname(id), url);
-                    // Get final asset URL. Catch error if the file does not exist,
-                    // in which we can resort to the initial URL and let it resolve in runtime
-                    const builtUrl = await fileToUrl(file, config, this).catch(() => {
-                        const rawExp = code.slice(index, index + exp.length);
-                        config.logger.warnOnce(`\n${rawExp} doesn't exist at build time, it will remain unchanged to be resolved at runtime`);
-                        return url;
-                    });
-                    s.overwrite(index, index + exp.length, `new URL(${JSON.stringify(builtUrl)}, self.location)`, { contentOnly: true });
-                }
-                if (s) {
-                    return transformStableResult(s, id, config);
-                }
-            }
-            return null;
-        }
-    };
-}
-function buildGlobPattern(ast) {
-    let pattern = '';
-    let lastElementIndex = -1;
-    for (const exp of ast.expressions) {
-        for (let i = lastElementIndex + 1; i < ast.quasis.length; i++) {
-            const el = ast.quasis[i];
-            if (el.end < exp.start) {
-                pattern += el.value.raw;
-                lastElementIndex = i;
-            }
-        }
-        pattern += '**';
-    }
-    for (let i = lastElementIndex + 1; i < ast.quasis.length; i++) {
-        pattern += ast.quasis[i].value.raw;
-    }
-    return pattern;
-}
-
 /**
  * A plugin to provide build load fallback for arbitrary request with queries.
  */
@@ -45554,9 +45889,24 @@ function completeSystemWrapPlugin() {
 }
 
 function resolveBuildOptions(raw, isBuild, logger) {
+    const deprecatedPolyfillModulePreload = raw?.polyfillModulePreload;
+    if (raw) {
+        const { polyfillModulePreload, ...rest } = raw;
+        raw = rest;
+        if (deprecatedPolyfillModulePreload !== undefined) {
+            logger.warn('polyfillModulePreload is deprecated. Use modulePreload.polyfill instead.');
+        }
+        if (deprecatedPolyfillModulePreload === false &&
+            raw.modulePreload === undefined) {
+            raw.modulePreload = { polyfill: false };
+        }
+    }
+    const modulePreload = raw?.modulePreload;
+    const defaultModulePreload = {
+        polyfill: true
+    };
     const resolved = {
         target: 'modules',
-        polyfillModulePreload: true,
         outDir: 'dist',
         assetsDir: 'assets',
         assetsInlineLimit: 4096,
@@ -45585,7 +45935,16 @@ function resolveBuildOptions(raw, isBuild, logger) {
             warnOnError: true,
             exclude: [/node_modules/],
             ...raw?.dynamicImportVarsOptions
-        }
+        },
+        // Resolve to false | object
+        modulePreload: modulePreload === false
+            ? false
+            : typeof modulePreload === 'object'
+                ? {
+                    ...defaultModulePreload,
+                    ...modulePreload
+                }
+                : defaultModulePreload
     };
     // handle special build targets
     if (resolved.target === 'modules') {
@@ -45619,7 +45978,6 @@ function resolveBuildPlugins(config) {
             watchPackageDataPlugin(config),
             ...(usePluginCommonjs ? [commonjs(options.commonjsOptions)] : []),
             dataURIPlugin(),
-            assetImportMetaUrlPlugin(config),
             ...(options.rollupOptions.plugins
                 ? options.rollupOptions.plugins.filter(Boolean)
                 : [])
@@ -45668,7 +46026,15 @@ async function doBuild(inlineConfig = {}) {
     config.logger.info(picocolors.exports.cyan(`vite v${VERSION} ${picocolors.exports.green(`building ${ssr ? `SSR bundle ` : ``}for ${config.mode}...`)}`));
     const resolve = (p) => path$n.resolve(config.root, p);
     const input = libOptions
-        ? options.rollupOptions?.input || resolve(libOptions.entry)
+        ? options.rollupOptions?.input ||
+            (typeof libOptions.entry === 'string'
+                ? resolve(libOptions.entry)
+                : Array.isArray(libOptions.entry)
+                    ? libOptions.entry.map(resolve)
+                    : Object.fromEntries(Object.entries(libOptions.entry).map(([alias, file]) => [
+                        alias,
+                        resolve(file)
+                    ])))
         : typeof options.ssr === 'string'
             ? resolve(options.ssr)
             : options.rollupOptions?.input || resolve('index.html');
@@ -45745,7 +46111,7 @@ async function doBuild(inlineConfig = {}) {
                 entryFileNames: ssr
                     ? `[name].${jsExt}`
                     : libOptions
-                        ? resolveLibFilename(libOptions, format, config.root, jsExt)
+                        ? ({ name }) => resolveLibFilename(libOptions, format, name, config.root, jsExt)
                         : path$n.posix.join(options.assetsDir, `[name].[hash].${jsExt}`),
                 chunkFileNames: libOptions
                     ? `[name].[hash].${jsExt}`
@@ -45762,23 +46128,24 @@ async function doBuild(inlineConfig = {}) {
         };
         // resolve lib mode outputs
         const outputs = resolveBuildOutputs(options.rollupOptions?.output, libOptions, config.logger);
+        const normalizedOutputs = [];
+        if (Array.isArray(outputs)) {
+            for (const resolvedOutput of outputs) {
+                normalizedOutputs.push(buildOutputOptions(resolvedOutput));
+            }
+        }
+        else {
+            normalizedOutputs.push(buildOutputOptions(outputs));
+        }
+        const outDirs = normalizedOutputs.map(({ dir }) => resolve(dir));
         // watch file changes with rollup
         if (config.build.watch) {
             config.logger.info(picocolors.exports.cyan(`\nwatching for file changes...`));
-            const output = [];
-            if (Array.isArray(outputs)) {
-                for (const resolvedOutput of outputs) {
-                    output.push(buildOutputOptions(resolvedOutput));
-                }
-            }
-            else {
-                output.push(buildOutputOptions(outputs));
-            }
             const resolvedChokidarOptions = resolveChokidarOptions(config.build.watch.chokidar);
             const { watch } = await import('rollup');
             const watcher = watch({
                 ...rollupOptions,
-                output,
+                output: normalizedOutputs,
                 watch: {
                     ...config.build.watch,
                     chokidar: resolvedChokidarOptions
@@ -45788,7 +46155,7 @@ async function doBuild(inlineConfig = {}) {
                 if (event.code === 'BUNDLE_START') {
                     config.logger.info(picocolors.exports.cyan(`\nbuild started...`));
                     if (options.write) {
-                        prepareOutDir(outDir, options.emptyOutDir, config);
+                        prepareOutDir(outDirs, options.emptyOutDir, config);
                     }
                 }
                 else if (event.code === 'BUNDLE_END') {
@@ -45806,41 +46173,56 @@ async function doBuild(inlineConfig = {}) {
         const bundle = await rollup(rollupOptions);
         parallelBuilds.push(bundle);
         const generate = (output = {}) => {
-            return bundle[options.write ? 'write' : 'generate'](buildOutputOptions(output));
+            return bundle[options.write ? 'write' : 'generate'](output);
         };
         if (options.write) {
-            prepareOutDir(outDir, options.emptyOutDir, config);
+            prepareOutDir(outDirs, options.emptyOutDir, config);
         }
-        if (Array.isArray(outputs)) {
-            const res = [];
-            for (const output of outputs) {
-                res.push(await generate(output));
-            }
-            return res;
-        }
-        else {
-            return await generate(outputs);
+        const res = [];
+        for (const output of normalizedOutputs) {
+            res.push(await generate(output));
         }
+        return Array.isArray(outputs) ? res : res[0];
     }
     catch (e) {
         outputBuildError(e);
         throw e;
     }
 }
-function prepareOutDir(outDir, emptyOutDir, config) {
-    if (fs$l.existsSync(outDir)) {
-        if (emptyOutDir == null &&
-            !normalizePath$3(outDir).startsWith(config.root + '/')) {
-            // warn if outDir is outside of root
-            config.logger.warn(picocolors.exports.yellow(`\n${picocolors.exports.bold(`(!)`)} outDir ${picocolors.exports.white(picocolors.exports.dim(outDir))} is not inside project root and will not be emptied.\n` +
-                `Use --emptyOutDir to override.\n`));
-        }
-        else if (emptyOutDir !== false) {
-            emptyDir(outDir, ['.git']);
+function prepareOutDir(outDirs, emptyOutDir, config) {
+    const nonDuplicateDirs = new Set(outDirs);
+    let outside = false;
+    if (emptyOutDir == null) {
+        for (const outDir of nonDuplicateDirs) {
+            if (fs$l.existsSync(outDir) &&
+                !normalizePath$3(outDir).startsWith(config.root + '/')) {
+                // warn if outDir is outside of root
+                config.logger.warn(picocolors.exports.yellow(`\n${picocolors.exports.bold(`(!)`)} outDir ${picocolors.exports.white(picocolors.exports.dim(outDir))} is not inside project root and will not be emptied.\n` +
+                    `Use --emptyOutDir to override.\n`));
+                outside = true;
+                break;
+            }
         }
     }
-    if (config.publicDir && fs$l.existsSync(config.publicDir)) {
-        copyDir(config.publicDir, outDir);
+    for (const outDir of nonDuplicateDirs) {
+        if (!outside && emptyOutDir !== false && fs$l.existsSync(outDir)) {
+            // skip those other outDirs which are nested in current outDir
+            const skipDirs = outDirs
+                .map((dir) => {
+                const relative = path$n.relative(outDir, dir);
+                if (relative &&
+                    !relative.startsWith('..') &&
+                    !path$n.isAbsolute(relative)) {
+                    return relative;
+                }
+                return '';
+            })
+                .filter(Boolean);
+            emptyDir(outDir, [...skipDirs, '.git']);
+        }
+        if (config.publicDir && fs$l.existsSync(config.publicDir)) {
+            copyDir(config.publicDir, outDir);
+        }
     }
 }
 function getPkgJson(root) {
@@ -45857,12 +46239,15 @@ function resolveOutputJsExtension(format, type = 'commonjs') {
         return format === 'es' ? 'mjs' : 'js';
     }
 }
-function resolveLibFilename(libOptions, format, root, extension) {
+function resolveLibFilename(libOptions, format, entryName, root, extension) {
     if (typeof libOptions.fileName === 'function') {
-        return libOptions.fileName(format);
+        return libOptions.fileName(format, entryName);
     }
     const packageJson = getPkgJson(root);
-    const name = libOptions.fileName || getPkgName(packageJson.name);
+    const name = libOptions.fileName ||
+        (typeof libOptions.entry === 'string'
+            ? getPkgName(packageJson.name)
+            : entryName);
     if (!name)
         throw new Error('Name in package.json is required if option "build.lib.fileName" is not provided.');
     extension ?? (extension = resolveOutputJsExtension(format, packageJson.type));
@@ -45874,10 +46259,15 @@ function resolveLibFilename(libOptions, format, root, extension) {
 function resolveBuildOutputs(outputs, libOptions, logger) {
     if (libOptions) {
         const formats = libOptions.formats || ['es', 'umd'];
-        if ((formats.includes('umd') || formats.includes('iife')) &&
-            !libOptions.name) {
-            throw new Error(`Option "build.lib.name" is required when output formats ` +
-                `include "umd" or "iife".`);
+        if (formats.includes('umd') || formats.includes('iife')) {
+            if (typeof libOptions.entry !== 'string' &&
+                Object.values(libOptions.entry).length > 1) {
+                throw new Error(`Multiple entry points are not supported when output formats include "umd" or "iife".`);
+            }
+            if (!libOptions.name) {
+                throw new Error(`Option "build.lib.name" is required when output formats ` +
+                    `include "umd" or "iife".`);
+            }
         }
         if (!outputs) {
             return formats.map((format) => ({ format }));
@@ -46061,7 +46451,7 @@ const relativeUrlMechanisms = {
     system: (relativePath) => getResolveUrl(`'${relativePath}', module.meta.url`),
     umd: (relativePath) => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getResolveUrl(`'file:' + __dirname + '/${relativePath}'`, `(require('u' + 'rl').URL)`)} : ${getRelativeUrlFromDocument(relativePath, true)})`
 };
-function toOutputFilePathInString(filename, type, hostId, hostType, config, format, toRelative = getToImportMetaURLBasedRelativePath(format)) {
+function toOutputFilePathInJS(filename, type, hostId, hostType, config, toRelative) {
     const { renderBuiltUrl } = config.experimental;
     let relative = config.base === '' || config.base === './';
     if (renderBuiltUrl) {
@@ -46088,7 +46478,7 @@ function toOutputFilePathInString(filename, type, hostId, hostType, config, form
     }
     return config.base + filename;
 }
-function getToImportMetaURLBasedRelativePath(format) {
+function createToImportMetaURLBasedRelativeRuntime(format) {
     const toRelativePath = relativeUrlMechanisms[format];
     return (filename, importer) => ({
         runtime: toRelativePath(path$n.posix.relative(path$n.dirname(importer), filename))
@@ -46133,7 +46523,8 @@ var build$1 = {
 	build: build,
 	resolveLibFilename: resolveLibFilename,
 	onRollupWarning: onRollupWarning,
-	toOutputFilePathInString: toOutputFilePathInString,
+	toOutputFilePathInJS: toOutputFilePathInJS,
+	createToImportMetaURLBasedRelativeRuntime: createToImportMetaURLBasedRelativeRuntime,
 	toOutputFilePathWithoutRuntime: toOutputFilePathWithoutRuntime,
 	toOutputFilePathInCss: toOutputFilePathInCss,
 	toOutputFilePathInHtml: toOutputFilePathInHtml
@@ -48936,7 +49327,7 @@ const fs$9 = require$$0__default;
 const { Readable } = require$$0$7;
 const sysPath$3 = require$$0$4;
 const { promisify: promisify$3 } = require$$0$6;
-const picomatch$1 = picomatch$4.exports;
+const picomatch$1 = picomatch$5.exports;
 
 const readdir$1 = promisify$3(fs$9.readdir);
 const stat$3 = promisify$3(fs$9.stat);
@@ -49258,7 +49649,7 @@ var normalizePath$2 = function(path, stripTrailing) {
 
 Object.defineProperty(anymatch$2.exports, "__esModule", { value: true });
 
-const picomatch = picomatch$4.exports;
+const picomatch = picomatch$5.exports;
 const normalizePath$1 = normalizePath$2;
 
 /**
@@ -52500,7 +52891,7 @@ async function resolveHttpServer({ proxy }, app, httpsOptions) {
         app);
     }
 }
-async function resolveHttpsConfig(https, cacheDir) {
+async function resolveHttpsConfig(https) {
     if (!https)
         return undefined;
     const httpsOption = isObject$2(https) ? { ...https } : {};
@@ -53062,35 +53453,35 @@ function walk(root, { onIdentifier, onImportMeta, onDynamicImport }) {
     function isInScope(name, parents) {
         return parents.some((node) => node && scopeMap.get(node)?.has(name));
     }
-    function handlePattern(p, parentFunction) {
+    function handlePattern(p, parentScope) {
         if (p.type === 'Identifier') {
-            setScope(parentFunction, p.name);
+            setScope(parentScope, p.name);
         }
         else if (p.type === 'RestElement') {
-            handlePattern(p.argument, parentFunction);
+            handlePattern(p.argument, parentScope);
         }
         else if (p.type === 'ObjectPattern') {
             p.properties.forEach((property) => {
                 if (property.type === 'RestElement') {
-                    setScope(parentFunction, property.argument.name);
+                    setScope(parentScope, property.argument.name);
                 }
                 else {
-                    handlePattern(property.value, parentFunction);
+                    handlePattern(property.value, parentScope);
                 }
             });
         }
         else if (p.type === 'ArrayPattern') {
             p.elements.forEach((element) => {
                 if (element) {
-                    handlePattern(element, parentFunction);
+                    handlePattern(element, parentScope);
                 }
             });
         }
         else if (p.type === 'AssignmentPattern') {
-            handlePattern(p.left, parentFunction);
+            handlePattern(p.left, parentScope);
         }
         else {
-            setScope(parentFunction, p.name);
+            setScope(parentScope, p.name);
         }
     }
     walk$1(root, {
@@ -53098,7 +53489,12 @@ function walk(root, { onIdentifier, onImportMeta, onDynamicImport }) {
             if (node.type === 'ImportDeclaration') {
                 return this.skip();
             }
-            parent && parentStack.unshift(parent);
+            // track parent stack, skip for "else-if"/"else" branches as acorn nests
+            // the ast within "if" nodes instead of flattening them
+            if (parent &&
+                !(parent.type === 'IfStatement' && node === parent.alternate)) {
+                parentStack.unshift(parent);
+            }
             if (node.type === 'MetaProperty' && node.meta.name === 'import') {
                 onImportMeta(node);
             }
@@ -53116,9 +53512,9 @@ function walk(root, { onIdentifier, onImportMeta, onDynamicImport }) {
                 // If it is a function declaration, it could be shadowing an import
                 // Add its name to the scope so it won't get replaced
                 if (node.type === 'FunctionDeclaration') {
-                    const parentFunction = findParentFunction(parentStack);
-                    if (parentFunction) {
-                        setScope(parentFunction, node.id.name);
+                    const parentScope = findParentScope(parentStack);
+                    if (parentScope) {
+                        setScope(parentScope, node.id.name);
                     }
                 }
                 // walk function expressions and add its arguments to known identifiers
@@ -53157,14 +53553,18 @@ function walk(root, { onIdentifier, onImportMeta, onDynamicImport }) {
                 setIsNodeInPattern(node);
             }
             else if (node.type === 'VariableDeclarator') {
-                const parentFunction = findParentFunction(parentStack);
+                const parentFunction = findParentScope(parentStack);
                 if (parentFunction) {
                     handlePattern(node.id, parentFunction);
                 }
             }
         },
         leave(node, parent) {
-            parent && parentStack.shift();
+            // untrack parent stack from above
+            if (parent &&
+                !(parent.type === 'IfStatement' && node === parent.alternate)) {
+                parentStack.shift();
+            }
         }
     });
     // emit the identifier events in BFS so the hoisted declarations
@@ -53226,11 +53626,13 @@ function isRefIdentifier(id, parent, parentStack) {
 }
 const isStaticProperty = (node) => node && node.type === 'Property' && !node.computed;
 const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
+const functionNodeTypeRE = /Function(?:Expression|Declaration)$|Method$/;
 function isFunction(node) {
-    return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
+    return functionNodeTypeRE.test(node.type);
 }
-function findParentFunction(parentStack) {
-    return parentStack.find((i) => isFunction(i));
+const scopeNodeTypeRE = /(?:Function|Class)(?:Expression|Declaration)$|Method$|^IfStatement$/;
+function findParentScope(parentStack) {
+    return parentStack.find((i) => scopeNodeTypeRE.test(i.type));
 }
 function isInDestructuringAssignment(parent, parentStack) {
     if (parent &&
@@ -53353,13 +53755,15 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     // CommonJS modules are preferred. We want to avoid ESM->ESM imports
     // whenever possible, because `hookNodeResolve` can't intercept them.
     const resolveOptions = {
-        dedupe,
+        mainFields: ['main'],
+        browserField: true,
+        conditions: [],
         extensions: ['.js', '.cjs', '.json'],
+        dedupe,
+        preserveSymlinks,
         isBuild: true,
         isProduction,
         isRequire: true,
-        mainFields: ['main'],
-        preserveSymlinks,
         root
     };
     // Since dynamic imports can happen in parallel, we need to
@@ -56578,20 +56982,20 @@ function initAsClient(websocket, address, protocols, options) {
   }
 
   const isSecure = parsedUrl.protocol === 'wss:';
-  const isUnixSocket = parsedUrl.protocol === 'ws+unix:';
-  let invalidURLMessage;
+  const isIpcUrl = parsedUrl.protocol === 'ws+unix:';
+  let invalidUrlMessage;
 
-  if (parsedUrl.protocol !== 'ws:' && !isSecure && !isUnixSocket) {
-    invalidURLMessage =
+  if (parsedUrl.protocol !== 'ws:' && !isSecure && !isIpcUrl) {
+    invalidUrlMessage =
       'The URL\'s protocol must be one of "ws:", "wss:", or "ws+unix:"';
-  } else if (isUnixSocket && !parsedUrl.pathname) {
-    invalidURLMessage = "The URL's pathname is empty";
+  } else if (isIpcUrl && !parsedUrl.pathname) {
+    invalidUrlMessage = "The URL's pathname is empty";
   } else if (parsedUrl.hash) {
-    invalidURLMessage = 'The URL contains a fragment identifier';
+    invalidUrlMessage = 'The URL contains a fragment identifier';
   }
 
-  if (invalidURLMessage) {
-    const err = new SyntaxError(invalidURLMessage);
+  if (invalidUrlMessage) {
+    const err = new SyntaxError(invalidUrlMessage);
 
     if (websocket._redirects === 0) {
       throw err;
@@ -56661,7 +57065,7 @@ function initAsClient(websocket, address, protocols, options) {
     opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
   }
 
-  if (isUnixSocket) {
+  if (isIpcUrl) {
     const parts = opts.path.split(':');
 
     opts.socketPath = parts[0];
@@ -56672,9 +57076,9 @@ function initAsClient(websocket, address, protocols, options) {
 
   if (opts.followRedirects) {
     if (websocket._redirects === 0) {
-      websocket._originalUnixSocket = isUnixSocket;
+      websocket._originalIpc = isIpcUrl;
       websocket._originalSecure = isSecure;
-      websocket._originalHostOrSocketPath = isUnixSocket
+      websocket._originalHostOrSocketPath = isIpcUrl
         ? opts.socketPath
         : parsedUrl.host;
 
@@ -56692,11 +57096,11 @@ function initAsClient(websocket, address, protocols, options) {
         }
       }
     } else if (websocket.listenerCount('redirect') === 0) {
-      const isSameHost = isUnixSocket
-        ? websocket._originalUnixSocket
+      const isSameHost = isIpcUrl
+        ? websocket._originalIpc
           ? opts.socketPath === websocket._originalHostOrSocketPath
           : false
-        : websocket._originalUnixSocket
+        : websocket._originalIpc
         ? false
         : parsedUrl.host === websocket._originalHostOrSocketPath;
 
@@ -60286,9 +60690,9 @@ var lib = {exports: {}};
 
 var history = lib.exports;
 
-function spaFallbackMiddleware(root) {
-    const historySpaFallbackMiddleware = history({
-        logger: createDebugger('vite:spa-fallback'),
+function htmlFallbackMiddleware(root, spaFallback) {
+    const historyHtmlFallbackMiddleware = history({
+        logger: createDebugger('vite:html-fallback'),
         // support /dir/ without explicit index.html
         rewrites: [
             {
@@ -60299,15 +60703,17 @@ function spaFallbackMiddleware(root) {
                         return rewritten;
                     }
                     else {
-                        return `/index.html`;
+                        if (spaFallback) {
+                            return `/index.html`;
+                        }
                     }
                 }
             }
         ]
     });
     // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
-    return function viteSpaFallbackMiddleware(req, res, next) {
-        return historySpaFallbackMiddleware(req, res, next);
+    return function viteHtmlFallbackMiddleware(req, res, next) {
+        return historyHtmlFallbackMiddleware(req, res, next);
     };
 }
 
@@ -60672,7 +61078,7 @@ function indexHtmlMiddleware(server) {
             return next();
         }
         const url = req.url && cleanUrl(req.url);
-        // spa-fallback always redirects to /index.html
+        // htmlFallbackMiddleware appends '.html' to URLs
         if (url?.endsWith('.html') && req.headers['sec-fetch-dest'] !== 'script') {
             const filename = getHtmlFilename(url, server);
             if (fs$l.existsSync(filename)) {
@@ -62131,6 +62537,8 @@ async function createServer(inlineConfig = {}) {
                 watcher.close(),
                 ws.close(),
                 container.close(),
+                getDepsOptimizer(server.config)?.close(),
+                getDepsOptimizer(server.config, true)?.close(),
                 closeHttpServer()
             ]);
             server.resolvedUrls = null;
@@ -62160,7 +62568,8 @@ async function createServer(inlineConfig = {}) {
         _restartPromise: null,
         _importGlobMap: new Map(),
         _forceOptimizeOnRestart: false,
-        _pendingRequests: new Map()
+        _pendingRequests: new Map(),
+        _fsDenyGlob: picomatch$3(config.server.fs.deny, { matchBase: true })
     };
     server.transformIndexHtml = createDevHtmlTransformFn(server);
     if (!middlewareMode) {
@@ -62210,6 +62619,13 @@ async function createServer(inlineConfig = {}) {
     watcher.on('unlink', (file) => {
         handleFileAddUnlink(normalizePath$3(file), server);
     });
+    ws.on('vite:invalidate', async ({ path }) => {
+        const mod = moduleGraph.urlToModuleMap.get(path);
+        if (mod && mod.isSelfAccepting && mod.lastHMRTimestamp > 0) {
+            const file = getShortName(mod.file, config.root);
+            updateModules(file, [...mod.importers], mod.lastHMRTimestamp, server);
+        }
+    });
     if (!middlewareMode && httpServer) {
         httpServer.once('listening', () => {
             // update actual port since this may be different from initial value
@@ -62254,9 +62670,9 @@ async function createServer(inlineConfig = {}) {
     // serve static files
     middlewares.use(serveRawFsMiddleware(server));
     middlewares.use(serveStaticMiddleware(root, server));
-    // spa fallback
-    if (config.appType === 'spa') {
-        middlewares.use(spaFallbackMiddleware(root));
+    // html fallback
+    if (config.appType === 'spa' || config.appType === 'mpa') {
+        middlewares.use(htmlFallbackMiddleware(root, config.appType === 'spa'));
     }
     // run post config hooks
     // This is applied before the html middleware so that user middleware can
@@ -62885,10 +63301,10 @@ function loadEnv(mode, envDir, prefixes = 'VITE_') {
     prefixes = arraify(prefixes);
     const env = {};
     const envFiles = [
-        /** mode local file */ `.env.${mode}.local`,
-        /** mode file */ `.env.${mode}`,
+        /** default file */ `.env`,
         /** local file */ `.env.local`,
-        /** default file */ `.env`
+        /** mode file */ `.env.${mode}`,
+        /** mode local file */ `.env.${mode}.local`
     ];
     // check if there are actual env variables starting with VITE_*
     // these are typically provided inline and should be prioritized
@@ -62898,30 +63314,32 @@ function loadEnv(mode, envDir, prefixes = 'VITE_') {
             env[key] = process.env[key];
         }
     }
-    for (const file of envFiles) {
-        const path = lookupFile(envDir, [file], { pathOnly: true, rootDir: envDir });
-        if (path) {
-            const parsed = main$1.exports.parse(fs$l.readFileSync(path), {
-                debug: process.env.DEBUG?.includes('vite:dotenv') || undefined
-            });
-            // let environment variables use each other
-            main({
-                parsed,
-                // prevent process.env mutation
-                ignoreProcessEnv: true
-            });
-            // only keys that start with prefix are exposed to client
-            for (const [key, value] of Object.entries(parsed)) {
-                if (prefixes.some((prefix) => key.startsWith(prefix)) &&
-                    env[key] === undefined) {
-                    env[key] = value;
-                }
-                else if (key === 'NODE_ENV' &&
-                    process.env.VITE_USER_NODE_ENV === undefined) {
-                    // NODE_ENV override in .env file
-                    process.env.VITE_USER_NODE_ENV = value;
-                }
-            }
+    const parsed = Object.fromEntries(envFiles.flatMap((file) => {
+        const path = lookupFile(envDir, [file], {
+            pathOnly: true,
+            rootDir: envDir
+        });
+        if (!path)
+            return [];
+        return Object.entries(main$1.exports.parse(fs$l.readFileSync(path), {
+            debug: process.env.DEBUG?.includes('vite:dotenv')
+        }));
+    }));
+    // let environment variables use each other
+    main({
+        parsed,
+        // prevent process.env mutation
+        ignoreProcessEnv: true
+    });
+    // only keys that start with prefix are exposed to client
+    for (const [key, value] of Object.entries(parsed)) {
+        if (prefixes.some((prefix) => key.startsWith(prefix))) {
+            env[key] = value;
+        }
+        else if (key === 'NODE_ENV' &&
+            process.env.VITE_USER_NODE_ENV === undefined) {
+            // NODE_ENV override in .env file
+            process.env.VITE_USER_NODE_ENV = value;
         }
     }
     return env;
@@ -62934,7 +63352,7 @@ function resolveEnvPrefix({ envPrefix = 'VITE_' }) {
     return envPrefix;
 }
 
-function resolveSSROptions(ssr, buildSsrCjsExternalHeuristics, preserveSymlinks) {
+function resolveSSROptions(ssr, preserveSymlinks, buildSsrCjsExternalHeuristics) {
     ssr ?? (ssr = {});
     const optimizeDeps = ssr.optimizeDeps ?? {};
     let format = 'esm';
@@ -63065,7 +63483,12 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
     // replacement, but its implementation does work with function values.
     clientAlias, config.resolve?.alias || []));
     const resolveOptions = {
-        ...config.resolve,
+        mainFields: config.resolve?.mainFields ?? DEFAULT_MAIN_FIELDS,
+        browserField: config.resolve?.browserField ?? true,
+        conditions: config.resolve?.conditions ?? [],
+        extensions: config.resolve?.extensions ?? DEFAULT_EXTENSIONS$1,
+        dedupe: config.resolve?.dedupe ?? [],
+        preserveSymlinks: config.resolve?.preserveSymlinks ?? false,
         alias: resolvedAlias
     };
     // load .env files
@@ -63094,7 +63517,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
             ? '/'
             : './'
         : resolveBaseUrl(config.base, isBuild, logger) ?? '/';
-    const resolvedBuildOptions = resolveBuildOptions(config.build);
+    const resolvedBuildOptions = resolveBuildOptions(config.build, isBuild, logger);
     // resolve cache directory
     const pkgPath = lookupFile(resolvedRoot, [`package.json`], { pathOnly: true });
     const cacheDir = config.cacheDir
@@ -63149,7 +63572,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
         ? path$n.resolve(resolvedRoot, typeof publicDir === 'string' ? publicDir : 'public')
         : '';
     const server = resolveServerOptions(resolvedRoot, config.server, logger);
-    const ssr = resolveSSROptions(config.ssr, config.legacy?.buildSsrCjsExternalHeuristics, config.resolve?.preserveSymlinks);
+    const ssr = resolveSSROptions(config.ssr, resolveOptions.preserveSymlinks, config.legacy?.buildSsrCjsExternalHeuristics);
     const middlewareMode = config?.server?.middlewareMode;
     const optimizeDeps = config.optimizeDeps || {};
     const BASE_URL = resolvedBase;
@@ -63206,7 +63629,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
             disabled: 'build',
             ...optimizeDeps,
             esbuildOptions: {
-                preserveSymlinks: config.resolve?.preserveSymlinks,
+                preserveSymlinks: resolveOptions.preserveSymlinks,
                 ...optimizeDeps.esbuildOptions
             }
         },
@@ -63420,40 +63843,32 @@ async function bundleConfigFile(fileName, isESM) {
             {
                 name: 'externalize-deps',
                 setup(build) {
-                    build.onResolve({ filter: /.*/ }, ({ path: id, importer }) => {
+                    const options = {
+                        root: path$n.dirname(fileName),
+                        isBuild: true,
+                        isProduction: true,
+                        isRequire: !isESM,
+                        preferRelative: false,
+                        tryIndex: true,
+                        mainFields: DEFAULT_MAIN_FIELDS,
+                        browserField: false,
+                        conditions: [],
+                        dedupe: [],
+                        extensions: DEFAULT_EXTENSIONS$1,
+                        preserveSymlinks: false
+                    };
+                    build.onResolve({ filter: /.*/ }, ({ path: id, importer, kind }) => {
                         // externalize bare imports
-                        if (id[0] !== '.' && !path$n.isAbsolute(id)) {
+                        if (id[0] !== '.' && !isAbsolute(id)) {
+                            let idFsPath = tryNodeResolve(id, importer, options, false)?.id;
+                            if (idFsPath && (isESM || kind === 'dynamic-import')) {
+                                idFsPath = pathToFileURL(idFsPath).href;
+                            }
                             return {
+                                path: idFsPath,
                                 external: true
                             };
                         }
-                        // bundle the rest and make sure that the we can also access
-                        // it's third-party dependencies. externalize if not.
-                        // monorepo/
-                        // ├─ package.json
-                        // ├─ utils.js -----------> bundle (share same node_modules)
-                        // ├─ vite-project/
-                        // │  ├─ vite.config.js --> entry
-                        // │  ├─ package.json
-                        // ├─ foo-project/
-                        // │  ├─ utils.js --------> external (has own node_modules)
-                        // │  ├─ package.json
-                        const idFsPath = path$n.resolve(path$n.dirname(importer), id);
-                        const idPkgPath = lookupFile(idFsPath, [`package.json`], {
-                            pathOnly: true
-                        });
-                        if (idPkgPath) {
-                            const idPkgDir = path$n.dirname(idPkgPath);
-                            // if this file needs to go up one or more directory to reach the vite config,
-                            // that means it has it's own node_modules (e.g. foo-project)
-                            if (path$n.relative(idPkgDir, fileName).startsWith('..')) {
-                                return {
-                                    // normalize actual import after bundled as a single vite config
-                                    path: isESM ? pathToFileURL(idFsPath).href : idFsPath,
-                                    external: true
-                                };
-                            }
-                        }
                     });
                 }
             },
@@ -63547,5 +63962,8 @@ function isDepsOptimizerEnabled(config, ssr) {
         (command === 'build' && disabled === 'build') ||
         (command === 'serve' && disabled === 'dev'));
 }
+function isAbsolute(id) {
+    return path$n.isAbsolute(id) || path$n.posix.isAbsolute(id);
+}
 
 export { index$1 as A, build$1 as B, index as C, preview$1 as D, resolvePackageData as a, build as b, createServer as c, defineConfig as d, resolveConfig as e, formatPostcssSourceMap as f, resolveBaseUrl as g, getDepOptimizationConfig as h, isDepsOptimizerEnabled as i, mergeAlias as j, createFilter as k, loadConfigFromFile as l, mergeConfig as m, normalizePath$3 as n, optimizeDeps as o, preview as p, send as q, resolvePackageEntry as r, sortUserPlugins as s, transformWithEsbuild as t, createLogger as u, searchForWorkspaceRoot as v, loadEnv as w, resolveEnvPrefix as x, picocolors as y, commonjsGlobal as z };