vite 3.1.7 → 3.2.0-beta.1

package/dist/node/chunks/{dep-0ebb5606.js → dep-34b5a6bf.js}

@@ -165,14 +165,21 @@ function getEntries({ entries, customResolver }) {
         return { find: key, replacement: value, resolverFunction: resolverFunctionFromOptions };
     });
 }
+function getHookFunction(hook) {
+    if (typeof hook === 'function') {
+        return hook;
+    }
+    if (hook && 'handler' in hook && typeof hook.handler === 'function') {
+        return hook.handler;
+    }
+    return null;
+}
 function resolveCustomResolver(customResolver) {
+    if (typeof customResolver === 'function') {
+        return customResolver;
+    }
     if (customResolver) {
-        if (typeof customResolver === 'function') {
-            return customResolver;
-        }
-        if (typeof customResolver.resolveId === 'function') {
-            return customResolver.resolveId;
-        }
+        return getHookFunction(customResolver.resolveId);
     }
     return null;
 }
@@ -187,10 +194,7 @@ function alias$1(options = {}) {
     return {
         name: 'alias',
         async buildStart(inputOptions) {
-            await Promise.all([...(Array.isArray(options.entries) ? options.entries : []), options].map(({ customResolver }) => customResolver &&
-                typeof customResolver === 'object' &&
-                typeof customResolver.buildStart === 'function' &&
-                customResolver.buildStart.call(this, inputOptions)));
+            await Promise.all([...(Array.isArray(options.entries) ? options.entries : []), options].map(({ customResolver }) => { var _a; return customResolver && ((_a = getHookFunction(customResolver.buildStart)) === null || _a === void 0 ? void 0 : _a.call(this, inputOptions)); }));
         },
         resolveId(importee, importer, resolveOptions) {
             if (!importer) {
@@ -210,7 +214,7 @@ function alias$1(options = {}) {
     };
 }
 
-var picomatch$4 = {exports: {}};
+var picomatch$5 = {exports: {}};
 
 var utils$k = {};
 
@@ -1960,9 +1964,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 +1986,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 +1995,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 +2049,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 +2070,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 +2093,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 +2115,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 +2131,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 +2163,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 +2177,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 +2191,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 +2218,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 +2233,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 +2253,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 +2268,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 +2580,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;
             }
@@ -9645,16 +9649,30 @@ const schemeRegex = /^[\w+.-]+:\/\//;
  * 3. Host, guaranteed.
  * 4. Port, including ":", optional.
  * 5. Path, including "/", optional.
+ * 6. Query, including "?", optional.
+ * 7. Hash, including "#", optional.
  */
-const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?/;
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
 /**
  * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
  * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
  *
  * 1. Host, optional.
- * 2. Path, which may inclue "/", guaranteed.
- */
-const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/]*)?)?(\/?.*)/i;
+ * 2. Path, which may include "/", guaranteed.
+ * 3. Query, including "?", optional.
+ * 4. Hash, including "#", optional.
+ */
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+var UrlType;
+(function (UrlType) {
+    UrlType[UrlType["Empty"] = 1] = "Empty";
+    UrlType[UrlType["Hash"] = 2] = "Hash";
+    UrlType[UrlType["Query"] = 3] = "Query";
+    UrlType[UrlType["RelativePath"] = 4] = "RelativePath";
+    UrlType[UrlType["AbsolutePath"] = 5] = "AbsolutePath";
+    UrlType[UrlType["SchemeRelative"] = 6] = "SchemeRelative";
+    UrlType[UrlType["Absolute"] = 7] = "Absolute";
+})(UrlType || (UrlType = {}));
 function isAbsoluteUrl(input) {
     return schemeRegex.test(input);
 }
@@ -9667,35 +9685,42 @@ function isAbsolutePath(input) {
 function isFileUrl(input) {
     return input.startsWith('file:');
 }
+function isRelative(input) {
+    return /^[.?#]/.test(input);
+}
 function parseAbsoluteUrl(input) {
     const match = urlRegex.exec(input);
-    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/');
+    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
 }
 function parseFileUrl(input) {
     const match = fileRegex.exec(input);
     const path = match[2];
-    return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path);
+    return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
 }
-function makeUrl(scheme, user, host, port, path) {
+function makeUrl(scheme, user, host, port, path, query, hash) {
     return {
         scheme,
         user,
         host,
         port,
         path,
-        relativePath: false,
+        query,
+        hash,
+        type: UrlType.Absolute,
     };
 }
 function parseUrl$2(input) {
     if (isSchemeRelativeUrl(input)) {
         const url = parseAbsoluteUrl('http:' + input);
         url.scheme = '';
+        url.type = UrlType.SchemeRelative;
         return url;
     }
     if (isAbsolutePath(input)) {
         const url = parseAbsoluteUrl('http://foo.com' + input);
         url.scheme = '';
         url.host = '';
+        url.type = UrlType.AbsolutePath;
         return url;
     }
     if (isFileUrl(input))
@@ -9705,7 +9730,13 @@ function parseUrl$2(input) {
     const url = parseAbsoluteUrl('http://foo.com/' + input);
     url.scheme = '';
     url.host = '';
-    url.relativePath = true;
+    url.type = input
+        ? input.startsWith('?')
+            ? UrlType.Query
+            : input.startsWith('#')
+                ? UrlType.Hash
+                : UrlType.RelativePath
+        : UrlType.Empty;
     return url;
 }
 function stripPathFilename(path) {
@@ -9717,10 +9748,7 @@ function stripPathFilename(path) {
     return path.slice(0, index + 1);
 }
 function mergePaths(url, base) {
-    // If we're not a relative path, then we're an absolute path, and it doesn't matter what base is.
-    if (!url.relativePath)
-        return;
-    normalizePath$5(base);
+    normalizePath$5(base, base.type);
     // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
     // path).
     if (url.path === '/') {
@@ -9730,15 +9758,13 @@ function mergePaths(url, base) {
         // Resolution happens relative to the base path's directory, not the file.
         url.path = stripPathFilename(base.path) + url.path;
     }
-    // If the base path is absolute, then our path is now absolute too.
-    url.relativePath = base.relativePath;
 }
 /**
  * The path can have empty directories "//", unneeded parents "foo/..", or current directory
  * "foo/.". We need to normalize to a standard representation.
  */
-function normalizePath$5(url) {
-    const { relativePath } = url;
+function normalizePath$5(url, type) {
+    const rel = type <= UrlType.RelativePath;
     const pieces = url.path.split('/');
     // We need to preserve the first piece always, so that we output a leading slash. The item at
     // pieces[0] is an empty string.
@@ -9770,7 +9796,7 @@ function normalizePath$5(url) {
                 positive--;
                 pointer--;
             }
-            else if (relativePath) {
+            else if (rel) {
                 // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
                 // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
                 pieces[pointer++] = piece;
@@ -9798,37 +9824,60 @@ function resolve$3(input, base) {
     if (!input && !base)
         return '';
     const url = parseUrl$2(input);
-    // If we have a base, and the input isn't already an absolute URL, then we need to merge.
-    if (base && !url.scheme) {
+    let inputType = url.type;
+    if (base && inputType !== UrlType.Absolute) {
         const baseUrl = parseUrl$2(base);
-        url.scheme = baseUrl.scheme;
-        // If there's no host, then we were just a path.
-        if (!url.host) {
-            // The host, user, and port are joined, you can't copy one without the others.
-            url.user = baseUrl.user;
-            url.host = baseUrl.host;
-            url.port = baseUrl.port;
-        }
-        mergePaths(url, baseUrl);
-    }
-    normalizePath$5(url);
-    // If the input (and base, if there was one) are both relative, then we need to output a relative.
-    if (url.relativePath) {
-        // The first char is always a "/".
-        const path = url.path.slice(1);
-        if (!path)
-            return '.';
-        // If base started with a leading ".", or there is no base and input started with a ".", then we
-        // need to ensure that the relative path starts with a ".". We don't know if relative starts
-        // with a "..", though, so check before prepending.
-        const keepRelative = (base || input).startsWith('.');
-        return !keepRelative || path.startsWith('.') ? path : './' + path;
+        const baseType = baseUrl.type;
+        switch (inputType) {
+            case UrlType.Empty:
+                url.hash = baseUrl.hash;
+            // fall through
+            case UrlType.Hash:
+                url.query = baseUrl.query;
+            // fall through
+            case UrlType.Query:
+            case UrlType.RelativePath:
+                mergePaths(url, baseUrl);
+            // fall through
+            case UrlType.AbsolutePath:
+                // The host, user, and port are joined, you can't copy one without the others.
+                url.user = baseUrl.user;
+                url.host = baseUrl.host;
+                url.port = baseUrl.port;
+            // fall through
+            case UrlType.SchemeRelative:
+                // The input doesn't have a schema at least, so we need to copy at least that over.
+                url.scheme = baseUrl.scheme;
+        }
+        if (baseType > inputType)
+            inputType = baseType;
+    }
+    normalizePath$5(url, inputType);
+    const queryHash = url.query + url.hash;
+    switch (inputType) {
+        // This is impossible, because of the empty checks at the start of the function.
+        // case UrlType.Empty:
+        case UrlType.Hash:
+        case UrlType.Query:
+            return queryHash;
+        case UrlType.RelativePath: {
+            // The first char is always a "/", and we need it to be relative.
+            const path = url.path.slice(1);
+            if (!path)
+                return queryHash || '.';
+            if (isRelative(base || input) && !isRelative(path)) {
+                // If base started with a leading ".", or there is no base and input started with a ".",
+                // then we need to ensure that the relative path starts with a ".". We don't know if
+                // relative starts with a "..", though, so check before prepending.
+                return './' + path + queryHash;
+            }
+            return path + queryHash;
+        }
+        case UrlType.AbsolutePath:
+            return url.path + queryHash;
+        default:
+            return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
     }
-    // If there's no host (and no scheme/user/port), then we need to output an absolute path.
-    if (!url.scheme && !url.host)
-        return url.path;
-    // We're outputting either an absolute URL, or a protocol relative one.
-    return `${url.scheme}//${url.user}${url.host}${url.port}${url.path}`;
 }
 
 function resolve$2(input, base) {
@@ -10033,7 +10082,9 @@ class TraceMap {
         // mapping (like a "//# sourceMappingURL=") at the end of the child file.
         if (line >= decoded.length)
             return null;
-        return traceSegmentInternal(decoded[line], map._decodedMemo, line, column, GREATEST_LOWER_BOUND);
+        const segments = decoded[line];
+        const index = traceSegmentInternal(segments, map._decodedMemo, line, column, GREATEST_LOWER_BOUND);
+        return index === -1 ? null : segments[index];
     };
     originalPositionFor$1 = (map, { line, column, bias }) => {
         line--;
@@ -10046,10 +10097,12 @@ class TraceMap {
         // mapping (like a "//# sourceMappingURL=") at the end of the child file.
         if (line >= decoded.length)
             return OMapping(null, null, null, null);
-        const segment = traceSegmentInternal(decoded[line], map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
-        if (segment == null)
+        const segments = decoded[line];
+        const index = traceSegmentInternal(segments, map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+        if (index === -1)
             return OMapping(null, null, null, null);
-        if (segment.length == 1)
+        const segment = segments[index];
+        if (segment.length === 1)
             return OMapping(null, null, null, null);
         const { names, resolvedSources } = map;
         return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
@@ -10066,8 +10119,8 @@ function traceSegmentInternal(segments, memo, line, column, bias) {
     else if (bias === LEAST_UPPER_BOUND)
         index++;
     if (index === -1 || index === segments.length)
-        return null;
-    return segments[index];
+        return -1;
+    return index;
 }
 
 /**
@@ -11494,7 +11547,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 +12048,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) {
@@ -15503,7 +15586,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 === './';
 
@@ -26127,11 +26210,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) {
@@ -26774,6 +26856,11 @@ class MagicString {
 	}
 
 	overwrite(start, end, content, options) {
+		options = options || {};
+		return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+	}
+
+	update(start, end, content, options) {
 		if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
 
 		while (start < 0) start += this.original.length;
@@ -26799,7 +26886,7 @@ class MagicString {
 			options = { storeName: true };
 		}
 		const storeName = options !== undefined ? options.storeName : false;
-		const contentOnly = options !== undefined ? options.contentOnly : false;
+		const overwrite = options !== undefined ? options.overwrite : false;
 
 		if (storeName) {
 			const original = this.original.slice(start, end);
@@ -26823,7 +26910,7 @@ class MagicString {
 				chunk.edit('', false);
 			}
 
-			first.edit(content, storeName, contentOnly);
+			first.edit(content, storeName, !overwrite);
 		} else {
 			// must be inserting at the end
 			const newChunk = new Chunk(start, end, '').edit(content, storeName);
@@ -27142,7 +27229,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) => {
@@ -27165,7 +27252,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)
@@ -27186,6 +27273,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;
@@ -32875,7 +33009,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,
@@ -33323,6 +33457,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();
@@ -33341,6 +33476,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.
@@ -33356,13 +33492,11 @@ 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}+"`;
-        s.overwrite(match.index, match.index + full.length, replacementString, {
-            contentOnly: true
-        });
+        s.update(match.index, match.index + full.length, replacementString);
     }
     // Replace __VITE_PUBLIC_ASSET__5aa0ddc0__ with absolute paths
     const publicAssetUrlMap = publicAssetUrlCache.get(config);
@@ -33370,13 +33504,11 @@ 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}+"`;
-        s.overwrite(match.index, match.index + full.length, replacementString, {
-            contentOnly: true
-        });
+        s.update(match.index, match.index + full.length, replacementString);
     }
     return s;
 }
@@ -33392,6 +33524,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))) {
@@ -33651,8 +33784,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,
@@ -33661,6 +33795,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);
@@ -34184,6 +34327,282 @@ 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.update(match.index, match.index + full.length, replacementString);
+                }
+            }
+            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
@@ -34218,12 +34637,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}`);
                 }
             }
@@ -34294,6 +34716,7 @@ function resolvePlugin(resolveOptions) {
                     return normalizedFsPath;
                 }
                 if (targetWeb &&
+                    options.browserField &&
                     (res = tryResolveBrowserMapping(fsPath, importer, options, true))) {
                     return res;
                 }
@@ -34351,6 +34774,7 @@ function resolvePlugin(resolveOptions) {
                     return res;
                 }
                 if (targetWeb &&
+                    options.browserField &&
                     (res = tryResolveBrowserMapping(id, importer, options, false, external))) {
                     return res;
                 }
@@ -34438,7 +34862,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;
@@ -34761,7 +35185,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'
@@ -34770,6 +35196,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
@@ -34797,7 +35224,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;
@@ -34812,14 +35241,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);
@@ -34847,12 +35276,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
     });
 }
@@ -34885,7 +35314,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);
@@ -34909,7 +35338,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);
@@ -34960,6 +35389,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:';
@@ -35256,7 +35715,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
@@ -35294,8 +35753,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
     };
@@ -35366,7 +35825,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;
@@ -35376,9 +35835,9 @@ function cjsSsrCollectExternals(root, preserveSymlinks, ssrExternals, seen, logg
         ...rootPkg.devDependencies,
         ...rootPkg.dependencies
     };
-    const resolveOptions = {
+    const internalResolveOptions = {
+        ...resolveOptions,
         root,
-        preserveSymlinks,
         isProduction: false,
         isBuild: true
     };
@@ -35390,7 +35849,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 '\\'
@@ -35450,7 +35909,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) {
@@ -35682,11 +36141,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) => {
@@ -36867,7 +37326,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;
 	}
@@ -37033,7 +37492,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']) {
@@ -37050,7 +37509,6 @@ function sirv (dir, opts={}) {
 	};
 }
 
-const { isMatch } = micromatch_1;
 const sirvOptions = (headers) => {
     return {
         dev: true,
@@ -37159,12 +37617,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;
@@ -37479,7 +37936,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'
@@ -37513,8 +37970,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);
@@ -38163,276 +38620,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
  */
@@ -38630,7 +38817,7 @@ function definePlugin(config) {
                 const start = match.index;
                 const end = start + match[0].length;
                 const replacement = '' + replacements[match[1]];
-                s.overwrite(start, end, replacement, { contentOnly: true });
+                s.update(start, end, replacement);
             }
             if (!hasReplaced) {
                 return null;
@@ -38648,7 +38835,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)) {
@@ -40118,14 +40305,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' };
@@ -40144,6 +40333,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) {
@@ -40169,20 +40359,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.update(urlIndex, urlIndex + exp.length, `new URL(${JSON.stringify(builtUrl)}, self.location)`);
                 }
                 if (s) {
                     return transformStableResult(s, id, config);
@@ -40193,6 +40396,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.update(index, index + exp.length, `new URL((import.meta.glob(${pattern}, { eager: true, import: 'default', as: 'url' }))[${rawUrl}], self.location)`);
+                            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.update(index, index + exp.length, `new URL(${JSON.stringify(builtUrl)}, self.location)`);
+                }
+                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.
  */
@@ -40374,6 +40690,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,
@@ -40493,13 +40815,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) ||
@@ -40540,6 +40864,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),
@@ -41470,7 +41795,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({
@@ -41615,6 +41940,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,
@@ -41627,6 +41953,7 @@ async function createDepsOptimizer(config, server) {
         delayDepsOptimizerUntil,
         resetRegisteredIds,
         ensureFirstRun,
+        close,
         options: getDepOptimizationConfig(config, ssr)
     };
     depsOptimizerMap.set(config, depsOptimizer);
@@ -41655,6 +41982,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;
@@ -41752,13 +42085,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
@@ -42027,7 +42367,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);
@@ -42058,7 +42398,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();
                         }
@@ -42094,6 +42434,7 @@ async function createDevSsrDepsOptimizer(config) {
         delayDepsOptimizerUntil: (id, done) => { },
         resetRegisteredIds: () => { },
         ensureFirstRun: () => { },
+        close: async () => { },
         options: config.ssr.optimizeDeps
     };
     devSsrDepsOptimizerMap.set(config, depsOptimizer);
@@ -42703,7 +43044,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
@@ -42803,6 +43149,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.
@@ -42820,6 +43170,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);
@@ -42830,8 +43181,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
@@ -42859,14 +43223,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',
@@ -42952,7 +43341,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
@@ -42986,9 +43377,7 @@ function buildImportAnalysisPlugin(config) {
                                 let rewrittenUrl = JSON.stringify(file);
                                 if (!isDynamicImport)
                                     rewrittenUrl = rewrittenUrl.slice(1, -1);
-                                str().overwrite(start, end, rewrittenUrl, {
-                                    contentOnly: true
-                                });
+                                str().update(start, end, rewrittenUrl);
                             }
                         }
                     }
@@ -43007,9 +43396,7 @@ function buildImportAnalysisPlugin(config) {
                     // edge case for package names ending with .css (e.g normalize.css)
                     !(bareImportRE.test(specifier) && !specifier.includes('/'))) {
                     const url = specifier.replace(/\?|$/, (m) => `?used${m ? '&' : ''}`);
-                    str().overwrite(start, end, isDynamicImport ? `'${url}'` : url, {
-                        contentOnly: true
-                    });
+                    str().update(start, end, isDynamicImport ? `'${url}'` : url);
                 }
             }
             if (needPreloadHelper &&
@@ -43033,7 +43420,7 @@ function buildImportAnalysisPlugin(config) {
                     const s = new MagicString(code);
                     let match;
                     while ((match = re.exec(code))) {
-                        s.overwrite(match.index, match.index + isModernFlag.length, isModern, { contentOnly: true });
+                        s.update(match.index, match.index + isModernFlag.length, isModern);
                     }
                     return {
                         code: s.toString(),
@@ -43047,7 +43434,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) {
@@ -43056,7 +43446,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);
                     }
@@ -43078,7 +43468,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();
@@ -43091,10 +43483,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);
@@ -43106,13 +43500,10 @@ function buildImportAnalysisPlugin(config) {
                                                 });
                                                 hasRemovedPureCssChunk = true;
                                             }
-                                            s.overwrite(expStart, expEnd, 'Promise.resolve({})', {
-                                                contentOnly: true
-                                            });
+                                            s.update(expStart, expEnd, 'Promise.resolve({})');
                                         }
                                     }
                                 };
-                                const normalizedFile = path$n.posix.join(path$n.posix.dirname(chunk.fileName), url);
                                 addDeps(normalizedFile);
                             }
                             let markerStartPos = code.indexOf(preloadMarkerWithQuote, end);
@@ -43121,19 +43512,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.update(markerStartPos, markerStartPos + preloadMarkerWithQuote.length, `[${renderedDeps.join(',')}]`);
                                 rewroteMarkerStartPos.add(markerStartPos);
                             }
                         }
@@ -43143,7 +43568,7 @@ function buildImportAnalysisPlugin(config) {
                     let markerStartPos = code.indexOf(preloadMarkerWithQuote);
                     while (markerStartPos >= 0) {
                         if (!rewroteMarkerStartPos.has(markerStartPos)) {
-                            s.overwrite(markerStartPos, markerStartPos + preloadMarkerWithQuote.length, 'void 0', { contentOnly: true });
+                            s.update(markerStartPos, markerStartPos + preloadMarkerWithQuote.length, 'void 0');
                         }
                         markerStartPos = code.indexOf(preloadMarkerWithQuote, markerStartPos + preloadMarkerWithQuote.length);
                     }
@@ -43328,6 +43753,8 @@ function getScriptInfo(node) {
     let isModule = false;
     let isAsync = false;
     for (const p of node.attrs) {
+        if (p.prefix !== undefined)
+            continue;
         if (p.name === 'src') {
             if (!src) {
                 src = p;
@@ -43353,7 +43780,7 @@ function overwriteAttrValue(s, sourceCodeLocation, newValue) {
     }
     const wrapOffset = valueStart[1] === '"' || valueStart[1] === "'" ? 1 : 0;
     const valueOffset = valueStart.index + valueStart[0].length - 1;
-    s.overwrite(sourceCodeLocation.startOffset + valueOffset + wrapOffset, sourceCodeLocation.endOffset - wrapOffset, newValue, { contentOnly: true });
+    s.update(sourceCodeLocation.startOffset + valueOffset + wrapOffset, sourceCodeLocation.endOffset - wrapOffset, newValue);
     return s;
 }
 /**
@@ -43494,15 +43921,17 @@ function buildHtmlPlugin(config) {
                     const assetAttrs = assetAttrsConfig[node.nodeName];
                     if (assetAttrs) {
                         for (const p of node.attrs) {
-                            if (p.value && assetAttrs.includes(p.name)) {
-                                const attrSourceCodeLocation = node.sourceCodeLocation.attrs[p.name];
+                            const attrKey = getAttrKey(p);
+                            if (p.value && assetAttrs.includes(attrKey)) {
+                                const attrSourceCodeLocation = node.sourceCodeLocation.attrs[attrKey];
                                 // assetsUrl may be encodeURI
                                 const url = decodeURI(p.value);
                                 if (!isExcludedUrl(url)) {
                                     if (node.nodeName === 'link' &&
                                         isCSSRequest(url) &&
                                         // should not be converted if following attributes are present (#6748)
-                                        !node.attrs.some((p) => p.name === 'media' || p.name === 'disabled')) {
+                                        !node.attrs.some((p) => p.prefix === undefined &&
+                                            (p.name === 'media' || p.name === 'disabled'))) {
                                         // CSS references, convert to import
                                         const importExpression = `\nimport ${JSON.stringify(url)}`;
                                         styleUrls.push({
@@ -43527,7 +43956,9 @@ function buildHtmlPlugin(config) {
                     }
                     // <tag style="... url(...) ..."></tag>
                     // extract inline styles as virtual css and add class attribute to tag for selecting
-                    const inlineStyle = node.attrs.find((prop) => prop.name === 'style' && prop.value.includes('url(') // only url(...) in css need to emit file
+                    const inlineStyle = node.attrs.find((prop) => prop.prefix === undefined &&
+                        prop.name === 'style' &&
+                        prop.value.includes('url(') // only url(...) in css need to emit file
                     );
                     if (inlineStyle) {
                         inlineModuleIndex++;
@@ -43554,7 +43985,7 @@ function buildHtmlPlugin(config) {
                         js += `\nimport "${id}?html-proxy&inline-css&index=${inlineModuleIndex}.css"`;
                         const hash = getHash(cleanUrl(id));
                         // will transform in `applyHtmlTransforms`
-                        s.overwrite(styleNode.sourceCodeLocation.startOffset, styleNode.sourceCodeLocation.endOffset, `__VITE_INLINE_CSS__${hash}_${inlineModuleIndex}__`, { contentOnly: true });
+                        s.update(styleNode.sourceCodeLocation.startOffset, styleNode.sourceCodeLocation.endOffset, `__VITE_INLINE_CSS__${hash}_${inlineModuleIndex}__`);
                     }
                     if (shouldRemove) {
                         // remove the script tag from the html. we are going to inject new
@@ -43578,7 +44009,7 @@ function buildHtmlPlugin(config) {
                         !namedOutput.includes(content.replace(/^\//, '')) // Allow for absolute references as named output can't be an absolute path
                     ) {
                         try {
-                            const url = attr.name === 'srcset'
+                            const url = attr.prefix === undefined && attr.name === 'srcset'
                                 ? await processSrcSet(content, ({ url }) => urlToBuiltUrl(url, id, config, this))
                                 : await urlToBuiltUrl(content, id, config, this);
                             overwriteAttrValue(s, sourceCodeLocation, url);
@@ -43593,12 +44024,10 @@ function buildHtmlPlugin(config) {
                 // emit <script>import("./aaa")</script> asset
                 for (const { start, end, url } of scriptUrls) {
                     if (!isExcludedUrl(url)) {
-                        s.overwrite(start, end, await urlToBuiltUrl(url, id, config, this), { contentOnly: true });
+                        s.update(start, end, await urlToBuiltUrl(url, id, config, this));
                     }
                     else if (checkPublicFile(url, config)) {
-                        s.overwrite(start, end, toOutputPublicFilePath(url), {
-                            contentOnly: true
-                        });
+                        s.update(start, end, toOutputPublicFilePath(url));
                     }
                 }
                 // ignore <link rel="stylesheet"> if its url can't be resolved
@@ -43618,7 +44047,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}`;
                 }
@@ -43649,12 +44080,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()) => {
@@ -43713,12 +44144,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);
                 }
@@ -43744,7 +44189,7 @@ function buildHtmlPlugin(config) {
                     s || (s = new MagicString(result));
                     const { 0: full, 1: scopedName } = match;
                     const cssTransformedCode = htmlProxyResult.get(scopedName);
-                    s.overwrite(match.index, match.index + full.length, cssTransformedCode, { contentOnly: true });
+                    s.update(match.index, match.index + full.length, cssTransformedCode);
                 }
                 if (s) {
                     result = s.toString();
@@ -43984,8 +44429,11 @@ function serializeAttrs(attrs) {
 function incrementIndent(indent = '') {
     return `${indent}${indent[0] === '\t' ? '\t' : '  '}`;
 }
+function getAttrKey(attr) {
+    return attr.prefix === undefined ? attr.name : `${attr.prefix}:${attr.name}`;
+}
 
-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/;
@@ -44002,7 +44450,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';
 }
@@ -44440,8 +44888,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 &&
@@ -44496,9 +44944,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) {
@@ -44520,7 +44972,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-77359784.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-46ac452b.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -44668,8 +45120,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;
     }
@@ -44705,7 +45158,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
@@ -44930,8 +45383,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 = {
@@ -45204,6 +45657,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 = {};
@@ -45290,6 +45746,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;
@@ -45429,87 +45889,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.
  */
@@ -45563,9 +45942,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,
@@ -45594,7 +45988,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') {
@@ -45628,7 +46031,6 @@ function resolveBuildPlugins(config) {
             watchPackageDataPlugin(config),
             ...(usePluginCommonjs ? [commonjs(options.commonjsOptions)] : []),
             dataURIPlugin(),
-            assetImportMetaUrlPlugin(config),
             ...(options.rollupOptions.plugins
                 ? options.rollupOptions.plugins.filter(Boolean)
                 : [])
@@ -45677,7 +46079,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');
@@ -45754,7 +46164,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}`
@@ -45771,23 +46181,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
@@ -45797,7 +46208,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') {
@@ -45815,41 +46226,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);
-        }
-        if (Array.isArray(outputs)) {
-            const res = [];
-            for (const output of outputs) {
-                res.push(await generate(output));
-            }
-            return res;
+            prepareOutDir(outDirs, options.emptyOutDir, config);
         }
-        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) {
@@ -45866,12 +46292,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));
@@ -45882,11 +46311,17 @@ 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".`);
+        const hasMultipleEntries = typeof libOptions.entry !== 'string' &&
+            Object.values(libOptions.entry).length > 1;
+        const formats = libOptions.formats || (hasMultipleEntries ? ['es', 'cjs'] : ['es', 'umd']);
+        if (formats.includes('umd') || formats.includes('iife')) {
+            if (hasMultipleEntries) {
+                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 }));
@@ -46070,7 +46505,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) {
@@ -46097,7 +46532,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))
@@ -46141,8 +46576,10 @@ var build$1 = {
 	resolveBuildPlugins: resolveBuildPlugins,
 	build: build,
 	resolveLibFilename: resolveLibFilename,
+	resolveBuildOutputs: resolveBuildOutputs,
 	onRollupWarning: onRollupWarning,
-	toOutputFilePathInString: toOutputFilePathInString,
+	toOutputFilePathInJS: toOutputFilePathInJS,
+	createToImportMetaURLBasedRelativeRuntime: createToImportMetaURLBasedRelativeRuntime,
 	toOutputFilePathWithoutRuntime: toOutputFilePathWithoutRuntime,
 	toOutputFilePathInCss: toOutputFilePathInCss,
 	toOutputFilePathInHtml: toOutputFilePathInHtml
@@ -48945,7 +49382,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);
@@ -49267,7 +49704,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;
 
 /**
@@ -52509,7 +52946,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 } : {};
@@ -52964,7 +53401,7 @@ async function ssrTransformScript(code, inMap, url, originalCode) {
             }
             else {
                 // anonymous default exports
-                s.overwrite(node.start, node.start + 14 /* 'export default'.length */, `${ssrModuleExportsKey}.default =`, { contentOnly: true });
+                s.update(node.start, node.start + 14 /* 'export default'.length */, `${ssrModuleExportsKey}.default =`);
             }
         }
         // export * from './foo'
@@ -53007,16 +53444,14 @@ async function ssrTransformScript(code, inMap, url, originalCode) {
                 }
             }
             else {
-                s.overwrite(id.start, id.end, binding, { contentOnly: true });
+                s.update(id.start, id.end, binding);
             }
         },
         onImportMeta(node) {
-            s.overwrite(node.start, node.end, ssrImportMetaKey, { contentOnly: true });
+            s.update(node.start, node.end, ssrImportMetaKey);
         },
         onDynamicImport(node) {
-            s.overwrite(node.start, node.start + 6, ssrDynamicImportKey, {
-                contentOnly: true
-            });
+            s.update(node.start, node.start + 6, ssrDynamicImportKey);
             if (node.type === 'ImportExpression' && node.source.type === 'Literal') {
                 dynamicDeps.add(node.source.value);
             }
@@ -53382,13 +53817,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
@@ -56607,20 +57044,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;
@@ -56690,7 +57127,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];
@@ -56701,9 +57138,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;
 
@@ -56721,11 +57158,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;
 
@@ -60315,9 +60752,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: [
             {
@@ -60328,15 +60765,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);
     };
 }
 
@@ -60586,7 +61025,7 @@ const processNodeUrl = (attr, sourceCodeLocation, s, config, htmlPath, originalU
         // path will add `/a/` prefix, it will caused 404.
         // rewrite before `./index.js` -> `localhost:5173/a/index.js`.
         // rewrite after `../index.js` -> `localhost:5173/index.js`.
-        const processedUrl = attr.name === 'srcset'
+        const processedUrl = attr.name === 'srcset' && attr.prefix === undefined
             ? processSrcSetSync(url, ({ url }) => replacer(url))
             : replacer(url);
         overwriteAttrValue(s, sourceCodeLocation, processedUrl);
@@ -60637,7 +61076,7 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
         if (module) {
             server?.moduleGraph.invalidateModule(module);
         }
-        s.overwrite(node.sourceCodeLocation.startOffset, node.sourceCodeLocation.endOffset, `<script type="module" src="${modulePath}"></script>`, { contentOnly: true });
+        s.update(node.sourceCodeLocation.startOffset, node.sourceCodeLocation.endOffset, `<script type="module" src="${modulePath}"></script>`);
     };
     await traverseHtml(html, htmlPath, (node) => {
         if (!nodeIsElement(node)) {
@@ -60665,8 +61104,9 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
         const assetAttrs = assetAttrsConfig[node.nodeName];
         if (assetAttrs) {
             for (const p of node.attrs) {
-                if (p.value && assetAttrs.includes(p.name)) {
-                    processNodeUrl(p, node.sourceCodeLocation.attrs[p.name], s, config, htmlPath, originalUrl);
+                const attrKey = getAttrKey(p);
+                if (p.value && assetAttrs.includes(attrKey)) {
+                    processNodeUrl(p, node.sourceCodeLocation.attrs[attrKey], s, config, htmlPath, originalUrl);
                 }
             }
         }
@@ -60701,7 +61141,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)) {
@@ -62160,6 +62600,8 @@ async function createServer(inlineConfig = {}) {
                 watcher.close(),
                 ws.close(),
                 container.close(),
+                getDepsOptimizer(server.config)?.close(),
+                getDepsOptimizer(server.config, true)?.close(),
                 closeHttpServer()
             ]);
             server.resolvedUrls = null;
@@ -62189,7 +62631,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) {
@@ -62239,6 +62682,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
@@ -62283,9 +62733,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
@@ -62914,10 +63364,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
@@ -62927,30 +63377,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;
@@ -62963,7 +63415,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';
@@ -63094,7 +63546,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
@@ -63123,7 +63580,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
@@ -63178,7 +63635,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;
@@ -63235,7 +63692,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
             disabled: 'build',
             ...optimizeDeps,
             esbuildOptions: {
-                preserveSymlinks: config.resolve?.preserveSymlinks,
+                preserveSymlinks: resolveOptions.preserveSymlinks,
                 ...optimizeDeps.esbuildOptions
             }
         },
@@ -63457,6 +63914,7 @@ async function bundleConfigFile(fileName, isESM) {
                         preferRelative: false,
                         tryIndex: true,
                         mainFields: [],
+                        browserField: false,
                         conditions: [],
                         dedupe: [],
                         extensions: DEFAULT_EXTENSIONS$1,