vite 3.0.0-alpha.11 → 3.0.0-alpha.14

package/dist/node/chunks/{dep-46501b7a.js → dep-dc88b587.js}

@@ -1,34 +1,45 @@
-import * as fs$n from 'fs';
-import fs__default, { readFileSync, existsSync, statSync as statSync$1, promises, readdirSync } from 'fs';
-import path$p, { sep, resolve as resolve$4, posix as posix$1, dirname as dirname$1, extname, basename as basename$1, join as join$1, win32 as win32$1, isAbsolute as isAbsolute$3, normalize, relative as relative$1 } from 'path';
-import require$$0$8, { URL as URL$3, pathToFileURL, URLSearchParams, parse as parse$m } from 'url';
-import { performance } from 'perf_hooks';
-import require$$0$7, { createRequire as createRequire$1, builtinModules } from 'module';
-import require$$0$2 from 'tty';
+import fs$n, { promises as promises$2 } from 'node:fs';
+import path$q, { resolve as resolve$5, join as join$2, posix as posix$2, isAbsolute as isAbsolute$4, relative as relative$1, dirname as dirname$2, basename as basename$2, extname as extname$1 } from 'node:path';
+import { URL as URL$3, pathToFileURL, URLSearchParams, parse as parse$m } from 'node:url';
+import { performance } from 'node:perf_hooks';
+import { createRequire as createRequire$1, builtinModules } from 'node:module';
+import require$$0$3 from 'tty';
 import { transform as transform$2, build as build$3, formatMessages } from 'esbuild';
-import require$$0$3 from 'events';
-import require$$5 from 'assert';
+import path$p, { sep, resolve as resolve$4, posix as posix$1, dirname as dirname$1, extname, basename as basename$1, join as join$1, win32 as win32$1, isAbsolute as isAbsolute$3, normalize } from 'path';
+import * as require$$0$2 from 'fs';
+import require$$0__default, { readFileSync, existsSync, statSync as statSync$1, promises as promises$1, readdirSync } from 'fs';
+import require$$0$4 from 'events';
+import assert$3 from 'assert';
 import __resolve from 'resolve';
-import require$$0$4, { promisify as promisify$4 } from 'util';
+import require$$0$5, { format as format$2, inspect } from 'util';
 import require$$3$1 from 'net';
-import require$$1$3, { STATUS_CODES } from 'http';
-import require$$0$5 from 'stream';
+import require$$0$9, { pathToFileURL as pathToFileURL$1 } from 'url';
+import require$$1$3 from 'http';
+import require$$0$6 from 'stream';
 import require$$1 from 'os';
-import require$$2, { execSync } from 'child_process';
-import { promises as promises$1 } from 'dns';
-import require$$1$2, { createHash as createHash$2 } from 'crypto';
+import require$$2 from 'child_process';
+import os$3 from 'node:os';
+import { createHash as createHash$2 } from 'node:crypto';
+import { promisify as promisify$4 } from 'node:util';
+import { promises } from 'node:dns';
 import { CLIENT_ENTRY, DEFAULT_EXTENSIONS as DEFAULT_EXTENSIONS$1, VALID_ID_PREFIX, FS_PREFIX, wildcardHosts, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, loopbackHosts, DEFAULT_MAIN_FIELDS, DEP_VERSION_RE, OPTIMIZABLE_ENTRY_RE, SPECIAL_QUERY_RE, KNOWN_ASSET_TYPES, JS_TYPES_RE, CLIENT_DIR, NULL_BYTE_PLACEHOLDER, VERSION, VITE_PACKAGE_DIR, ENV_ENTRY, DEFAULT_ASSETS_RE } from '../constants.js';
-import require$$0$6 from 'buffer';
+import require$$1$2 from 'crypto';
+import require$$0$7 from 'buffer';
 import * as qs from 'querystring';
-import zlib$1, { gzip } from 'zlib';
-import require$$1$4, { createServer as createServer$2 } from 'https';
+import require$$0$8, { createRequire as createRequire$2 } from 'module';
+import require$$0$a from 'zlib';
+import require$$1$4 from 'https';
 import require$$4 from 'tls';
+import { STATUS_CODES } from 'node:http';
+import { createServer as createServer$2 } from 'node:https';
 import require$$1$1 from 'worker_threads';
 import readline from 'readline';
+import { execSync } from 'node:child_process';
+import zlib$1, { gzip } from 'node:zlib';
 
-import { fileURLToPath as __cjs_fileURLToPath } from 'url';
-import { dirname as __cjs_dirname } from 'path';
-import { createRequire as __cjs_createRequire } from 'module';
+import { fileURLToPath as __cjs_fileURLToPath } from 'node:url';
+import { dirname as __cjs_dirname } from 'node:path';
+import { createRequire as __cjs_createRequire } from 'node:module';
 
 const __filename = __cjs_fileURLToPath(import.meta.url);
 const __dirname = __cjs_dirname(__filename);
@@ -57,7 +68,7 @@ function getAugmentedNamespace(n) {
 
 var picocolors = {exports: {}};
 
-let tty = require$$0$2;
+let tty = require$$0$3;
 
 let isColorSupported =
 	!("NO_COLOR" in process.env || process.argv.includes("--no-color")) &&
@@ -2648,8 +2659,8 @@ var old$1 = {};
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 var pathModule = path$p;
-var isWindows$4 = process.platform === 'win32';
-var fs$m = fs__default;
+var isWindows$5 = process.platform === 'win32';
+var fs$m = require$$0__default;
 
 // JavaScript implementation of realpath, ported from node pre-v6
 
@@ -2696,14 +2707,14 @@ function maybeCallback(cb) {
 
 // Regexp that finds the next partion of a (partial) path
 // result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
-if (isWindows$4) {
+if (isWindows$5) {
   var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
 } else {
   var nextPartRe = /(.*?)(?:[\/]+|$)/g;
 }
 
 // Regex to find the device root, including trailing slash. E.g. 'c:\\'.
-if (isWindows$4) {
+if (isWindows$5) {
   var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
 } else {
   var splitRootRe = /^[\/]*/;
@@ -2741,7 +2752,7 @@ old$1.realpathSync = function realpathSync(p, cache) {
     previous = '';
 
     // On windows, check that the root exists. On unix there is no need.
-    if (isWindows$4 && !knownHard[base]) {
+    if (isWindows$5 && !knownHard[base]) {
       fs$m.lstatSync(base);
       knownHard[base] = true;
     }
@@ -2779,7 +2790,7 @@ old$1.realpathSync = function realpathSync(p, cache) {
       // read the link if it wasn't read before
       // dev/ino always return 0 on windows, so skip the check.
       var linkTarget = null;
-      if (!isWindows$4) {
+      if (!isWindows$5) {
         var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
         if (seenLinks.hasOwnProperty(id)) {
           linkTarget = seenLinks[id];
@@ -2792,7 +2803,7 @@ old$1.realpathSync = function realpathSync(p, cache) {
       resolvedLink = pathModule.resolve(previous, linkTarget);
       // track this, if given a cache.
       if (cache) cache[base] = resolvedLink;
-      if (!isWindows$4) seenLinks[id] = linkTarget;
+      if (!isWindows$5) seenLinks[id] = linkTarget;
     }
 
     // resolve the link, then start over
@@ -2843,7 +2854,7 @@ old$1.realpath = function realpath(p, cache, cb) {
     previous = '';
 
     // On windows, check that the root exists. On unix there is no need.
-    if (isWindows$4 && !knownHard[base]) {
+    if (isWindows$5 && !knownHard[base]) {
       fs$m.lstat(base, function(err) {
         if (err) return cb(err);
         knownHard[base] = true;
@@ -2897,7 +2908,7 @@ old$1.realpath = function realpath(p, cache, cb) {
     // stat & read the link if not read before
     // call gotTarget as soon as the link target is known
     // dev/ino always return 0 on windows, so skip the check.
-    if (!isWindows$4) {
+    if (!isWindows$5) {
       var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
       if (seenLinks.hasOwnProperty(id)) {
         return gotTarget(null, seenLinks[id], base);
@@ -2907,7 +2918,7 @@ old$1.realpath = function realpath(p, cache, cb) {
       if (err) return cb(err);
 
       fs$m.readlink(base, function(err, target) {
-        if (!isWindows$4) seenLinks[id] = target;
+        if (!isWindows$5) seenLinks[id] = target;
         gotTarget(err, target);
       });
     });
@@ -2935,7 +2946,7 @@ realpath$2.realpathSync = realpathSync;
 realpath$2.monkeypatch = monkeypatch;
 realpath$2.unmonkeypatch = unmonkeypatch;
 
-var fs$l = fs__default;
+var fs$l = require$$0__default;
 var origRealpath = fs$l.realpath;
 var origRealpathSync = fs$l.realpathSync;
 
@@ -4292,7 +4303,7 @@ function ownProp$2 (obj, field) {
   return Object.prototype.hasOwnProperty.call(obj, field)
 }
 
-var fs$k = fs__default;
+var fs$k = require$$0__default;
 var path$k = path$p;
 var minimatch$2 = minimatch_1;
 var isAbsolute$2 = pathIsAbsolute.exports;
@@ -4523,7 +4534,7 @@ globSync$1.GlobSync = GlobSync$1;
 var rp$1 = fs_realpath;
 var minimatch$1 = minimatch_1;
 var path$j = path$p;
-var assert$2 = require$$5;
+var assert$2 = assert$3;
 var isAbsolute$1 = pathIsAbsolute.exports;
 var common$d = common$e;
 var setopts$1 = common$d.setopts;
@@ -5173,9 +5184,9 @@ var glob_1 = glob;
 var rp = fs_realpath;
 var minimatch = minimatch_1;
 var inherits = inherits$1.exports;
-var EE = require$$0$3.EventEmitter;
+var EE = require$$0$4.EventEmitter;
 var path$i = path$p;
-var assert$1 = require$$5;
+var assert$1 = assert$3;
 var isAbsolute = pathIsAbsolute.exports;
 var globSync = sync$c;
 var common$c = common$e;
@@ -10785,8 +10796,8 @@ var node$1 = {exports: {}};
  */
 
 (function (module, exports) {
-const tty = require$$0$2;
-const util = require$$0$4;
+const tty = require$$0$3;
+const util = require$$0$5;
 
 /**
  * This is the Node.js implementation of `debug()`.
@@ -11312,17 +11323,17 @@ function testCaseInsensitiveFS() {
     if (!CLIENT_ENTRY.endsWith('client.mjs')) {
         throw new Error(`cannot test case insensitive FS, CLIENT_ENTRY const doesn't contain client.mjs`);
     }
-    if (!fs__default.existsSync(CLIENT_ENTRY)) {
+    if (!fs$n.existsSync(CLIENT_ENTRY)) {
         throw new Error('cannot test case insensitive FS, CLIENT_ENTRY does not point to an existing file: ' +
             CLIENT_ENTRY);
     }
-    return fs__default.existsSync(CLIENT_ENTRY.replace('client.mjs', 'cLiEnT.mjs'));
+    return fs$n.existsSync(CLIENT_ENTRY.replace('client.mjs', 'cLiEnT.mjs'));
 }
 const isCaseInsensitiveFS = testCaseInsensitiveFS();
-const isWindows$3 = require$$1.platform() === 'win32';
+const isWindows$4 = os$3.platform() === 'win32';
 const VOLUME_RE = /^[A-Z]:/i;
 function normalizePath$3(id) {
-    return path$p.posix.normalize(isWindows$3 ? slash$1(id) : id);
+    return path$q.posix.normalize(isWindows$4 ? slash$1(id) : id);
 }
 function fsPathFromId(id) {
     const fsPath = normalizePath$3(id.startsWith(FS_PREFIX) ? id.slice(FS_PREFIX.length) : id);
@@ -11350,7 +11361,7 @@ function isParentDirectory(dir, file) {
         (isCaseInsensitiveFS && file.toLowerCase().startsWith(dir.toLowerCase())));
 }
 function ensureVolumeInPath(file) {
-    return isWindows$3 ? path$p.resolve(file) : file;
+    return isWindows$4 ? path$q.resolve(file) : file;
 }
 const queryRE = /\?.*$/s;
 const hashRE = /#.*$/s;
@@ -11367,7 +11378,7 @@ const isJSRequest = (url) => {
     if (knownJsSrcRE.test(url)) {
         return true;
     }
-    if (!path$p.extname(url) && !url.endsWith('/')) {
+    if (!path$q.extname(url) && !url.endsWith('/')) {
         return true;
     }
     return false;
@@ -11416,9 +11427,6 @@ const timestampRE = /\bt=\d{13}&?\b/;
 function removeTimestampQuery(url) {
     return url.replace(timestampRE, '').replace(trailingSeparatorRE, '');
 }
-function isRelativeBase(base) {
-    return base === '' || base.startsWith('.');
-}
 async function asyncReplace(input, re, replacer) {
     let match;
     let remaining = input;
@@ -11451,7 +11459,7 @@ function prettifyUrl(url, root) {
     url = removeTimestampQuery(url);
     const isAbsoluteFile = url.startsWith(root);
     if (isAbsoluteFile || url.startsWith(FS_PREFIX)) {
-        let file = path$p.relative(root, isAbsoluteFile ? url : fsPathFromId(url));
+        let file = path$q.relative(root, isAbsoluteFile ? url : fsPathFromId(url));
         const seg = file.split('/');
         const npmIndex = seg.indexOf(`node_modules`);
         const isSourceMap = file.endsWith('.map');
@@ -11476,12 +11484,12 @@ function isDefined(value) {
 }
 function lookupFile(dir, formats, options) {
     for (const format of formats) {
-        const fullPath = path$p.join(dir, format);
-        if (fs__default.existsSync(fullPath) && fs__default.statSync(fullPath).isFile()) {
-            return options?.pathOnly ? fullPath : fs__default.readFileSync(fullPath, 'utf-8');
+        const fullPath = path$q.join(dir, format);
+        if (fs$n.existsSync(fullPath) && fs$n.statSync(fullPath).isFile()) {
+            return options?.pathOnly ? fullPath : fs$n.readFileSync(fullPath, 'utf-8');
         }
     }
-    const parentDir = path$p.dirname(dir);
+    const parentDir = path$q.dirname(dir);
     if (parentDir !== dir &&
         (!options?.rootDir || parentDir.startsWith(options?.rootDir))) {
         return lookupFile(parentDir, formats, options);
@@ -11561,11 +11569,11 @@ function generateCodeFrame(source, start = 0, end) {
     return res.join('\n');
 }
 function writeFile(filename, content) {
-    const dir = path$p.dirname(filename);
-    if (!fs__default.existsSync(dir)) {
-        fs__default.mkdirSync(dir, { recursive: true });
+    const dir = path$q.dirname(filename);
+    if (!fs$n.existsSync(dir)) {
+        fs$n.mkdirSync(dir, { recursive: true });
     }
-    fs__default.writeFileSync(filename, content);
+    fs$n.writeFileSync(filename, content);
 }
 /**
  * Use fs.statSync(filename) instead of fs.existsSync(filename)
@@ -11575,7 +11583,7 @@ function writeFile(filename, content) {
  */
 function isFileReadable(filename) {
     try {
-        const stat = fs__default.statSync(filename, { throwIfNoEntry: false });
+        const stat = fs$n.statSync(filename, { throwIfNoEntry: false });
         return !!stat;
     }
     catch {
@@ -11587,45 +11595,45 @@ function isFileReadable(filename) {
  * Pass an optional `skip` array to preserve files in the root directory.
  */
 function emptyDir(dir, skip) {
-    for (const file of fs__default.readdirSync(dir)) {
+    for (const file of fs$n.readdirSync(dir)) {
         if (skip?.includes(file)) {
             continue;
         }
-        fs__default.rmSync(path$p.resolve(dir, file), { recursive: true, force: true });
+        fs$n.rmSync(path$q.resolve(dir, file), { recursive: true, force: true });
     }
 }
 function copyDir(srcDir, destDir) {
-    fs__default.mkdirSync(destDir, { recursive: true });
-    for (const file of fs__default.readdirSync(srcDir)) {
-        const srcFile = path$p.resolve(srcDir, file);
+    fs$n.mkdirSync(destDir, { recursive: true });
+    for (const file of fs$n.readdirSync(srcDir)) {
+        const srcFile = path$q.resolve(srcDir, file);
         if (srcFile === destDir) {
             continue;
         }
-        const destFile = path$p.resolve(destDir, file);
-        const stat = fs__default.statSync(srcFile);
+        const destFile = path$q.resolve(destDir, file);
+        const stat = fs$n.statSync(srcFile);
         if (stat.isDirectory()) {
             copyDir(srcFile, destFile);
         }
         else {
-            fs__default.copyFileSync(srcFile, destFile);
+            fs$n.copyFileSync(srcFile, destFile);
         }
     }
 }
-const removeDir = isWindows$3
+const removeDir = isWindows$4
     ? promisify$4(gracefulRemoveDir)
     : function removeDirSync(dir) {
-        fs__default.rmSync(dir, { recursive: true, force: true });
+        fs$n.rmSync(dir, { recursive: true, force: true });
     };
-const renameDir = isWindows$3 ? promisify$4(gracefulRename) : fs__default.renameSync;
+const renameDir = isWindows$4 ? promisify$4(gracefulRename) : fs$n.renameSync;
 function ensureWatchedFile(watcher, file, root) {
     if (file &&
         // only need to watch if out of root
         !file.startsWith(root + '/') &&
         // some rollup plugins use null bytes for private resolved Ids
         !file.includes('\0') &&
-        fs__default.existsSync(file)) {
+        fs$n.existsSync(file)) {
         // resolve file to normalized system path
-        watcher.add(path$p.resolve(file));
+        watcher.add(path$q.resolve(file));
     }
 }
 const escapedSpaceCharacters = /( |\\t|\\n|\\f|\\r)+/g;
@@ -11744,7 +11752,23 @@ function combineSourcemaps(filename, sourcemapList, excludeContent = true) {
 function unique(arr) {
     return Array.from(new Set(arr));
 }
-function resolveHostname(optionsHost) {
+/**
+ * Returns resolved localhost address when `dns.lookup` result differs from DNS
+ *
+ * `dns.lookup` result is same when defaultResultOrder is `verbatim`.
+ * Even if defaultResultOrder is `ipv4first`, `dns.lookup` result maybe same.
+ * For example, when IPv6 is not supported on that machine/network.
+ */
+async function getLocalhostAddressIfDiffersFromDNS() {
+    const [nodeResult, dnsResult] = await Promise.all([
+        promises.lookup('localhost'),
+        promises.lookup('localhost', { verbatim: true })
+    ]);
+    const isSame = nodeResult.family === dnsResult.family &&
+        nodeResult.address === dnsResult.address;
+    return isSame ? undefined : nodeResult.address;
+}
+async function resolveHostname(optionsHost) {
     let host;
     if (optionsHost === undefined || optionsHost === false) {
         // Use a secure default
@@ -11758,8 +11782,15 @@ function resolveHostname(optionsHost) {
         host = optionsHost;
     }
     // Set host name to localhost when possible
-    const name = host === undefined || wildcardHosts.has(host) ? 'localhost' : host;
-    return { host, name };
+    let name = host === undefined || wildcardHosts.has(host) ? 'localhost' : host;
+    if (host === 'localhost') {
+        // See #8647 for more details.
+        const localhostAddr = await getLocalhostAddressIfDiffersFromDNS();
+        if (localhostAddr) {
+            name = localhostAddr;
+        }
+    }
+    return { host, name, implicit: optionsHost === undefined };
 }
 function arraify(target) {
     return Array.isArray(target) ? target : [target];
@@ -11767,8 +11798,8 @@ function arraify(target) {
 function toUpperCaseDriveLetter(pathName) {
     return pathName.replace(/^\w:/, (letter) => letter.toUpperCase());
 }
-const multilineCommentsRE = /\/\*(.|[\r\n])*?\*\//gm;
-const singlelineCommentsRE = /\/\/.*/g;
+const multilineCommentsRE$1 = /\/\*(.|[\r\n])*?\*\//gm;
+const singlelineCommentsRE$1 = /\/\/.*/g;
 const requestQuerySplitRE = /\?(?!.*[\/|\}])/;
 // @ts-expect-error
 const usingDynamicImport = typeof jest === 'undefined';
@@ -11815,14 +11846,14 @@ const GRACEFUL_RENAME_TIMEOUT = 5000;
 function gracefulRename(from, to, cb) {
     const start = Date.now();
     let backoff = 0;
-    fs__default.rename(from, to, function CB(er) {
+    fs$n.rename(from, to, function CB(er) {
         if (er &&
             (er.code === 'EACCES' || er.code === 'EPERM') &&
             Date.now() - start < GRACEFUL_RENAME_TIMEOUT) {
             setTimeout(function () {
-                fs__default.stat(to, function (stater, st) {
+                fs$n.stat(to, function (stater, st) {
                     if (stater && stater.code === 'ENOENT')
-                        fs__default.rename(from, to, CB);
+                        fs$n.rename(from, to, CB);
                     else
                         CB(er);
                 });
@@ -11839,14 +11870,14 @@ const GRACEFUL_REMOVE_DIR_TIMEOUT = 5000;
 function gracefulRemoveDir(dir, cb) {
     const start = Date.now();
     let backoff = 0;
-    fs__default.rm(dir, { recursive: true }, function CB(er) {
+    fs$n.rm(dir, { recursive: true }, function CB(er) {
         if (er) {
             if ((er.code === 'ENOTEMPTY' ||
                 er.code === 'EACCES' ||
                 er.code === 'EPERM') &&
                 Date.now() - start < GRACEFUL_REMOVE_DIR_TIMEOUT) {
                 setTimeout(function () {
-                    fs__default.rm(dir, { recursive: true }, CB);
+                    fs$n.rm(dir, { recursive: true }, CB);
                 }, backoff);
                 if (backoff < 100)
                     backoff += 10;
@@ -11861,7 +11892,7 @@ function gracefulRemoveDir(dir, cb) {
     });
 }
 function emptyCssComments(raw) {
-    return raw.replace(multilineCommentsRE, (s) => ' '.repeat(s.length));
+    return raw.replace(multilineCommentsRE$1, (s) => ' '.repeat(s.length));
 }
 function mergeConfigRecursively(defaults, overrides, rootPath) {
     const merged = { ...defaults };
@@ -11951,6 +11982,19 @@ function transformResult(s, id, config) {
         map: needSourceMap ? s.generateMap({ hires: true, source: id }) : null
     };
 }
+async function asyncFlatten(arr) {
+    do {
+        arr = (await Promise.all(arr)).flat(Infinity);
+    } while (arr.some((v) => v?.then));
+    return arr;
+}
+// strip UTF-8 BOM
+function stripBomTag(content) {
+    if (content.charCodeAt(0) === 0xfeff) {
+        return content.slice(1);
+    }
+    return content;
+}
 
 /* eslint no-console: 0 */
 const LogLevels = {
@@ -12050,17 +12094,19 @@ function createLogger(level = 'info', options = {}) {
     };
     return logger;
 }
-function printCommonServerUrls(server, options, config) {
+async function printCommonServerUrls(server, options, config) {
     const address = server.address();
     const isAddressInfo = (x) => x?.address;
     if (isAddressInfo(address)) {
-        const hostname = resolveHostname(options.host);
+        const hostname = await resolveHostname(options.host);
         const protocol = options.https ? 'https' : 'http';
-        printServerUrls(hostname, protocol, address.port, config.base, config.logger.info);
+        const base = config.base === './' || config.base === '' ? '/' : config.base;
+        printServerUrls(hostname, protocol, address.port, base, config.logger.info);
     }
 }
 function printServerUrls(hostname, protocol, port, base, info) {
     const urls = [];
+    const notes = [];
     if (hostname.host && loopbackHosts.has(hostname.host)) {
         let hostnameName = hostname.name;
         if (hostnameName === '::1' ||
@@ -12071,15 +12117,16 @@ function printServerUrls(hostname, protocol, port, base, info) {
             label: 'Local',
             url: colors$1.cyan(`${protocol}://${hostnameName}:${colors$1.bold(port)}${base}`)
         });
-        if (hostname.name === 'localhost') {
+        if (hostname.implicit) {
             urls.push({
                 label: 'Network',
-                url: colors$1.dim(`use ${colors$1.white(colors$1.bold('--host'))} to expose`)
+                url: `use ${colors$1.white(colors$1.bold('--host'))} to expose`,
+                disabled: true
             });
         }
     }
     else {
-        Object.values(require$$1.networkInterfaces())
+        Object.values(os$3.networkInterfaces())
             .flatMap((nInterface) => nInterface ?? [])
             .filter((detail) => detail &&
             detail.address &&
@@ -12094,16 +12141,17 @@ function printServerUrls(hostname, protocol, port, base, info) {
             urls.push({ label, url: colors$1.cyan(url) });
         });
     }
-    const length = urls.reduce((length, { label }) => Math.max(length, label.length), 0);
-    const print = (iconWithColor, label, messageWithColor) => {
-        info(`  ${iconWithColor}  ${colors$1.bold(label)}: ${' '.repeat(length - label.length)}${messageWithColor}`);
+    const length = Math.max(...[...urls, ...notes].map(({ label }) => label.length));
+    const print = (iconWithColor, label, messageWithColor, disabled) => {
+        const message = `  ${iconWithColor}  ${label ? colors$1.bold(label) + ':' : ' '} ${' '.repeat(length - label.length)}${messageWithColor}`;
+        info(disabled ? colors$1.dim(message) : message);
     };
-    urls.forEach(({ label, url: text }) => {
-        print(colors$1.green('➜'), label, text);
+    urls.forEach(({ label, url: text, disabled }) => {
+        print(colors$1.green('➜'), label, text, disabled);
+    });
+    notes.forEach(({ label, message: text }) => {
+        print(colors$1.white('❖'), label, text);
     });
-    if (!hostname.host || wildcardHosts.has(hostname.host)) {
-        print(colors$1.bold(colors$1.blue('ⓘ')), 'Note', colors$1.dim('You are using a wildcard host. Ports might be overriden.'));
-    }
 }
 
 const writeColors = {
@@ -12128,7 +12176,7 @@ function buildReporterPlugin(config) {
             .length / 1024).toFixed(2)} KiB`;
     }
     function printFileInfo(filePath, content, type, maxLength, compressedSize = '') {
-        const outDir = normalizePath$3(path$p.relative(config.root, path$p.resolve(config.root, config.build.outDir))) + '/';
+        const outDir = normalizePath$3(path$q.relative(config.root, path$q.resolve(config.root, config.build.outDir))) + '/';
         const kibs = content.length / 1024;
         const sizeColor = kibs > chunkLimit ? colors$1.yellow : colors$1.dim;
         config.logger.info(`${colors$1.gray(colors$1.white(colors$1.dim(outDir)))}${writeColors[type](filePath.padEnd(maxLength + 2))} ${sizeColor(`${kibs.toFixed(2)} KiB${compressedSize}`)}`);
@@ -12140,7 +12188,7 @@ function buildReporterPlugin(config) {
     let transformedCount = 0;
     let chunkCount = 0;
     const logTransform = throttle((id) => {
-        writeLine(`transforming (${transformedCount}) ${colors$1.dim(path$p.relative(config.root, id))}`);
+        writeLine(`transforming (${transformedCount}) ${colors$1.dim(path$q.relative(config.root, id))}`);
     });
     return {
         name: 'vite:reporter',
@@ -12321,7 +12369,7 @@ async function tsconfigInDir(dir, options) {
     return options.tsConfigPaths.has(tsconfig) ? tsconfig : void 0;
   }
   try {
-    const stat = await promises.stat(tsconfig);
+    const stat = await promises$1.stat(tsconfig);
     if (stat.isFile() || stat.isFIFO()) {
       return tsconfig;
     }
@@ -12342,7 +12390,7 @@ async function* findTSConfig(dir, options, visited = /* @__PURE__ */ new Set())
   if (!visited.has(dir)) {
     visited.add(dir);
     try {
-      const dirents = await promises.readdir(dir, { withFileTypes: true });
+      const dirents = await promises$1.readdir(dir, { withFileTypes: true });
       for (const dirent of dirents) {
         if (dirent.isDirectory() && (!(options == null ? void 0 : options.skip) || !options.skip(dirent.name))) {
           yield* findTSConfig(path$p.resolve(dir, dirent.name), options, visited);
@@ -12479,7 +12527,7 @@ async function resolveTSConfig(filename) {
   }
   const tsconfig = path$p.resolve(filename);
   try {
-    const stat = await promises.stat(tsconfig);
+    const stat = await promises$1.stat(tsconfig);
     if (stat.isFile() || stat.isFIFO()) {
       return tsconfig;
     }
@@ -12644,7 +12692,7 @@ async function parseFile$1(tsconfigFile, cache) {
     return cache.get(tsconfigFile);
   }
   try {
-    const tsconfigJson = await promises.readFile(tsconfigFile, "utf-8");
+    const tsconfigJson = await promises$1.readFile(tsconfigFile, "utf-8");
     const json = toJson(tsconfigJson);
     const result = {
       tsconfigFile,
@@ -12696,14 +12744,14 @@ async function parseExtends(result, cache) {
 function resolveExtends(extended, from) {
   let error;
   try {
-    return createRequire$1(from).resolve(extended);
+    return createRequire$2(from).resolve(extended);
   } catch (e) {
     error = e;
   }
   if (!path$p.isAbsolute(extended) && !extended.startsWith("./") && !extended.startsWith("../")) {
     try {
       const fallbackExtended = path$p.join(extended, "tsconfig.json");
-      return createRequire$1(from).resolve(fallbackExtended);
+      return createRequire$2(from).resolve(fallbackExtended);
     } catch (e) {
       error = e;
     }
@@ -12798,7 +12846,7 @@ async function transformWithEsbuild(code, filename, options, inMap) {
     if (!loader) {
         // if the id ends with a valid ext, use it (e.g. vue blocks)
         // otherwise, cleanup the query before checking the ext
-        const ext = path$p
+        const ext = path$q
             .extname(/\.\w+$/.test(filename) ? filename : cleanUrl(filename))
             .slice(1);
         if (ext === 'cjs' || ext === 'mjs') {
@@ -13040,7 +13088,7 @@ async function loadTsconfigJsonForFile(filename) {
 function reloadOnTsconfigChange(changedFile) {
     // any tsconfig.json that's added in the workspace could be closer to a code file than a previously cached one
     // any json file in the tsconfig cache could have been used to compile ts
-    if (path$p.basename(changedFile) === 'tsconfig.json' ||
+    if (path$q.basename(changedFile) === 'tsconfig.json' ||
         (changedFile.endsWith('.json') &&
             tsconfckParseOptions?.cache?.has(changedFile))) {
         server.config.logger.info(`changed tsconfig file detected: ${changedFile} - Clearing cache and forcing full-reload to ensure typescript is compiled with updated config values.`, { clear: server.config.clearScreen, timestamp: true });
@@ -13228,16 +13276,16 @@ function manifestPlugin(config) {
         generateBundle({ format }, bundle) {
             function getChunkName(chunk) {
                 if (chunk.facadeModuleId) {
-                    let name = normalizePath$3(path$p.relative(config.root, chunk.facadeModuleId));
+                    let name = normalizePath$3(path$q.relative(config.root, chunk.facadeModuleId));
                     if (format === 'system' && !chunk.name.includes('-legacy')) {
-                        const ext = path$p.extname(name);
+                        const ext = path$q.extname(name);
                         const endPos = ext.length !== 0 ? -ext.length : undefined;
                         name = name.slice(0, endPos) + `-legacy` + ext;
                     }
                     return name.replace(/\0/g, '');
                 }
                 else {
-                    return `_` + path$p.basename(chunk.fileName);
+                    return `_` + path$q.basename(chunk.fileName);
                 }
             }
             function getInternalImports(imports) {
@@ -13283,11 +13331,20 @@ function manifestPlugin(config) {
                 }
                 return manifestChunk;
             }
+            function createAsset(chunk) {
+                return {
+                    file: chunk.fileName,
+                    src: chunk.name
+                };
+            }
             for (const file in bundle) {
                 const chunk = bundle[file];
                 if (chunk.type === 'chunk') {
                     manifest[getChunkName(chunk)] = createChunk(chunk);
                 }
+                else if (chunk.type === 'asset' && typeof chunk.name === 'string') {
+                    manifest[chunk.name] = createAsset(chunk);
+                }
             }
             outputCount++;
             const output = config.build.rollupOptions?.output;
@@ -14434,7 +14491,7 @@ async function injectSourcesContent(map, file, logger) {
     let sourceRoot;
     try {
         // The source root is undefined for virtual modules and permission errors.
-        sourceRoot = await promises.realpath(path$p.resolve(path$p.dirname(file), map.sourceRoot || ''));
+        sourceRoot = await promises$2.realpath(path$q.resolve(path$q.dirname(file), map.sourceRoot || ''));
     }
     catch { }
     const missingSources = [];
@@ -14442,9 +14499,9 @@ async function injectSourcesContent(map, file, logger) {
         if (sourcePath && !virtualSourceRE.test(sourcePath)) {
             sourcePath = decodeURI(sourcePath);
             if (sourceRoot) {
-                sourcePath = path$p.resolve(sourceRoot, sourcePath);
+                sourcePath = path$q.resolve(sourceRoot, sourcePath);
             }
-            return promises.readFile(sourcePath, 'utf-8').catch(() => {
+            return promises$2.readFile(sourcePath, 'utf-8').catch(() => {
                 missingSources.push(sourcePath);
                 return null;
             });
@@ -14596,7 +14653,7 @@ const debug$d = createDebugger('vite:resolve-details', {
 });
 function invalidatePackageData(packageCache, pkgPath) {
     packageCache.delete(pkgPath);
-    const pkgDir = path$p.dirname(pkgPath);
+    const pkgDir = path$q.dirname(pkgPath);
     packageCache.forEach((pkg, cacheKey) => {
         if (pkg.dir === pkgDir) {
             packageCache.delete(cacheKey);
@@ -14634,14 +14691,14 @@ function resolvePackageData(id, basedir, preserveSymlinks = false, packageCache)
 }
 function loadPackageData(pkgPath, preserveSymlinks, packageCache) {
     if (!preserveSymlinks) {
-        pkgPath = fs__default.realpathSync.native(pkgPath);
+        pkgPath = fs$n.realpathSync.native(pkgPath);
     }
     let cached;
     if ((cached = packageCache?.get(pkgPath))) {
         return cached;
     }
-    const data = JSON.parse(fs__default.readFileSync(pkgPath, 'utf-8'));
-    const pkgDir = path$p.dirname(pkgPath);
+    const data = JSON.parse(fs$n.readFileSync(pkgPath, 'utf-8'));
+    const pkgDir = path$q.dirname(pkgPath);
     const { sideEffects } = data;
     let hasSideEffects;
     if (typeof sideEffects === 'boolean') {
@@ -14717,15 +14774,15 @@ const isDebug$4 = process.env.DEBUG;
 const debug$c = createDebugger('vite:resolve-details', {
     onlyWhenFocused: true
 });
-function resolvePlugin(baseOptions) {
-    const { root, isBuild, isProduction, asSrc, ssrConfig, preferRelative = false } = baseOptions;
+function resolvePlugin(resolveOptions) {
+    const { root, isProduction, asSrc, ssrConfig, preferRelative = false } = resolveOptions;
     const { target: ssrTarget, noExternal: ssrNoExternal } = ssrConfig ?? {};
     return {
         name: 'vite:resolve',
         async resolveId(id, importer, resolveOpts) {
             // We need to delay depsOptimizer until here instead of passing it as an option
             // the resolvePlugin because the optimizer is created on server listen during dev
-            const depsOptimizer = baseOptions.getDepsOptimizer?.();
+            const depsOptimizer = resolveOptions.getDepsOptimizer?.();
             const ssr = resolveOpts?.ssr === true;
             if (id.startsWith(browserExternalId)) {
                 return id;
@@ -14739,8 +14796,8 @@ function resolvePlugin(baseOptions) {
             const isRequire = resolveOpts?.custom?.['node-resolve']?.isRequire ?? false;
             const options = {
                 isRequire,
-                ...baseOptions,
-                scan: resolveOpts?.scan ?? baseOptions.scan
+                ...resolveOptions,
+                scan: resolveOpts?.scan ?? resolveOptions.scan
             };
             if (importer) {
                 if (isTsRequest(importer)) {
@@ -14758,7 +14815,7 @@ function resolvePlugin(baseOptions) {
             if (asSrc && depsOptimizer?.isOptimizedDepUrl(id)) {
                 const optimizedPath = id.startsWith(FS_PREFIX)
                     ? fsPathFromId(id)
-                    : normalizePath$3(ensureVolumeInPath(path$p.resolve(root, id.slice(1))));
+                    : normalizePath$3(ensureVolumeInPath(path$q.resolve(root, id.slice(1))));
                 return optimizedPath;
             }
             // explicit fs paths that starts with /@fs/*
@@ -14773,7 +14830,7 @@ function resolvePlugin(baseOptions) {
             // URL
             // /foo -> /fs-root/foo
             if (asSrc && id.startsWith('/')) {
-                const fsPath = path$p.resolve(root, id.slice(1));
+                const fsPath = path$q.resolve(root, id.slice(1));
                 if ((res = tryFsResolve(fsPath, options))) {
                     isDebug$4 && debug$c(`[url] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
                     return res;
@@ -14783,15 +14840,15 @@ function resolvePlugin(baseOptions) {
             if (id.startsWith('.') ||
                 (preferRelative && /^\w/.test(id)) ||
                 importer?.endsWith('.html')) {
-                const basedir = importer ? path$p.dirname(importer) : process.cwd();
-                const fsPath = path$p.resolve(basedir, id);
+                const basedir = importer ? path$q.dirname(importer) : process.cwd();
+                const fsPath = path$q.resolve(basedir, id);
                 // handle browser field mapping for relative imports
                 const normalizedFsPath = normalizePath$3(fsPath);
                 if (depsOptimizer?.isOptimizedDepFile(normalizedFsPath)) {
                     // Optimized files could not yet exist in disk, resolve to the full path
                     // Inject the current browserHash version if the path doesn't have one
                     if (!normalizedFsPath.match(DEP_VERSION_RE)) {
-                        const browserHash = optimizedDepInfoFromFile(depsOptimizer.metadata, normalizedFsPath)?.browserHash;
+                        const browserHash = optimizedDepInfoFromFile(depsOptimizer.metadata({ ssr }), normalizedFsPath)?.browserHash;
                         if (browserHash) {
                             return injectQuery(normalizedFsPath, `v=${browserHash}`);
                         }
@@ -14827,7 +14884,7 @@ function resolvePlugin(baseOptions) {
                 }
             }
             // absolute fs paths
-            if (path$p.isAbsolute(id) && (res = tryFsResolve(id, options))) {
+            if (path$q.isAbsolute(id) && (res = tryFsResolve(id, options))) {
                 isDebug$4 && debug$c(`[fs] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
                 return res;
             }
@@ -14849,9 +14906,8 @@ function resolvePlugin(baseOptions) {
                 if (!external &&
                     asSrc &&
                     depsOptimizer &&
-                    (isBuild || !ssr) &&
                     !options.scan &&
-                    (res = await tryOptimizedResolve(depsOptimizer, id, importer))) {
+                    (res = await tryOptimizedResolve(depsOptimizer, ssr, id, importer))) {
                     return res;
                 }
                 if (targetWeb &&
@@ -14868,7 +14924,7 @@ function resolvePlugin(baseOptions) {
                         if (ssrNoExternal === true) {
                             let message = `Cannot bundle Node.js built-in "${id}"`;
                             if (importer) {
-                                message += ` imported from "${path$p.relative(process.cwd(), importer)}"`;
+                                message += ` imported from "${path$q.relative(process.cwd(), importer)}"`;
                             }
                             message += `. Consider disabling ssr.noExternal or remove the built-in dependency.`;
                             this.error(message);
@@ -14955,7 +15011,7 @@ function tryResolveFile(file, postfix, options, tryIndex, targetWeb, tryPrefix,
     // works and will result in massively slow subsequent checks (which are
     // unnecessary in the first place)
     if (isFileReadable(file)) {
-        if (!fs__default.statSync(file).isDirectory()) {
+        if (!fs$n.statSync(file).isDirectory()) {
             return getRealPath(file, options.preserveSymlinks) + postfix;
         }
         else if (tryIndex) {
@@ -14989,13 +15045,14 @@ function tryResolveFile(file, postfix, options, tryIndex, targetWeb, tryPrefix,
         return;
     }
     if (tryPrefix) {
-        const prefixed = `${path$p.dirname(file)}/${tryPrefix}${path$p.basename(file)}`;
+        const prefixed = `${path$q.dirname(file)}/${tryPrefix}${path$q.basename(file)}`;
         return tryResolveFile(prefixed, postfix, options, tryIndex, targetWeb);
     }
 }
 const idToPkgMap = new Map();
 function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, externalize) {
     const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
+    ssr ?? (ssr = false);
     // split id by last '>' for nested selected packages, for example:
     // 'foo > bar > baz' => 'foo > bar' & 'baz'
     // 'foo'             => ''          & 'foo'
@@ -15016,7 +15073,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
         // first path part (since periods are sadly allowed in package names).
         // At the same time, skip the first path part if it begins with "@"
         // (since "@foo/bar" should be treated as the top-level path).
-        if (possiblePkgIds.length ? path$p.extname(part) : part[0] === '@') {
+        if (possiblePkgIds.length ? path$q.extname(part) : part[0] === '@') {
             continue;
         }
         const possiblePkgId = nestedPath.slice(0, slashIndex);
@@ -15027,9 +15084,9 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
         basedir = root;
     }
     else if (importer &&
-        path$p.isAbsolute(importer) &&
-        fs__default.existsSync(cleanUrl(importer))) {
-        basedir = path$p.dirname(importer);
+        path$q.isAbsolute(importer) &&
+        fs$n.existsSync(cleanUrl(importer))) {
+        basedir = path$q.dirname(importer);
     }
     else {
         basedir = root;
@@ -15077,7 +15134,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
         if (!externalize) {
             return resolved;
         }
-        const resolvedExt = path$p.extname(resolved.id);
+        const resolvedExt = path$q.extname(resolved.id);
         let resolvedId = id;
         if (isDeepImport) {
             // check ext before externalizing - only externalize
@@ -15085,7 +15142,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
             if (resolvedExt && !resolved.id.match(/(.js|.mjs|.cjs)$/)) {
                 return;
             }
-            if (!pkg?.data.exports && path$p.extname(id) !== resolvedExt) {
+            if (!pkg?.data.exports && path$q.extname(id) !== resolvedExt) {
                 resolvedId += resolvedExt;
             }
         }
@@ -15122,7 +15179,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
         // otherwise we may introduce duplicated modules for externalized files
         // from pre-bundled deps.
         if (!isBuild) {
-            const versionHash = depsOptimizer.metadata.browserHash;
+            const versionHash = depsOptimizer.metadata({ ssr }).browserHash;
             if (versionHash && isJsType) {
                 resolved = injectQuery(resolved, `v=${versionHash}`);
             }
@@ -15131,7 +15188,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
     else {
         // this is a missing import, queue optimize-deps re-run and
         // get a resolved its optimized info
-        const optimizedInfo = depsOptimizer.registerMissingImport(id, resolved);
+        const optimizedInfo = depsOptimizer.registerMissingImport(id, resolved, ssr);
         resolved = depsOptimizer.getOptimizedDepId(optimizedInfo);
     }
     if (isBuild) {
@@ -15146,9 +15203,13 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
         return { id: resolved };
     }
 }
-async function tryOptimizedResolve(depsOptimizer, id, importer) {
+async function tryOptimizedResolve(depsOptimizer, ssr, id, importer) {
     await depsOptimizer.scanProcessing;
-    const depInfo = optimizedDepInfoFromId(depsOptimizer.metadata, id);
+    const metadata = depsOptimizer.metadata({ ssr });
+    if (!metadata) {
+        return;
+    }
+    const depInfo = optimizedDepInfoFromId(metadata, id);
     if (depInfo) {
         return depsOptimizer.getOptimizedDepId(depInfo);
     }
@@ -15156,7 +15217,7 @@ async function tryOptimizedResolve(depsOptimizer, id, importer) {
         return;
     // further check if id is imported by nested dependency
     let resolvedSrc;
-    for (const optimizedData of depsOptimizer.metadata.depInfoList) {
+    for (const optimizedData of metadata.depInfoList) {
         if (!optimizedData.src)
             continue; // Ignore chunks
         const pkgPath = optimizedData.id;
@@ -15170,7 +15231,7 @@ async function tryOptimizedResolve(depsOptimizer, id, importer) {
         if (resolvedSrc == null) {
             try {
                 // this may throw errors if unable to resolve, e.g. aliased id
-                resolvedSrc = normalizePath$3(resolveFrom(id, path$p.dirname(importer)));
+                resolvedSrc = normalizePath$3(resolveFrom(id, path$q.dirname(importer)));
             }
             catch {
                 // this is best-effort only so swallow errors
@@ -15216,9 +15277,9 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
                     // the heuristics here is to actually read the browser entry when
                     // possible and check for hints of UMD. If it is UMD, prefer "module"
                     // instead; Otherwise, assume it's ESM and use it.
-                    const resolvedBrowserEntry = tryFsResolve(path$p.join(dir, browserEntry), options);
+                    const resolvedBrowserEntry = tryFsResolve(path$q.join(dir, browserEntry), options);
                     if (resolvedBrowserEntry) {
-                        const content = fs__default.readFileSync(resolvedBrowserEntry, 'utf-8');
+                        const content = fs$n.readFileSync(resolvedBrowserEntry, 'utf-8');
                         if ((/typeof exports\s*==/.test(content) &&
                             /typeof module\s*==/.test(content)) ||
                             /module\.exports\s*=/.test(content)) {
@@ -15249,7 +15310,7 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
         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$p.extname(entry))) {
+                !options.extensions?.includes(path$q.extname(entry))) {
                 entry = '';
                 options.skipPackageJson = true;
             }
@@ -15258,7 +15319,7 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
             if (targetWeb && isObject$2(browserField)) {
                 entry = mapWithBrowserField(entry, browserField) || entry;
             }
-            const entryPointPath = path$p.join(dir, entry);
+            const entryPointPath = path$q.join(dir, entry);
             const resolvedEntryPoint = tryFsResolve(entryPointPath, options);
             if (resolvedEntryPoint) {
                 isDebug$4 &&
@@ -15318,7 +15379,7 @@ function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolv
         }
         if (!relativeId) {
             throw new Error(`Package subpath '${relativeId}' is not defined by "exports" in ` +
-                `${path$p.join(dir, 'package.json')}.`);
+                `${path$q.join(dir, 'package.json')}.`);
         }
     }
     else if (targetWeb && isObject$2(browserField)) {
@@ -15333,7 +15394,7 @@ function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolv
         }
     }
     if (relativeId) {
-        const resolved = tryFsResolve(path$p.join(dir, relativeId), options, !exportsField, // try index only if no exports field
+        const resolved = tryFsResolve(path$q.join(dir, relativeId), options, !exportsField, // try index only if no exports field
         targetWeb);
         if (resolved) {
             isDebug$4 &&
@@ -15347,10 +15408,10 @@ function tryResolveBrowserMapping(id, importer, options, isFilePath, externalize
     let res;
     const pkg = importer && idToPkgMap.get(importer);
     if (pkg && isObject$2(pkg.data.browser)) {
-        const mapId = isFilePath ? './' + slash$1(path$p.relative(pkg.dir, id)) : id;
+        const mapId = isFilePath ? './' + slash$1(path$q.relative(pkg.dir, id)) : id;
         const browserMappedPath = mapWithBrowserField(mapId, pkg.data.browser);
         if (browserMappedPath) {
-            const fsPath = path$p.join(pkg.dir, browserMappedPath);
+            const fsPath = path$q.join(pkg.dir, browserMappedPath);
             if ((res = tryFsResolve(fsPath, options))) {
                 isDebug$4 &&
                     debug$c(`[browser mapped] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
@@ -15376,9 +15437,9 @@ function tryResolveBrowserMapping(id, importer, options, isFilePath, externalize
  * - Returning `false` means this id is explicitly externalized for browser
  */
 function mapWithBrowserField(relativePathInPkgDir, map) {
-    const normalizedPath = path$p.posix.normalize(relativePathInPkgDir);
+    const normalizedPath = path$q.posix.normalize(relativePathInPkgDir);
     for (const key in map) {
-        const normalizedKey = path$p.posix.normalize(key);
+        const normalizedKey = path$q.posix.normalize(key);
         if (normalizedPath === normalizedKey ||
             equalWithoutSuffix(normalizedPath, normalizedKey, '.js') ||
             equalWithoutSuffix(normalizedPath, normalizedKey, '/index.js')) {
@@ -15392,7 +15453,7 @@ function equalWithoutSuffix(path, key, suffix) {
 function getRealPath(resolved, preserveSymlinks) {
     resolved = ensureVolumeInPath(resolved);
     if (!preserveSymlinks && browserExternalId !== resolved) {
-        resolved = fs__default.realpathSync(resolved);
+        resolved = fs$n.realpathSync(resolved);
     }
     return normalizePath$3(resolved);
 }
@@ -15438,7 +15499,7 @@ function esbuildDepPlugin(qualified, exportsData, config) {
         // explicit resolveDir - this is passed only during yarn pnp resolve for
         // entries
         if (resolveDir) {
-            _importer = normalizePath$3(path$p.join(resolveDir, '*'));
+            _importer = normalizePath$3(path$q.join(resolveDir, '*'));
         }
         else {
             // map importer ids to file paths for correct resolution
@@ -15447,6 +15508,23 @@ function esbuildDepPlugin(qualified, exportsData, config) {
         const resolver = kind.startsWith('require') ? _resolveRequire : _resolve;
         return resolver(id, _importer, undefined);
     };
+    const resolveResult = (id, resolved) => {
+        if (resolved.startsWith(browserExternalId)) {
+            return {
+                path: id,
+                namespace: 'browser-external'
+            };
+        }
+        if (isExternalUrl(resolved)) {
+            return {
+                path: resolved,
+                external: true
+            };
+        }
+        return {
+            path: path$q.resolve(resolved)
+        };
+    };
     return {
         name: 'vite:dep-pre-bundle',
         setup(build) {
@@ -15510,21 +15588,7 @@ function esbuildDepPlugin(qualified, exportsData, config) {
                 // use vite's own resolver
                 const resolved = await resolve(id, importer, kind);
                 if (resolved) {
-                    if (resolved.startsWith(browserExternalId)) {
-                        return {
-                            path: id,
-                            namespace: 'browser-external'
-                        };
-                    }
-                    if (isExternalUrl(resolved)) {
-                        return {
-                            path: resolved,
-                            external: true
-                        };
-                    }
-                    return {
-                        path: path$p.resolve(resolved)
-                    };
+                    return resolveResult(id, resolved);
                 }
             });
             // For entry files, we'll read it ourselves and construct a proxy module
@@ -15535,10 +15599,10 @@ function esbuildDepPlugin(qualified, exportsData, config) {
             // referenced via relative imports - if we don't separate the proxy and
             // the actual module, esbuild will create duplicated copies of the same
             // module!
-            const root = path$p.resolve(config.root);
+            const root = path$q.resolve(config.root);
             build.onLoad({ filter: /.*/, namespace: 'dep' }, ({ path: id }) => {
                 const entryFile = qualified[id];
-                let relativePath = normalizePath$3(path$p.relative(root, entryFile));
+                let relativePath = normalizePath$3(path$q.relative(root, entryFile));
                 if (!relativePath.startsWith('./') &&
                     !relativePath.startsWith('../') &&
                     relativePath !== '.') {
@@ -15565,24 +15629,30 @@ function esbuildDepPlugin(qualified, exportsData, config) {
                 };
             });
             build.onLoad({ filter: /.*/, namespace: 'browser-external' }, ({ path }) => {
-                return {
-                    // Return in CJS to intercept named imports. Use `Object.create` to
-                    // create the Proxy in the prototype to workaround esbuild issue. Why?
-                    //
-                    // In short, esbuild cjs->esm flow:
-                    // 1. Create empty object using `Object.create(Object.getPrototypeOf(module.exports))`.
-                    // 2. Assign props of `module.exports` to the object.
-                    // 3. Return object for ESM use.
-                    //
-                    // If we do `module.exports = new Proxy({}, {})`, step 1 returns empty object,
-                    // step 2 does nothing as there's no props for `module.exports`. The final object
-                    // is just an empty object.
-                    //
-                    // Creating the Proxy in the prototype satisfies step 1 immediately, which means
-                    // the returned object is a Proxy that we can intercept.
-                    //
-                    // Note: Skip keys that are accessed by esbuild and browser devtools.
-                    contents: `\
+                if (config.isProduction) {
+                    return {
+                        contents: 'module.exports = {}'
+                    };
+                }
+                else {
+                    return {
+                        // Return in CJS to intercept named imports. Use `Object.create` to
+                        // create the Proxy in the prototype to workaround esbuild issue. Why?
+                        //
+                        // In short, esbuild cjs->esm flow:
+                        // 1. Create empty object using `Object.create(Object.getPrototypeOf(module.exports))`.
+                        // 2. Assign props of `module.exports` to the object.
+                        // 3. Return object for ESM use.
+                        //
+                        // If we do `module.exports = new Proxy({}, {})`, step 1 returns empty object,
+                        // step 2 does nothing as there's no props for `module.exports`. The final object
+                        // is just an empty object.
+                        //
+                        // Creating the Proxy in the prototype satisfies step 1 immediately, which means
+                        // the returned object is a Proxy that we can intercept.
+                        //
+                        // Note: Skip keys that are accessed by esbuild and browser devtools.
+                        contents: `\
 module.exports = Object.create(new Proxy({}, {
   get(_, key) {
     if (
@@ -15595,16 +15665,21 @@ module.exports = Object.create(new Proxy({}, {
     }
   }
 }))`
-                };
+                    };
+                }
             });
             // yarn 2 pnp compat
             if (isRunningWithYarnPnp) {
-                build.onResolve({ filter: /.*/ }, async ({ path, importer, kind, resolveDir }) => ({
+                build.onResolve({ filter: /.*/ }, async ({ path: id, importer, kind, resolveDir, namespace }) => {
+                    const resolved = await resolve(id, importer, kind, 
                     // pass along resolveDir for entries
-                    path: await resolve(path, importer, kind, resolveDir)
-                }));
+                    namespace === 'dep' ? resolveDir : undefined);
+                    if (resolved) {
+                        return resolveResult(id, resolved);
+                    }
+                });
                 build.onLoad({ filter: /.*/ }, async (args) => ({
-                    contents: await promises.readFile(args.path),
+                    contents: await promises$2.readFile(args.path),
                     loader: 'default'
                 }));
             }
@@ -16377,7 +16452,7 @@ var toRegexRange_1 = toRegexRange$1;
  * Licensed under the MIT License.
  */
 
-const util$2 = require$$0$4;
+const util$2 = require$$0$5;
 const toRegexRange = toRegexRange_1;
 
 const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
@@ -17340,7 +17415,7 @@ braces$2.create = (input, options = {}) => {
 
 var braces_1 = braces$2;
 
-const util$1 = require$$0$4;
+const util$1 = require$$0$5;
 const braces$1 = braces_1;
 const picomatch$2 = picomatch$3;
 const utils$b = utils$k;
@@ -17984,7 +18059,7 @@ var stream$4 = {};
  * Copyright (c) 2014-2020 Teambition
  * Licensed under the MIT license.
  */
-const Stream = require$$0$5;
+const Stream = require$$0$6;
 const PassThrough = Stream.PassThrough;
 const slice = Array.prototype.slice;
 
@@ -18347,7 +18422,7 @@ var fs$h = {};
 (function (exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-const fs = fs__default;
+const fs = require$$0__default;
 exports.FILE_SYSTEM_ADAPTER = {
     lstat: fs.lstat,
     stat: fs.stat,
@@ -18708,7 +18783,7 @@ var fs$d = {};
 (function (exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-const fs = fs__default;
+const fs = require$$0__default;
 exports.FILE_SYSTEM_ADAPTER = {
     lstat: fs.lstat,
     stat: fs.stat,
@@ -19139,7 +19214,7 @@ class Reader$1 {
 reader$1.default = Reader$1;
 
 Object.defineProperty(async$2, "__esModule", { value: true });
-const events_1 = require$$0$3;
+const events_1 = require$$0$4;
 const fsScandir$2 = out$1;
 const fastq = queue.exports;
 const common$5 = common$7;
@@ -19268,7 +19343,7 @@ function callSuccessCallback(callback, entries) {
 var stream$1 = {};
 
 Object.defineProperty(stream$1, "__esModule", { value: true });
-const stream_1$5 = require$$0$5;
+const stream_1$5 = require$$0$6;
 const async_1$2 = async$2;
 class StreamProvider {
     constructor(_root, _settings) {
@@ -19476,7 +19551,7 @@ class Reader {
 reader.default = Reader;
 
 Object.defineProperty(stream$2, "__esModule", { value: true });
-const stream_1$3 = require$$0$5;
+const stream_1$3 = require$$0$6;
 const fsStat$1 = out$3;
 const fsWalk$1 = out$2;
 const reader_1$1 = reader;
@@ -19874,7 +19949,7 @@ async$6.default = ProviderAsync;
 var stream = {};
 
 Object.defineProperty(stream, "__esModule", { value: true });
-const stream_1$1 = require$$0$5;
+const stream_1$1 = require$$0$6;
 const stream_2 = stream$2;
 const provider_1$1 = provider;
 class ProviderStream extends provider_1$1.default {
@@ -19979,7 +20054,7 @@ var settings = {};
 (function (exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-const fs = fs__default;
+const fs = require$$0__default;
 const os = require$$1;
 /**
  * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
@@ -25821,10 +25896,10 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
     // TODO: use import()
     const _require = createRequire$1(import.meta.url);
     // get rollup version
-    const rollupPkgPath = resolve$4(_require.resolve('rollup'), '../../package.json');
+    const rollupPkgPath = resolve$5(_require.resolve('rollup'), '../../package.json');
     const minimalContext = {
         meta: {
-            rollupVersion: JSON.parse(fs__default.readFileSync(rollupPkgPath, 'utf-8'))
+            rollupVersion: JSON.parse(fs$n.readFileSync(rollupPkgPath, 'utf-8'))
                 .version,
             watchMode: true
         }
@@ -25985,7 +26060,7 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
                     if (err.loc.file) {
                         err.id = normalizePath$3(err.loc.file);
                         try {
-                            code = fs__default.readFileSync(err.loc.file, 'utf-8');
+                            code = fs$n.readFileSync(err.loc.file, 'utf-8');
                         }
                         catch { }
                     }
@@ -26105,7 +26180,7 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
                 }
             }));
         },
-        async resolveId(rawId, importer = join$1(root, 'index.html'), options) {
+        async resolveId(rawId, importer = join$2(root, 'index.html'), options) {
             const skip = options?.skip;
             const ssr = options?.ssr;
             const scan = !!options?.scan;
@@ -26229,7 +26304,7 @@ async function createPluginContainer({ plugins, logger, root, build: { rollupOpt
     return container;
 }
 
-function stripLiteral(code, forgiving = false) {
+function stripLiteralAcorn(code) {
   const FILL = " ";
   let result = "";
   function fulfill(index) {
@@ -26245,26 +26320,54 @@ function stripLiteral(code, forgiving = false) {
   });
   const inter = tokens[Symbol.iterator]();
   while (true) {
-    try {
-      const { done, value: token } = inter.next();
-      if (done)
-        break;
-      fulfill(token.start);
-      if (token.type.label === "string")
-        result += code[token.start] + FILL.repeat(token.end - token.start - 2) + code[token.end - 1];
-      else if (token.type.label === "template")
-        result += FILL.repeat(token.end - token.start);
-      else
-        result += code.slice(token.start, token.end);
-    } catch (e) {
-      if (!forgiving)
-        throw e;
-    }
+    const { done, value: token } = inter.next();
+    if (done)
+      break;
+    fulfill(token.start);
+    if (token.type.label === "string")
+      result += code[token.start] + FILL.repeat(token.end - token.start - 2) + code[token.end - 1];
+    else if (token.type.label === "template")
+      result += FILL.repeat(token.end - token.start);
+    else
+      result += code.slice(token.start, token.end);
   }
   fulfill(code.length);
   return result;
 }
 
+const multilineCommentsRE = /\/\*.*?\*\//gms;
+const singlelineCommentsRE = /\/\/.*$/gm;
+const templateLiteralRE = /\$\{(\s*(?:(?!\$\{).|\n|\r)*?\s*)\}/g;
+const quotesRE = [
+  /(["'`])((?:\\\1|(?!\1)|.|\r)*?)\1/gm,
+  /([`])((?:\\\1|(?!\1)|.|\n|\r)*?)\1/gm
+];
+function stripLiteralRegex(code) {
+  code = code.replace(multilineCommentsRE, (s) => " ".repeat(s.length)).replace(singlelineCommentsRE, (s) => " ".repeat(s.length));
+  let expanded = code;
+  for (let i = 0; i < 16; i++) {
+    const before = expanded;
+    expanded = expanded.replace(templateLiteralRE, "` $1`");
+    if (expanded === before)
+      break;
+  }
+  quotesRE.forEach((re) => {
+    expanded = expanded.replace(re, (s, quote, body, index) => {
+      code = code.slice(0, index + 1) + " ".repeat(s.length - 2) + code.slice(index + s.length - 1);
+      return quote + " ".repeat(s.length - 2) + quote;
+    });
+  });
+  return code;
+}
+
+function stripLiteral(code) {
+  try {
+    return stripLiteralAcorn(code);
+  } catch (e) {
+    return stripLiteralRegex(code);
+  }
+}
+
 const HASH_RE = /#/g;
 const AMPERSAND_RE = /&/g;
 const EQUAL_RE = /=/g;
@@ -26326,7 +26429,7 @@ function importGlobPlugin(config) {
         async transform(code, id) {
             if (!code.includes('import.meta.glob'))
                 return;
-            const result = await transformGlobImport(code, id, config.root, (im) => this.resolve(im, id).then((i) => i?.id || im), config.experimental?.importGlobRestoreExtension);
+            const result = await transformGlobImport(code, id, config.root, (im) => this.resolve(im, id).then((i) => i?.id || im), config.experimental.importGlobRestoreExtension);
             if (result) {
                 if (server) {
                     const allGlobs = result.matches.map((i) => i.globsResolved);
@@ -26504,7 +26607,7 @@ async function parseImportGlob(code, importer, root, resolveId) {
     return (await Promise.all(tasks)).filter(Boolean);
 }
 const importPrefix = '__vite_glob_';
-const { basename, dirname, relative, join } = posix$1;
+const { basename, dirname, relative, join } = posix$2;
 /**
  * @param optimizeExport for dynamicImportVar plugin don't need to optimize export.
  */
@@ -26619,15 +26722,15 @@ async function toAbsoluteGlob(glob, root, importer, resolveId) {
     }
     const dir = importer ? dirname(importer) : root;
     if (glob.startsWith('/'))
-        return pre + posix$1.join(root, glob.slice(1));
+        return pre + posix$2.join(root, glob.slice(1));
     if (glob.startsWith('./'))
-        return pre + posix$1.join(dir, glob.slice(2));
+        return pre + posix$2.join(dir, glob.slice(2));
     if (glob.startsWith('../'))
-        return pre + posix$1.join(dir, glob);
+        return pre + posix$2.join(dir, glob);
     if (glob.startsWith('**'))
         return pre + glob;
     const resolved = normalizePath$3((await resolveId(glob, importer)) || glob);
-    if (isAbsolute$3(resolved))
+    if (isAbsolute$4(resolved))
         return pre + resolved;
     throw new Error(`Invalid glob: "${glob}" (resolved: "${resolved}"). It must starts with '/' or './'`);
 }
@@ -26637,8 +26740,8 @@ function getCommonBase(globsResolved) {
         .map((glob) => {
         let { base } = scan(glob);
         // `scan('a/foo.js')` returns `base: 'a/foo.js'`
-        if (posix$1.basename(base).includes('.'))
-            base = posix$1.dirname(base);
+        if (posix$2.basename(base).includes('.'))
+            base = posix$2.dirname(base);
         return base;
     });
     if (!bases.length)
@@ -26681,7 +26784,7 @@ async function scanImports(config) {
         entries = await globEntries(explicitEntryPatterns, config);
     }
     else if (buildInput) {
-        const resolvePath = (p) => path$p.resolve(config.root, p);
+        const resolvePath = (p) => path$q.resolve(config.root, p);
         if (typeof buildInput === 'string') {
             entries = [resolvePath(buildInput)];
         }
@@ -26700,7 +26803,7 @@ async function scanImports(config) {
     }
     // Non-supported entry file types and virtual files should not be scanned for
     // dependencies.
-    entries = entries.filter((entry) => isScannable(entry) && fs__default.existsSync(entry));
+    entries = entries.filter((entry) => isScannable(entry) && fs$n.existsSync(entry));
     if (!entries.length) {
         if (!explicitEntryPatterns && !config.optimizeDeps.include) {
             config.logger.warn(colors$1.yellow('(!) Could not auto-determine entry point from rollupOptions or html files ' +
@@ -26764,7 +26867,7 @@ const contextRE = /\bcontext\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
 function esbuildScanPlugin(config, container, depImports, missing, entries) {
     const seen = new Map();
     const resolve = async (id, importer) => {
-        const key = id + (importer && path$p.dirname(importer));
+        const key = id + (importer && path$q.dirname(importer));
         if (seen.has(key)) {
             return seen.get(key);
         }
@@ -26829,7 +26932,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
             });
             // extract scripts inside HTML-like files and treat it as a js module
             build.onLoad({ filter: htmlTypesRE, namespace: 'html' }, async ({ path }) => {
-                let raw = fs__default.readFileSync(path, 'utf-8');
+                let raw = fs$n.readFileSync(path, 'utf-8');
                 // Avoid matching the content of the comment
                 raw = raw.replace(commentRE$1, '<!---->');
                 const isHtml = path.endsWith('.html');
@@ -26949,7 +27052,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                         const namespace = htmlTypesRE.test(resolved) ? 'html' : undefined;
                         // linked package, keep crawling
                         return {
-                            path: path$p.resolve(resolved),
+                            path: path$q.resolve(resolved),
                             namespace
                         };
                     }
@@ -26991,7 +27094,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                     }
                     const namespace = htmlTypesRE.test(resolved) ? 'html' : undefined;
                     return {
-                        path: path$p.resolve(cleanUrl(resolved)),
+                        path: path$q.resolve(cleanUrl(resolved)),
                         namespace
                     };
                 }
@@ -27004,10 +27107,10 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
             // presence of import.meta.glob, since it results in import relationships
             // but isn't crawled by esbuild.
             build.onLoad({ filter: JS_TYPES_RE }, ({ path: id }) => {
-                let ext = path$p.extname(id).slice(1);
+                let ext = path$q.extname(id).slice(1);
                 if (ext === 'mjs')
                     ext = 'js';
-                let contents = fs__default.readFileSync(id, 'utf-8');
+                let contents = fs$n.readFileSync(id, 'utf-8');
                 if (ext.endsWith('x') && config.esbuild && config.esbuild.jsxInject) {
                     contents = config.esbuild.jsxInject + `\n` + contents;
                 }
@@ -27031,8 +27134,8 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
 function extractImportPaths(code) {
     // empty singleline & multiline comments to avoid matching comments
     code = code
-        .replace(multilineCommentsRE, '/* */')
-        .replace(singlelineCommentsRE, '');
+        .replace(multilineCommentsRE$1, '/* */')
+        .replace(singlelineCommentsRE$1, '');
     let js = '';
     let m;
     while ((m = importsRE.exec(code)) != null) {
@@ -27046,7 +27149,7 @@ function extractImportPaths(code) {
 }
 function shouldExternalizeDep(resolvedId, rawId) {
     // not a valid file path
-    if (!path$p.isAbsolute(resolvedId)) {
+    if (!path$q.isAbsolute(resolvedId)) {
         return true;
     }
     // virtual id
@@ -27078,7 +27181,7 @@ var etag_1 = etag;
  */
 
 var crypto = require$$1$2;
-var Stats = fs__default.Stats;
+var Stats = require$$0__default.Stats;
 
 /**
  * Module variables.
@@ -27196,7 +27299,7 @@ var safeBuffer = {exports: {}};
 /* eslint-disable node/no-deprecated-api */
 
 (function (module, exports) {
-var buffer = require$$0$6;
+var buffer = require$$0$7;
 var Buffer = buffer.Buffer;
 
 // alternative to using Object.keys for old browsers
@@ -27260,7 +27363,7 @@ SafeBuffer.allocUnsafeSlow = function (size) {
 }(safeBuffer, safeBuffer.exports));
 
 (function (exports) {
-var fs = fs__default;
+var fs = require$$0__default;
 var path = path$p;
 var SafeBuffer = safeBuffer.exports;
 
@@ -27836,7 +27939,6 @@ function registerCustomMime() {
 function assetPlugin(config) {
     // assetHashToFilenameMap initialization in buildStart causes getAssetFilename to return undefined
     assetHashToFilenameMap.set(config, new Map());
-    const relativeBase = isRelativeBase(config.base);
     registerCustomMime();
     return {
         name: 'vite:asset',
@@ -27865,7 +27967,7 @@ function assetPlugin(config) {
             if (rawRE.test(id)) {
                 const file = checkPublicFile(id, config) || cleanUrl(id);
                 // raw query, read file and return as string
-                return `export default ${JSON.stringify(await promises.readFile(file, 'utf-8'))}`;
+                return `export default ${JSON.stringify(await promises$2.readFile(file, 'utf-8'))}`;
             }
             if (!config.assetsInclude(cleanUrl(id)) && !urlRE.test(id)) {
                 return;
@@ -27877,7 +27979,14 @@ function assetPlugin(config) {
         renderChunk(code, chunk) {
             let match;
             let s;
-            const absoluteUrlPathInterpolation = (filename) => `"+new URL(${JSON.stringify(path$p.posix.relative(path$p.dirname(chunk.fileName), filename))},import.meta.url).href+"`;
+            const absoluteUrlPathInterpolation = (filename) => `"+new URL(${JSON.stringify(path$q.posix.relative(path$q.dirname(chunk.fileName), filename))},import.meta.url).href+"`;
+            const toOutputFilePathInString = (filename, base) => {
+                return base.runtime
+                    ? `"+${base.runtime(JSON.stringify(filename))}+"`
+                    : base.relative && !config.build.ssr
+                        ? absoluteUrlPathInterpolation(filename)
+                        : JSON.stringify((base.url ?? config.base) + filename).slice(1, -1);
+            };
             // Urls added with JS using e.g.
             // imgElement.src = "__VITE_ASSET__5aa0ddc0__" are using quotes
             // Urls added in CSS that is imported in JS end up like
@@ -27891,25 +28000,21 @@ function assetPlugin(config) {
                 const file = getAssetFilename(hash, config) || this.getFileName(hash);
                 chunk.viteMetadata.importedAssets.add(cleanUrl(file));
                 const filename = file + postfix;
-                const outputFilepath = relativeBase
-                    ? absoluteUrlPathInterpolation(filename)
-                    : JSON.stringify(config.base + filename).slice(1, -1);
-                s.overwrite(match.index, match.index + full.length, outputFilepath, {
+                const replacement = toOutputFilePathInString(filename, config.experimental.buildAdvancedBaseOptions.assets);
+                s.overwrite(match.index, match.index + full.length, replacement, {
                     contentOnly: true
                 });
             }
             // Replace __VITE_PUBLIC_ASSET__5aa0ddc0__ with absolute paths
-            if (relativeBase) {
-                const publicAssetUrlMap = publicAssetUrlCache.get(config);
-                while ((match = publicAssetUrlRE.exec(code))) {
-                    s = s || (s = new MagicString(code));
-                    const [full, hash] = match;
-                    const publicUrl = publicAssetUrlMap.get(hash);
-                    const replacement = absoluteUrlPathInterpolation(publicUrl.slice(1));
-                    s.overwrite(match.index, match.index + full.length, replacement, {
-                        contentOnly: true
-                    });
-                }
+            const publicAssetUrlMap = publicAssetUrlCache.get(config);
+            while ((match = publicAssetUrlRE.exec(code))) {
+                s = s || (s = new MagicString(code));
+                const [full, hash] = match;
+                const publicUrl = publicAssetUrlMap.get(hash).slice(1);
+                const replacement = toOutputFilePathInString(publicUrl, config.experimental.buildAdvancedBaseOptions.public);
+                s.overwrite(match.index, match.index + full.length, replacement, {
+                    contentOnly: true
+                });
             }
             if (s) {
                 return {
@@ -27940,8 +28045,8 @@ function checkPublicFile(url, { publicDir }) {
     if (!publicDir || !url.startsWith('/')) {
         return;
     }
-    const publicFile = path$p.join(publicDir, cleanUrl(url));
-    if (fs__default.existsSync(publicFile)) {
+    const publicFile = path$q.join(publicDir, cleanUrl(url));
+    if (fs$n.existsSync(publicFile)) {
         return publicFile;
     }
     else {
@@ -27964,19 +28069,34 @@ function fileToDevUrl(id, config) {
     }
     else if (id.startsWith(config.root)) {
         // in project root, infer short public path
-        rtn = '/' + path$p.posix.relative(config.root, id);
+        rtn = '/' + path$q.posix.relative(config.root, id);
     }
     else {
         // outside of project root, use absolute fs path
         // (this is special handled by the serve static middleware
-        rtn = path$p.posix.join(FS_PREFIX + id);
+        rtn = path$q.posix.join(FS_PREFIX + id);
     }
     const origin = config.server?.origin ?? '';
-    return origin + config.base + rtn.replace(/^\//, '');
+    const devBase = config.base;
+    return origin + devBase + rtn.replace(/^\//, '');
 }
 function getAssetFilename(hash, config) {
     return assetHashToFilenameMap.get(config)?.get(hash);
 }
+function resolveAssetFileNames(config) {
+    const output = config.build?.rollupOptions?.output;
+    const defaultAssetFileNames = path$q.posix.join(config.build.assetsDir, '[name].[hash][extname]');
+    // Steps to determine which assetFileNames will be actually used.
+    // First, if output is an object or string, use assetFileNames in it.
+    // And a default assetFileNames as fallback.
+    let assetFileNames = (output && !Array.isArray(output) ? output.assetFileNames : undefined) ??
+        defaultAssetFileNames;
+    if (output && Array.isArray(output)) {
+        // Second, if output is an array, adopt assetFileNames in the first object.
+        assetFileNames = output[0].assetFileNames ?? assetFileNames;
+    }
+    return assetFileNames;
+}
 /**
  * converts the source filepath of the asset to the output filename based on the assetFileNames option. \
  * this function imitates the behavior of rollup.js. \
@@ -28001,10 +28121,10 @@ function getAssetFilename(hash, config) {
  * @returns output filename
  */
 function assetFileNamesToFileName(assetFileNames, file, contentHash, content) {
-    const basename = path$p.basename(file);
+    const basename = path$q.basename(file);
     // placeholders for `assetFileNames`
     // `hash` is slightly different from the rollup's one
-    const extname = path$p.extname(basename);
+    const extname = path$q.extname(basename);
     const ext = extname.substring(1);
     const name = basename.slice(0, -extname.length);
     const hash = contentHash;
@@ -28039,7 +28159,8 @@ function assetFileNamesToFileName(assetFileNames, file, contentHash, content) {
 const publicAssetUrlCache = new WeakMap();
 const publicAssetUrlRE = /__VITE_PUBLIC_ASSET__([a-z\d]{8})__/g;
 function publicFileToBuiltUrl(url, config) {
-    if (!isRelativeBase(config.base)) {
+    if (config.command !== 'build') {
+        // We don't need relative base or buildAdvancedBaseOptions support during dev
         return config.base + url.slice(1);
     }
     const hash = getHash(url);
@@ -28067,7 +28188,7 @@ async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false
         return cached;
     }
     const file = cleanUrl(id);
-    const content = await promises.readFile(file);
+    const content = await promises$2.readFile(file);
     let url;
     if (config.build.lib ||
         (!file.endsWith('.svg') &&
@@ -28088,18 +28209,13 @@ async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false
         const contentHash = getHash(content);
         const { search, hash } = parse$m(id);
         const postfix = (search || '') + (hash || '');
-        const output = config.build?.rollupOptions?.output;
-        const assetFileNames = (output && !Array.isArray(output) ? output.assetFileNames : undefined) ??
-            // defaults to '<assetsDir>/[name].[hash][extname]'
-            // slightly different from rollup's one ('assets/[name]-[hash][extname]')
-            path$p.posix.join(config.build.assetsDir, '[name].[hash][extname]');
-        const fileName = assetFileNamesToFileName(assetFileNames, file, contentHash, content);
+        const fileName = assetFileNamesToFileName(resolveAssetFileNames(config), file, contentHash, content);
         if (!map.has(contentHash)) {
             map.set(contentHash, fileName);
         }
         const emittedSet = emittedHashMap.get(config);
         if (!emittedSet.has(contentHash)) {
-            const name = normalizePath$3(path$p.relative(config.root, file));
+            const name = normalizePath$3(path$q.relative(config.root, file));
             pluginContext.emitFile({
                 name,
                 fileName,
@@ -28118,8 +28234,8 @@ async function urlToBuiltUrl(url, importer, config, pluginContext) {
         return publicFileToBuiltUrl(url, config);
     }
     const file = url.startsWith('/')
-        ? path$p.join(config.root, url)
-        : path$p.join(path$p.dirname(importer), url);
+        ? path$q.join(config.root, url)
+        : path$q.join(path$q.dirname(importer), url);
     return fileToBuiltUrl(file, config, pluginContext, 
     // skip public check since we just did it above
     true);
@@ -28406,6 +28522,7 @@ function jsonPlugin(options = {}, isBuild) {
                 return null;
             if (SPECIAL_QUERY_RE.test(id))
                 return null;
+            json = stripBomTag(json);
             try {
                 if (options.stringify) {
                     if (isBuild) {
@@ -28938,8 +29055,8 @@ function viaLocal(dir, isEtag, uri, extns) {
 	let abs, stats, name, headers;
 	for (; i < arr.length; i++) {
 		abs = normalize(join$1(dir, name=arr[i]));
-		if (abs.startsWith(dir) && fs$n.existsSync(abs)) {
-			stats = fs$n.statSync(abs);
+		if (abs.startsWith(dir) && require$$0$2.existsSync(abs)) {
+			stats = require$$0$2.statSync(abs);
 			if (stats.isDirectory()) continue;
 			headers = toHeaders(name, stats, isEtag);
 			headers['Cache-Control'] = isEtag ? 'no-cache' : 'no-store';
@@ -28983,7 +29100,7 @@ function send$2(req, res, file, stats, headers) {
 	}
 
 	res.writeHead(code, headers);
-	fs$n.createReadStream(file, opts).pipe(res);
+	require$$0$2.createReadStream(file, opts).pipe(res);
 }
 
 const ENCODING = {
@@ -29131,7 +29248,7 @@ function serveStaticMiddleware(dir, server) {
         // also skip internal requests `/@fs/ /@vite-client` etc...
         const cleanedUrl = cleanUrl(req.url);
         if (cleanedUrl.endsWith('/') ||
-            path$p.extname(cleanedUrl) === '.html' ||
+            path$q.extname(cleanedUrl) === '.html' ||
             isInternalRequest(req.url)) {
             return next();
         }
@@ -29152,7 +29269,7 @@ function serveStaticMiddleware(dir, server) {
             }
         }
         const resolvedUrl = redirected || url;
-        let fileUrl = path$p.resolve(dir, resolvedUrl.replace(/^\//, ''));
+        let fileUrl = path$q.resolve(dir, resolvedUrl.replace(/^\//, ''));
         if (resolvedUrl.endsWith('/') && !fileUrl.endsWith('/')) {
             fileUrl = fileUrl + '/';
         }
@@ -29176,11 +29293,11 @@ function serveRawFsMiddleware(server) {
         // searching based from fs root.
         if (url.startsWith(FS_PREFIX)) {
             // restrict files outside of `fs.allow`
-            if (!ensureServingAccess(slash$1(path$p.resolve(fsPathFromId(url))), server, res, next)) {
+            if (!ensureServingAccess(slash$1(path$q.resolve(fsPathFromId(url))), server, res, next)) {
                 return;
             }
             url = url.slice(FS_PREFIX.length);
-            if (isWindows$3)
+            if (isWindows$4)
                 url = url.replace(/^[A-Z]:/i, '');
             req.url = url;
             serveFromRoot(req, res, next);
@@ -29346,7 +29463,7 @@ async function doTransform(url, server, options, timestamp) {
         // like /service-worker.js or /api/users
         if (options.ssr || isFileServingAllowed(file, server)) {
             try {
-                code = await promises.readFile(file, 'utf-8');
+                code = await promises$2.readFile(file, 'utf-8');
                 isDebug$3 && debugLoad(`${timeFrom(loadStart)} [fs] ${prettyUrl}`);
             }
             catch (e) {
@@ -29358,7 +29475,7 @@ async function doTransform(url, server, options, timestamp) {
         if (code) {
             try {
                 map = (convertSourceMap.fromSource(code) ||
-                    convertSourceMap.fromMapFileSource(code, path$p.dirname(file)))?.toObject();
+                    convertSourceMap.fromMapFileSource(code, path$q.dirname(file)))?.toObject();
             }
             catch (e) {
                 logger.warn(`Failed to load source map for ${url}.`, {
@@ -29448,12 +29565,21 @@ function getDepsOptimizer(config) {
 async function initDepsOptimizer(config, server) {
     const { logger } = config;
     const isBuild = config.command === 'build';
-    const scan = config.command !== 'build' && config.optimizeDeps.devScan;
+    const scan = config.command !== 'build' && config.legacy?.devDepsScanner;
     const sessionTimestamp = Date.now().toString();
     const cachedMetadata = loadCachedDepOptimizationMetadata(config);
     let handle;
+    let ssrServerDepsMetadata;
+    let _metadata = cachedMetadata || initDepsOptimizerMetadata(config, sessionTimestamp);
     const depsOptimizer = {
-        metadata: cachedMetadata || initDepsOptimizerMetadata(config, sessionTimestamp),
+        metadata: (options) => {
+            if (isBuild || !options.ssr) {
+                return _metadata;
+            }
+            else {
+                return ssrServerDepsMetadata;
+            }
+        },
         registerMissingImport,
         run: () => debouncedProcessing(0),
         isOptimizedDepFile: (id) => isOptimizedDepFile(id, config),
@@ -29465,6 +29591,9 @@ async function initDepsOptimizer(config, server) {
         options: config.optimizeDeps
     };
     depsOptimizerMap.set(config, depsOptimizer);
+    if (!isBuild && config.ssr) {
+        ssrServerDepsMetadata = await optimizeServerSsrDeps(config);
+    }
     let newDepsDiscovered = false;
     let newDepsToLog = [];
     let newDepsToLogHandle;
@@ -29495,7 +29624,7 @@ async function initDepsOptimizer(config, server) {
         if (!scan) {
             // Initialize discovered deps with manually added optimizeDeps.include info
             const discovered = await initialProjectDependencies(config, sessionTimestamp);
-            const { metadata } = depsOptimizer;
+            const metadata = _metadata;
             for (const depInfo of Object.values(discovered)) {
                 addOptimizedDepInfo(metadata, 'discovered', {
                     ...depInfo,
@@ -29511,7 +29640,7 @@ async function initDepsOptimizer(config, server) {
             setTimeout(async () => {
                 try {
                     debuggerViteDeps(colors$1.green(`scanning for dependencies...`));
-                    const { metadata } = depsOptimizer;
+                    const metadata = _metadata;
                     const discovered = await discoverProjectDependencies(config, sessionTimestamp);
                     // Respect the scan phase discover order to improve reproducibility
                     for (const depInfo of Object.values(discovered)) {
@@ -29543,7 +29672,7 @@ async function initDepsOptimizer(config, server) {
         // Ensure that a rerun will not be issued for current discovered deps
         if (handle)
             clearTimeout(handle);
-        if (Object.keys(depsOptimizer.metadata.discovered).length === 0) {
+        if (Object.keys(_metadata.discovered).length === 0) {
             currentlyProcessing = false;
             return;
         }
@@ -29551,11 +29680,11 @@ async function initDepsOptimizer(config, server) {
         // a succesful completion of the optimizeDeps rerun will end up
         // creating new bundled version of all current and discovered deps
         // in the cache dir and a new metadata info object assigned
-        // to optimizeDeps.metadata. A fullReload is only issued if
-        // the previous bundled dependencies have changed.
-        // if the rerun fails, optimizeDeps.metadata remains untouched,
-        // current discovered deps are cleaned, and a fullReload is issued
-        let { metadata } = depsOptimizer;
+        // to _metadata. A fullReload is only issued if the previous bundled
+        // dependencies have changed.
+        // if the rerun fails, _metadata remains untouched, current discovered
+        // deps are cleaned, and a fullReload is issued
+        let metadata = _metadata;
         // All deps, previous known and newly discovered are rebundled,
         // respect insertion order to keep the metadata file stable
         const newDeps = {};
@@ -29635,7 +29764,7 @@ async function initDepsOptimizer(config, server) {
                 if (isRerun) {
                     newDepsToLog.push(...Object.keys(newData.optimized).filter((dep) => !metadata.optimized[dep]));
                 }
-                metadata = depsOptimizer.metadata = newData;
+                metadata = _metadata = newData;
                 resolveEnqueuedProcessingPromises();
             };
             if (!needsReload) {
@@ -29707,7 +29836,7 @@ async function initDepsOptimizer(config, server) {
         // debounce time to wait for new missing deps finished, issue a new
         // optimization of deps (both old and newly found) once the previous
         // optimizeDeps processing is finished
-        const deps = Object.keys(depsOptimizer.metadata.discovered);
+        const deps = Object.keys(_metadata.discovered);
         const depsString = depsLogString(deps);
         debuggerViteDeps(colors$1.green(`new dependencies found: ${depsString}`));
         runOptimizer();
@@ -29719,7 +29848,10 @@ async function initDepsOptimizer(config, server) {
         if (depsOptimizer.scanProcessing) {
             config.logger.error('Vite internal error: registering missing import before initial scanning is over');
         }
-        const { metadata } = depsOptimizer;
+        if (!isBuild && ssr) {
+            config.logger.error(`Error: ${id} is a missing dependency in SSR dev server, it needs to be added to optimizeDeps.include`);
+        }
+        const metadata = _metadata;
         const optimized = metadata.optimized[id];
         if (optimized) {
             return optimized;
@@ -29737,7 +29869,7 @@ async function initDepsOptimizer(config, server) {
         newDepsDiscovered = true;
         missing = addOptimizedDepInfo(metadata, 'discovered', {
             id,
-            file: getOptimizedDepPath(id, config),
+            file: getOptimizedDepPath(id, config, ssr),
             src: resolved,
             // Assing a browserHash to this missing dependency that is unique to
             // the current state of known + missing deps. If its optimizeDeps run
@@ -29865,7 +29997,7 @@ const jsMapExtensionRE = /\.js\.map$/i;
 /**
  * Used by Vite CLI when running `vite optimize`
  */
-async function optimizeDeps(config, force = config.force, asCommand = false) {
+async function optimizeDeps(config, force = config.optimizeDeps.force, asCommand = false) {
     const log = asCommand ? config.logger.info : debug$a;
     const cachedMetadata = loadCachedDepOptimizationMetadata(config, force, asCommand);
     if (cachedMetadata) {
@@ -29878,6 +30010,31 @@ async function optimizeDeps(config, force = config.force, asCommand = false) {
     await result.commit();
     return result.metadata;
 }
+async function optimizeServerSsrDeps(config) {
+    const cachedMetadata = loadCachedDepOptimizationMetadata(config, config.optimizeDeps.force, false, true // ssr
+    );
+    if (cachedMetadata) {
+        return cachedMetadata;
+    }
+    let alsoInclude;
+    let noExternalFilter;
+    const noExternal = config.ssr?.noExternal;
+    if (noExternal) {
+        alsoInclude = arraify(noExternal).filter((ne) => typeof ne === 'string');
+        noExternalFilter =
+            noExternal === true
+                ? (dep) => false
+                : createFilter$1(noExternal, config.optimizeDeps?.exclude, {
+                    resolve: false
+                });
+    }
+    const deps = {};
+    await addManuallyIncludedOptimizeDeps(deps, config, alsoInclude, noExternalFilter);
+    const depsInfo = toDiscoveredDependencies(config, deps, true);
+    const result = await runOptimizeDeps(config, depsInfo, true);
+    await result.commit();
+    return result.metadata;
+}
 function initDepsOptimizerMetadata(config, timestamp) {
     const hash = getDepHash(config);
     return {
@@ -29898,19 +30055,19 @@ function addOptimizedDepInfo(metadata, type, depInfo) {
  * Creates the initial dep optimization metadata, loading it from the deps cache
  * if it exists and pre-bundling isn't forced
  */
-function loadCachedDepOptimizationMetadata(config, force = config.force, asCommand = false) {
+function loadCachedDepOptimizationMetadata(config, force = config.optimizeDeps.force, asCommand = false, ssr = !!config.build.ssr) {
     const log = asCommand ? config.logger.info : debug$a;
     // Before Vite 2.9, dependencies were cached in the root of the cacheDir
     // For compat, we remove the cache if we find the old structure
-    if (fs__default.existsSync(path$p.join(config.cacheDir, '_metadata.json'))) {
+    if (fs$n.existsSync(path$q.join(config.cacheDir, '_metadata.json'))) {
         emptyDir(config.cacheDir);
     }
-    const depsCacheDir = getDepsCacheDir(config);
+    const depsCacheDir = getDepsCacheDir(config, ssr);
     if (!force) {
         let cachedMetadata;
         try {
-            const cachedMetadataPath = path$p.join(depsCacheDir, '_metadata.json');
-            cachedMetadata = parseDepsOptimizerMetadata(fs__default.readFileSync(cachedMetadataPath, 'utf-8'), depsCacheDir);
+            const cachedMetadataPath = path$q.join(depsCacheDir, '_metadata.json');
+            cachedMetadata = parseDepsOptimizerMetadata(fs$n.readFileSync(cachedMetadataPath, 'utf-8'), depsCacheDir);
         }
         catch (e) { }
         // hash is consistent, no need to re-bundle
@@ -29925,7 +30082,7 @@ function loadCachedDepOptimizationMetadata(config, force = config.force, asComma
         config.logger.info('Forced re-optimization of dependencies');
     }
     // Start with a fresh cache
-    fs__default.rmSync(depsCacheDir, { recursive: true, force: true });
+    fs$n.rmSync(depsCacheDir, { recursive: true, force: true });
 }
 /**
  * Initial optimizeDeps at server start. Perform a fast scan using esbuild to
@@ -29949,13 +30106,16 @@ async function discoverProjectDependencies(config, timestamp) {
 async function initialProjectDependencies(config, timestamp, knownDeps) {
     const deps = knownDeps ?? {};
     await addManuallyIncludedOptimizeDeps(deps, config);
+    return toDiscoveredDependencies(config, deps, !!config.build.ssr, timestamp);
+}
+function toDiscoveredDependencies(config, deps, ssr, timestamp) {
     const browserHash = getOptimizedBrowserHash(getDepHash(config), deps, timestamp);
     const discovered = {};
     for (const id in deps) {
         const src = deps[id];
         discovered[id] = {
             id,
-            file: getOptimizedDepPath(id, config),
+            file: getOptimizedDepPath(id, config, ssr),
             src,
             browserHash: browserHash,
             exportsData: extractExportsData(src, config)
@@ -29980,25 +30140,26 @@ function depsLogString(qualifiedIds) {
  * Internally, Vite uses this function to prepare a optimizeDeps run. When Vite starts, we can get
  * the metadata and start the server without waiting for the optimizeDeps processing to be completed
  */
-async function runOptimizeDeps(resolvedConfig, depsInfo) {
+async function runOptimizeDeps(resolvedConfig, depsInfo, ssr = !!resolvedConfig.build.ssr) {
+    const isBuild = resolvedConfig.command === 'build';
     const config = {
         ...resolvedConfig,
         command: 'build'
     };
-    const depsCacheDir = getDepsCacheDir(resolvedConfig);
-    const processingCacheDir = getProcessingDepsCacheDir(resolvedConfig);
+    const depsCacheDir = getDepsCacheDir(resolvedConfig, ssr);
+    const processingCacheDir = getProcessingDepsCacheDir(resolvedConfig, ssr);
     // Create a temporal directory so we don't need to delete optimized deps
     // until they have been processed. This also avoids leaving the deps cache
     // directory in a corrupted state if there is an error
-    if (fs__default.existsSync(processingCacheDir)) {
+    if (fs$n.existsSync(processingCacheDir)) {
         emptyDir(processingCacheDir);
     }
     else {
-        fs__default.mkdirSync(processingCacheDir, { recursive: true });
+        fs$n.mkdirSync(processingCacheDir, { recursive: true });
     }
     // a hint for Node.js
     // all files in the cache directory should be recognized as ES modules
-    writeFile(path$p.resolve(processingCacheDir, 'package.json'), JSON.stringify({ type: 'module' }));
+    writeFile(path$q.resolve(processingCacheDir, 'package.json'), JSON.stringify({ type: 'module' }));
     const metadata = initDepsOptimizerMetadata(config);
     metadata.browserHash = getOptimizedBrowserHash(metadata.hash, depsFromOptimizedDepInfo(depsInfo));
     // We prebundle dependencies with esbuild and cache them, but there is no need
@@ -30015,7 +30176,7 @@ async function runOptimizeDeps(resolvedConfig, depsInfo) {
             await renameDir(processingCacheDir, depsCacheDir);
         },
         cancel() {
-            fs__default.rmSync(processingCacheDir, { recursive: true, force: true });
+            fs$n.rmSync(processingCacheDir, { recursive: true, force: true });
         }
     };
     if (!qualifiedIds.length) {
@@ -30048,18 +30209,14 @@ async function runOptimizeDeps(resolvedConfig, depsInfo) {
         idToExports[id] = exportsData;
         flatIdToExports[flatId] = exportsData;
     }
-    const define = {
-        'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || config.mode)
-    };
-    for (const key in config.define) {
-        const value = config.define[key];
-        define[key] = typeof value === 'string' ? value : JSON.stringify(value);
-    }
     const start = performance.now();
     const result = await build$3({
         absWorkingDir: process.cwd(),
         entryPoints: Object.keys(flatIdDeps),
         bundle: true,
+        // Ensure resolution is handled by esbuildDepPlugin and
+        // avoid replacing `process.env.NODE_ENV` for 'browser'
+        platform: 'neutral',
         format: 'esm',
         target: config.build.target || undefined,
         external: config.optimizeDeps?.exclude,
@@ -30067,9 +30224,8 @@ async function runOptimizeDeps(resolvedConfig, depsInfo) {
         splitting: true,
         sourcemap: true,
         outdir: processingCacheDir,
-        ignoreAnnotations: resolvedConfig.command !== 'build',
+        ignoreAnnotations: !isBuild,
         metafile: true,
-        define,
         plugins: [
             ...plugins,
             esbuildDepPlugin(flatIdDeps, flatIdToExports, config)
@@ -30078,7 +30234,7 @@ async function runOptimizeDeps(resolvedConfig, depsInfo) {
     });
     const meta = result.metafile;
     // the paths in `meta.outputs` are relative to `process.cwd()`
-    const processingCacheDirOutputPath = path$p.relative(process.cwd(), processingCacheDir);
+    const processingCacheDirOutputPath = path$q.relative(process.cwd(), processingCacheDir);
     for (const id in depsInfo) {
         const output = esbuildOutputFromId(meta.outputs, id, processingCacheDir);
         const { exportsData, ...info } = depsInfo[id];
@@ -30095,10 +30251,10 @@ async function runOptimizeDeps(resolvedConfig, depsInfo) {
     }
     for (const o of Object.keys(meta.outputs)) {
         if (!o.match(jsMapExtensionRE)) {
-            const id = path$p
+            const id = path$q
                 .relative(processingCacheDirOutputPath, o)
                 .replace(jsExtensionRE, '');
-            const file = getOptimizedDepPath(id, resolvedConfig);
+            const file = getOptimizedDepPath(id, resolvedConfig, ssr);
             if (!findOptimizedDepInfoInRecord(metadata.optimized, (depInfo) => depInfo.file === file)) {
                 addOptimizedDepInfo(metadata, 'chunks', {
                     id,
@@ -30109,7 +30265,7 @@ async function runOptimizeDeps(resolvedConfig, depsInfo) {
             }
         }
     }
-    const dataPath = path$p.join(processingCacheDir, '_metadata.json');
+    const dataPath = path$q.join(processingCacheDir, '_metadata.json');
     writeFile(dataPath, stringifyDepsOptimizerMetadata(metadata, depsCacheDir));
     debug$a(`deps bundled in ${(performance.now() - start).toFixed(2)}ms`);
     return processingResult;
@@ -30119,15 +30275,15 @@ async function findKnownImports(config) {
     await addManuallyIncludedOptimizeDeps(deps, config);
     return Object.keys(deps);
 }
-async function addManuallyIncludedOptimizeDeps(deps, config) {
-    const include = config.optimizeDeps?.include;
+async function addManuallyIncludedOptimizeDeps(deps, config, extra, filter) {
+    const include = [...(config.optimizeDeps?.include ?? []), ...(extra ?? [])];
     if (include) {
         const resolve = config.createResolver({ asSrc: false, scan: true });
         for (const id of include) {
             // normalize 'foo   >bar` as 'foo > bar' to prevent same id being added
             // and for pretty printing
             const normalizedId = normalizeId(id);
-            if (!deps[normalizedId]) {
+            if (!deps[normalizedId] && filter?.(normalizedId) !== false) {
                 const entry = await resolve(id);
                 if (entry) {
                     deps[normalizedId] = entry;
@@ -30150,35 +30306,39 @@ function newDepOptimizationProcessing() {
 function depsFromOptimizedDepInfo(depsInfo) {
     return Object.fromEntries(Object.entries(depsInfo).map((d) => [d[0], d[1].src]));
 }
-function getOptimizedDepPath(id, config) {
-    return normalizePath$3(path$p.resolve(getDepsCacheDir(config), flattenId(id) + '.js'));
+function getOptimizedDepPath(id, config, ssr = !!config.build.ssr) {
+    return normalizePath$3(path$q.resolve(getDepsCacheDir(config, ssr), flattenId(id) + '.js'));
 }
-function getDepsCacheSuffix(config) {
+function getDepsCacheSuffix(config, ssr) {
     let suffix = '';
     if (config.command === 'build') {
-        suffix += '_build';
-        if (config.build.ssr) {
-            suffix += '_ssr';
-        }
+        // Differentiate build caches depending on outDir to allow parallel builds
+        const { outDir } = config.build;
+        const buildId = outDir.length > 8 || outDir.includes('/') ? getHash(outDir) : outDir;
+        suffix += `_build-${buildId}`;
+    }
+    if (ssr) {
+        suffix += '_ssr';
     }
     return suffix;
 }
-function getDepsCacheDir(config) {
-    const dirName = 'deps' + getDepsCacheSuffix(config);
-    return normalizePath$3(path$p.resolve(config.cacheDir, dirName));
+function getDepsCacheDir(config, ssr) {
+    return getDepsCacheDirPrefix(config) + getDepsCacheSuffix(config, ssr);
+}
+function getProcessingDepsCacheDir(config, ssr) {
+    return (getDepsCacheDirPrefix(config) + getDepsCacheSuffix(config, ssr) + '_temp');
 }
-function getProcessingDepsCacheDir(config) {
-    const dirName = 'deps' + getDepsCacheSuffix(config) + '_temp';
-    return normalizePath$3(path$p.resolve(config.cacheDir, dirName));
+function getDepsCacheDirPrefix(config) {
+    return normalizePath$3(path$q.resolve(config.cacheDir, 'deps'));
 }
 function isOptimizedDepFile(id, config) {
-    return id.startsWith(getDepsCacheDir(config));
+    return id.startsWith(getDepsCacheDirPrefix(config));
 }
 function createIsOptimizedDepUrl(config) {
     const { root } = config;
-    const depsCacheDir = getDepsCacheDir(config);
+    const depsCacheDir = getDepsCacheDirPrefix(config);
     // determine the url prefix of files inside cache directory
-    const depsCacheDirRelative = normalizePath$3(path$p.relative(root, depsCacheDir));
+    const depsCacheDirRelative = normalizePath$3(path$q.relative(root, depsCacheDir));
     const depsCacheDirPrefix = depsCacheDirRelative.startsWith('../')
         ? // if the cache directory is outside root, the url prefix would be something
             // like '/@fs/absolute/path/to/node_modules/.vite'
@@ -30195,7 +30355,7 @@ function parseDepsOptimizerMetadata(jsonMetadata, depsCacheDir) {
         // Paths can be absolute or relative to the deps cache dir where
         // the _metadata.json is located
         if (key === 'file' || key === 'src') {
-            return normalizePath$3(path$p.resolve(depsCacheDir, value));
+            return normalizePath$3(path$q.resolve(depsCacheDir, value));
         }
         return value;
     });
@@ -30254,14 +30414,14 @@ function stringifyDepsOptimizerMetadata(metadata, depsCacheDir) {
         // Paths can be absolute or relative to the deps cache dir where
         // the _metadata.json is located
         if (key === 'file' || key === 'src') {
-            return normalizePath$3(path$p.relative(depsCacheDir, value));
+            return normalizePath$3(path$q.relative(depsCacheDir, value));
         }
         return value;
     }, 2);
 }
 function esbuildOutputFromId(outputs, id, cacheDirOutputPath) {
     const flatId = flattenId(id) + '.js';
-    return outputs[normalizePath$3(path$p.relative(process.cwd(), path$p.join(cacheDirOutputPath, flatId)))];
+    return outputs[normalizePath$3(path$q.relative(process.cwd(), path$q.join(cacheDirOutputPath, flatId)))];
 }
 async function extractExportsData(filePath, config) {
     await init;
@@ -30285,12 +30445,12 @@ async function extractExportsData(filePath, config) {
     }
     let parseResult;
     let usedJsxLoader = false;
-    const entryContent = fs__default.readFileSync(filePath, 'utf-8');
+    const entryContent = fs$n.readFileSync(filePath, 'utf-8');
     try {
         parseResult = parse$g(entryContent);
     }
     catch {
-        const loader = esbuildOptions.loader?.[path$p.extname(filePath)] || 'jsx';
+        const loader = esbuildOptions.loader?.[path$q.extname(filePath)] || 'jsx';
         debug$a(`Unable to parse: ${filePath}.\n Trying again with a ${loader} transform.`);
         const transformed = await transformWithEsbuild(entryContent, filePath, {
             loader
@@ -30355,7 +30515,6 @@ function getDepHash(config) {
     content += JSON.stringify({
         mode: process.env.NODE_ENV || config.mode,
         root: config.root,
-        define: config.define,
         resolve: config.resolve,
         buildTarget: config.build.target,
         assetsInclude: config.assetsInclude,
@@ -30406,11 +30565,13 @@ var index$1 = {
 	__proto__: null,
 	debuggerViteDeps: debuggerViteDeps,
 	optimizeDeps: optimizeDeps,
+	optimizeServerSsrDeps: optimizeServerSsrDeps,
 	initDepsOptimizerMetadata: initDepsOptimizerMetadata,
 	addOptimizedDepInfo: addOptimizedDepInfo,
 	loadCachedDepOptimizationMetadata: loadCachedDepOptimizationMetadata,
 	discoverProjectDependencies: discoverProjectDependencies,
 	initialProjectDependencies: initialProjectDependencies,
+	toDiscoveredDependencies: toDiscoveredDependencies,
 	depsLogString: depsLogString,
 	runOptimizeDeps: runOptimizeDeps,
 	findKnownImports: findKnownImports,
@@ -30418,6 +30579,7 @@ var index$1 = {
 	depsFromOptimizedDepInfo: depsFromOptimizedDepInfo,
 	getOptimizedDepPath: getOptimizedDepPath,
 	getDepsCacheDir: getDepsCacheDir,
+	getDepsCacheDirPrefix: getDepsCacheDirPrefix,
 	isOptimizedDepFile: isOptimizedDepFile,
 	createIsOptimizedDepUrl: createIsOptimizedDepUrl,
 	extractExportsData: extractExportsData,
@@ -30435,7 +30597,7 @@ var dist = {};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lilconfigSync = exports.lilconfig = exports.defaultLoaders = void 0;
 const path = path$p;
-const fs = fs__default;
+const fs = require$$0__default;
 const os = require$$1;
 const fsReadFileAsync = fs.promises.readFile;
 function getDefaultSearchPlaces(name) {
@@ -37911,7 +38073,7 @@ var browser$1 = {
 var require$$3 = /*@__PURE__*/getAugmentedNamespace(browser$1);
 
 // eslint-disable-next-line n/no-deprecated-api
-const { createRequire, createRequireFromPath } = require$$0$7;
+const { createRequire, createRequireFromPath } = require$$0$8;
 
 function req$2 (name, rootFile) {
   const create = createRequire || createRequireFromPath;
@@ -38052,7 +38214,7 @@ const plugins = (config, file) => {
 var plugins_1 = plugins;
 
 const resolve = path$p.resolve;
-const url$4 = require$$0$8;
+const url$4 = require$$0$9;
 
 const config$1 = dist;
 const yaml = require$$3;
@@ -38365,7 +38527,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await import('./dep-d6e255b8.js').then(function (n) { return n.c; });
+    const { parse, transform } = await import('./dep-92497830.js').then(function (n) { return n.c; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -38437,7 +38599,7 @@ function buildHtmlPlugin(config) {
         name: 'vite:build-html',
         async transform(html, id) {
             if (id.endsWith('.html')) {
-                const relativeUrlPath = slash$1(path$p.relative(config.root, id));
+                const relativeUrlPath = slash$1(path$q.relative(config.root, id));
                 const publicPath = `/${relativeUrlPath}`;
                 const publicBase = getPublicBase(relativeUrlPath, config);
                 // pre-transform
@@ -38664,31 +38826,31 @@ function buildHtmlPlugin(config) {
                 });
                 return chunks;
             };
-            const toScriptTag = (chunk, publicBase, isAsync) => ({
+            const toScriptTag = (chunk, assetsBase, isAsync) => ({
                 tag: 'script',
                 attrs: {
                     ...(isAsync ? { async: true } : {}),
                     type: 'module',
                     crossorigin: true,
-                    src: toPublicPath(chunk.fileName, publicBase)
+                    src: toPublicPath(chunk.fileName, assetsBase)
                 }
             });
-            const toPreloadTag = (chunk, publicBase) => ({
+            const toPreloadTag = (chunk, assetsBase) => ({
                 tag: 'link',
                 attrs: {
                     rel: 'modulepreload',
                     crossorigin: true,
-                    href: toPublicPath(chunk.fileName, publicBase)
+                    href: toPublicPath(chunk.fileName, assetsBase)
                 }
             });
-            const getCssTagsForChunk = (chunk, publicBase, seen = new Set()) => {
+            const getCssTagsForChunk = (chunk, assetsBase, seen = new Set()) => {
                 const tags = [];
                 if (!analyzedChunk.has(chunk)) {
                     analyzedChunk.set(chunk, 1);
                     chunk.imports.forEach((file) => {
                         const importee = bundle[file];
                         if (importee?.type === 'chunk') {
-                            tags.push(...getCssTagsForChunk(importee, publicBase, seen));
+                            tags.push(...getCssTagsForChunk(importee, assetsBase, seen));
                         }
                     });
                 }
@@ -38699,7 +38861,7 @@ function buildHtmlPlugin(config) {
                             tag: 'link',
                             attrs: {
                                 rel: 'stylesheet',
-                                href: toPublicPath(file, publicBase)
+                                href: toPublicPath(file, assetsBase)
                             }
                         });
                     }
@@ -38707,8 +38869,8 @@ function buildHtmlPlugin(config) {
                 return tags;
             };
             for (const [id, html] of processedHtml) {
-                const relativeUrlPath = path$p.posix.relative(config.root, id);
-                const publicBase = getPublicBase(relativeUrlPath, config);
+                const relativeUrlPath = path$q.posix.relative(config.root, id);
+                const assetsBase = getAssetsBase(relativeUrlPath, config);
                 const isAsync = isAsyncScriptMap.get(config).get(id);
                 let result = html;
                 // find corresponding entry chunk
@@ -38728,12 +38890,12 @@ function buildHtmlPlugin(config) {
                     // 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, publicBase, isAsync))
+                        ? imports.map((chunk) => toScriptTag(chunk, assetsBase, isAsync))
                         : [
-                            toScriptTag(chunk, publicBase, isAsync),
-                            ...imports.map((i) => toPreloadTag(i, publicBase))
+                            toScriptTag(chunk, assetsBase, isAsync),
+                            ...imports.map((i) => toPreloadTag(i, assetsBase))
                         ];
-                    assetTags.push(...getCssTagsForChunk(chunk, publicBase));
+                    assetTags.push(...getCssTagsForChunk(chunk, assetsBase));
                     result = injectToHead(result, assetTags);
                 }
                 // inject css link when cssCodeSplit is false
@@ -38745,7 +38907,7 @@ function buildHtmlPlugin(config) {
                                 tag: 'link',
                                 attrs: {
                                     rel: 'stylesheet',
-                                    href: toPublicPath(cssChunk.fileName, publicBase)
+                                    href: toPublicPath(cssChunk.fileName, assetsBase)
                                 }
                             }
                         ]);
@@ -38771,13 +38933,13 @@ function buildHtmlPlugin(config) {
                 });
                 // resolve asset url references
                 result = result.replace(assetUrlRE, (_, fileHash, postfix = '') => {
-                    return publicBase + getAssetFilename(fileHash, config) + postfix;
+                    return assetsBase + getAssetFilename(fileHash, config) + postfix;
                 });
                 if (chunk && canInlineEntry) {
                     // all imports from entry have been inlined to html, prevent rollup from outputting it
                     delete bundle[chunk.fileName];
                 }
-                const shortEmitName = path$p.relative(config.root, id);
+                const shortEmitName = path$q.relative(config.root, id);
                 this.emitFile({
                     type: 'asset',
                     fileName: shortEmitName,
@@ -38807,10 +38969,6 @@ function resolveHtmlTransforms(plugins) {
     return [preHooks, postHooks];
 }
 async function applyHtmlTransforms(html, hooks, ctx) {
-    const headTags = [];
-    const headPrependTags = [];
-    const bodyTags = [];
-    const bodyPrependTags = [];
     for (const hook of hooks) {
         const res = await hook(html, ctx);
         if (!res) {
@@ -38828,6 +38986,10 @@ async function applyHtmlTransforms(html, hooks, ctx) {
                 html = res.html || html;
                 tags = res.tags;
             }
+            const headTags = [];
+            const headPrependTags = [];
+            const bodyTags = [];
+            const bodyPrependTags = [];
             for (const tag of tags) {
                 if (tag.injectTo === 'body') {
                     bodyTags.push(tag);
@@ -38842,21 +39004,12 @@ async function applyHtmlTransforms(html, hooks, ctx) {
                     headPrependTags.push(tag);
                 }
             }
+            html = injectToHead(html, headPrependTags, true);
+            html = injectToHead(html, headTags);
+            html = injectToBody(html, bodyPrependTags, true);
+            html = injectToBody(html, bodyTags);
         }
     }
-    // inject tags
-    if (headPrependTags.length) {
-        html = injectToHead(html, headPrependTags, true);
-    }
-    if (headTags.length) {
-        html = injectToHead(html, headTags);
-    }
-    if (bodyPrependTags.length) {
-        html = injectToBody(html, bodyPrependTags, true);
-    }
-    if (bodyTags.length) {
-        html = injectToBody(html, bodyTags);
-    }
     return html;
 }
 const importRE = /\bimport\s*("[^"]*[^\\]"|'[^']*[^\\]');*/g;
@@ -38866,10 +39019,19 @@ function isEntirelyImport(code) {
     // the regexes will remove too little in some exotic cases, but false-negatives are alright
     return !code.replace(importRE, '').replace(commentRE, '').trim().length;
 }
+function getBaseInHTML(urlRelativePath, baseOptions, config) {
+    // Prefer explicit URL if defined for linking to assets and public files from HTML,
+    // even when base relative is specified
+    return (baseOptions.url ??
+        (baseOptions.relative
+            ? path$q.posix.join(path$q.posix.relative(urlRelativePath, '').slice(0, -2), './')
+            : config.base));
+}
 function getPublicBase(urlRelativePath, config) {
-    return isRelativeBase(config.base)
-        ? path$p.posix.join(path$p.posix.relative(urlRelativePath, '').slice(0, -2), './')
-        : config.base;
+    return getBaseInHTML(urlRelativePath, config.experimental.buildAdvancedBaseOptions.public, config);
+}
+function getAssetsBase(urlRelativePath, config) {
+    return getBaseInHTML(urlRelativePath, config.experimental.buildAdvancedBaseOptions.assets, config);
 }
 function toPublicPath(filename, publicBase) {
     return isExternalUrl(filename) ? filename : publicBase + filename;
@@ -38885,6 +39047,8 @@ const bodyInjectRE = /([ \t]*)<\/body>/i;
 const bodyPrependInjectRE = /([ \t]*)<body[^>]*>/i;
 const doctypePrependInjectRE = /<!doctype html>/i;
 function injectToHead(html, tags, prepend = false) {
+    if (tags.length === 0)
+        return html;
     if (prepend) {
         // inject as the first element of head
         if (headPrependInjectRE.test(html)) {
@@ -38906,6 +39070,8 @@ function injectToHead(html, tags, prepend = false) {
     return prependInjectFallback(html, tags);
 }
 function injectToBody(html, tags, prepend = false) {
+    if (tags.length === 0)
+        return html;
     if (prepend) {
         // inject after body open
         if (bodyPrependInjectRE.test(html)) {
@@ -38989,6 +39155,9 @@ const isDirectRequest = (request) => directRequestRE.test(request);
 const cssModulesCache = new WeakMap();
 const removedPureCssFilesCache = new WeakMap();
 const postcssConfigCache = new WeakMap();
+function encodePublicUrlsInCSS(config) {
+    return config.command === 'build';
+}
 /**
  * Plugin applied before user plugins
  */
@@ -39021,7 +39190,7 @@ function cssPlugin(config) {
             const ssr = options?.ssr === true;
             const urlReplacer = async (url, importer) => {
                 if (checkPublicFile(url, config)) {
-                    if (isRelativeBase(config.base)) {
+                    if (encodePublicUrlsInCSS(config)) {
                         return publicFileToBuiltUrl(url, config);
                     }
                     else {
@@ -39049,6 +39218,7 @@ function cssPlugin(config) {
                 // server only logic for handling CSS @import dependency hmr
                 const { moduleGraph } = server;
                 const thisModule = moduleGraph.getModuleById(id);
+                const devBase = config.base;
                 if (thisModule) {
                     // CSS modules cannot self-accept since it exports values
                     const isSelfAccepting = !modules && !inlineRE.test(id) && !htmlProxyRE.test(id);
@@ -39059,12 +39229,12 @@ function cssPlugin(config) {
                         for (const file of deps) {
                             depModules.add(isCSSRequest(file)
                                 ? moduleGraph.createFileOnlyEntry(file)
-                                : await moduleGraph.ensureEntryFromUrl((await fileToUrl(file, config, this)).replace((config.server?.origin ?? '') + config.base, '/'), ssr));
+                                : await moduleGraph.ensureEntryFromUrl((await fileToUrl(file, config, this)).replace((config.server?.origin ?? '') + devBase, '/'), ssr));
                         }
-                        moduleGraph.updateModuleInfo(thisModule, depModules, 
+                        moduleGraph.updateModuleInfo(thisModule, depModules, null, 
                         // The root CSS proxy module is self-accepting and should not
                         // have an explicit accept list
-                        new Set(), isSelfAccepting, ssr);
+                        new Set(), null, isSelfAccepting, ssr);
                         for (const file of deps) {
                             this.addWatchFile(file);
                         }
@@ -39092,7 +39262,6 @@ function cssPostPlugin(config) {
     // since output formats have no effect on the generated CSS.
     let outputToExtractedCSSMap;
     let hasEmitted = false;
-    const relativeBase = isRelativeBase(config.base);
     const rollupOptionsOutput = config.build.rollupOptions.output;
     const assetFileNames = (Array.isArray(rollupOptionsOutput)
         ? rollupOptionsOutput[0]
@@ -39102,10 +39271,10 @@ function cssPostPlugin(config) {
             return config.build.assetsDir;
         }
         else if (typeof assetFileNames === 'string') {
-            return path$p.dirname(assetFileNames);
+            return path$q.dirname(assetFileNames);
         }
         else {
-            return path$p.dirname(assetFileNames({
+            return path$q.dirname(assetFileNames({
                 name: cssAssetName,
                 type: 'asset',
                 source: '/* vite internal call, ignore */'
@@ -39154,8 +39323,9 @@ function cssPostPlugin(config) {
                     return `export default ${JSON.stringify(css)}`;
                 }
                 const cssContent = await getContentWithSourcemap(css);
+                const devBase = config.base;
                 return [
-                    `import { updateStyle as __vite__updateStyle, removeStyle as __vite__removeStyle } from ${JSON.stringify(path$p.posix.join(config.base, CLIENT_PUBLIC_PATH))}`,
+                    `import { updateStyle as __vite__updateStyle, removeStyle as __vite__removeStyle } from ${JSON.stringify(path$q.posix.join(devBase, CLIENT_PUBLIC_PATH))}`,
                     `const __vite__id = ${JSON.stringify(id)}`,
                     `const __vite__css = ${JSON.stringify(cssContent)}`,
                     `__vite__updateStyle(__vite__id, __vite__css)`,
@@ -39221,46 +39391,61 @@ function cssPostPlugin(config) {
             const publicAssetUrlMap = publicAssetUrlCache.get(config);
             // resolve asset URL placeholders to their built file URLs
             function resolveAssetUrlsInCss(chunkCSS, cssAssetName) {
-                const cssAssetDirname = relativeBase
+                const encodedPublicUrls = encodePublicUrlsInCSS(config);
+                const { assets: assetsBase, public: publicBase } = config.experimental.buildAdvancedBaseOptions;
+                const cssAssetDirname = encodedPublicUrls || assetsBase.relative
                     ? getCssAssetDirname(cssAssetName)
                     : undefined;
                 // replace asset url references with resolved url.
                 chunkCSS = chunkCSS.replace(assetUrlRE, (_, fileHash, postfix = '') => {
                     const filename = getAssetFilename(fileHash, config) + postfix;
                     chunk.viteMetadata.importedAssets.add(cleanUrl(filename));
-                    if (relativeBase) {
+                    if (assetsBase.relative && !config.build.ssr) {
                         // relative base + extracted CSS
-                        const relativePath = path$p.posix.relative(cssAssetDirname, filename);
+                        const relativePath = path$q.posix.relative(cssAssetDirname, filename);
                         return relativePath.startsWith('.')
                             ? relativePath
                             : './' + relativePath;
                     }
                     else {
-                        // absolute base
-                        return config.base + filename;
+                        // assetsBase.runtime has no effect for assets in CSS
+                        return (assetsBase.url ?? config.base) + filename;
                     }
                 });
                 // resolve public URL from CSS paths
-                if (relativeBase) {
-                    const relativePathToPublicFromCSS = path$p.posix.relative(cssAssetDirname, '');
-                    chunkCSS = chunkCSS.replace(publicAssetUrlRE, (_, hash) => relativePathToPublicFromCSS + publicAssetUrlMap.get(hash));
+                if (encodedPublicUrls) {
+                    const relativePathToPublicFromCSS = path$q.posix.relative(cssAssetDirname, '');
+                    chunkCSS = chunkCSS.replace(publicAssetUrlRE, (_, hash) => {
+                        const publicUrl = publicAssetUrlMap.get(hash);
+                        if (publicBase.relative && !config.build.ssr) {
+                            return relativePathToPublicFromCSS + publicUrl;
+                        }
+                        else {
+                            // publicBase.runtime has no effect for assets in CSS
+                            return (publicBase.url ?? config.base) + publicUrl.slice(1);
+                        }
+                    });
                 }
                 return chunkCSS;
             }
+            function ensureFileExt(name, ext) {
+                return path$q.format({ ...path$q.parse(name), base: undefined, ext });
+            }
             if (config.build.cssCodeSplit) {
                 if (isPureCssChunk) {
                     // this is a shared CSS-only chunk that is empty.
                     pureCssChunks.add(chunk.fileName);
                 }
-                if (opts.format === 'es' ||
-                    opts.format === 'cjs' ||
-                    opts.format === 'system') {
-                    const cssAssetName = chunk.name + '.css';
+                if (opts.format === 'es' || opts.format === 'cjs') {
+                    const cssAssetName = ensureFileExt(chunk.facadeModuleId
+                        ? normalizePath$3(path$q.relative(config.root, chunk.facadeModuleId))
+                        : chunk.name, '.css');
                     chunkCSS = resolveAssetUrlsInCss(chunkCSS, cssAssetName);
                     chunkCSS = await finalizeCss(chunkCSS, true, config);
                     // emit corresponding css file
                     const fileHandle = this.emitFile({
                         name: cssAssetName,
+                        fileName: assetFileNamesToFileName(resolveAssetFileNames(config), cssAssetName, getHash(chunkCSS), chunkCSS),
                         type: 'asset',
                         source: chunkCSS
                     });
@@ -39304,10 +39489,10 @@ function cssPostPlugin(config) {
             // remove empty css chunks and their imports
             if (pureCssChunks.size) {
                 const emptyChunkFiles = [...pureCssChunks]
-                    .map((file) => path$p.basename(file))
+                    .map((file) => path$q.basename(file))
                     .join('|')
                     .replace(/\./g, '\\.');
-                const emptyChunkRE = new RegExp(opts.format === 'es' || opts.format === 'system'
+                const emptyChunkRE = new RegExp(opts.format === 'es'
                     ? `\\bimport\\s*["'][^"']*(?:${emptyChunkFiles})["'];\n?`
                     : `\\brequire\\(\\s*["'][^"']*(?:${emptyChunkFiles})["']\\);\n?`, 'g');
                 for (const file in bundle) {
@@ -39451,15 +39636,15 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
     const postcssOptions = (postcssConfig && postcssConfig.options) || {};
     const postcssPlugins = postcssConfig && postcssConfig.plugins ? postcssConfig.plugins.slice() : [];
     if (needInlineImport) {
-        postcssPlugins.unshift((await import('./dep-17430d09.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-58d622b1.js').then(function (n) { return n.i; })).default({
             async resolve(id, basedir) {
                 const publicFile = checkPublicFile(id, config);
                 if (publicFile) {
                     return publicFile;
                 }
-                const resolved = await atImportResolvers.css(id, path$p.join(basedir, '*'));
+                const resolved = await atImportResolvers.css(id, path$q.join(basedir, '*'));
                 if (resolved) {
-                    return path$p.resolve(resolved);
+                    return path$q.resolve(resolved);
                 }
                 return id;
             }
@@ -39470,7 +39655,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-4e458630.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-e88a0dff.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -39482,7 +39667,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
                 for (const key of getCssResolversKeys(atImportResolvers)) {
                     const resolved = await atImportResolvers[key](id);
                     if (resolved) {
-                        return path$p.resolve(resolved);
+                        return path$q.resolve(resolved);
                     }
                 }
                 return id;
@@ -39524,7 +39709,9 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         else if (message.type === 'dir-dependency') {
             // https://github.com/postcss/postcss/blob/main/docs/guidelines/plugin.md#3-dependencies
             const { dir, glob: globPattern = '**' } = message;
-            const pattern = normalizePath$3(path$p.resolve(path$p.dirname(id), dir)) + `/` + globPattern;
+            const pattern = out.escapePath(normalizePath$3(path$q.resolve(path$q.dirname(id), dir))) +
+                `/` +
+                globPattern;
             const files = out.sync(pattern, {
                 ignore: ['**/node_modules/**']
             });
@@ -39566,14 +39753,14 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
     };
 }
 async function formatPostcssSourceMap(rawMap, file) {
-    const inputFileDir = path$p.dirname(file);
+    const inputFileDir = path$q.dirname(file);
     const sources = rawMap.sources.map((source) => {
         const cleanSource = cleanUrl(decodeURIComponent(source));
         // postcss returns virtual files
         if (/^<.+>$/.test(cleanSource)) {
             return `\0${cleanSource}`;
         }
-        return normalizePath$3(path$p.resolve(inputFileDir, cleanSource));
+        return normalizePath$3(path$q.resolve(inputFileDir, cleanSource));
     });
     return {
         file,
@@ -39859,7 +40046,7 @@ const scss = async (source, root, options, resolvers) => {
             ? {
                 sourceMap: true,
                 omitSourceMapUrl: true,
-                sourceMapRoot: path$p.dirname(options.filename)
+                sourceMapRoot: path$q.dirname(options.filename)
             }
             : {})
     };
@@ -39902,14 +40089,14 @@ const sass = (source, root, options, aliasResolver) => scss(source, root, {
  * root file as base.
  */
 async function rebaseUrls(file, rootFile, alias) {
-    file = path$p.resolve(file); // ensure os-specific flashes
+    file = path$q.resolve(file); // ensure os-specific flashes
     // in the same dir, no need to rebase
-    const fileDir = path$p.dirname(file);
-    const rootDir = path$p.dirname(rootFile);
+    const fileDir = path$q.dirname(file);
+    const rootDir = path$q.dirname(rootFile);
     if (fileDir === rootDir) {
         return { file };
     }
-    const content = fs__default.readFileSync(file, 'utf-8');
+    const content = fs$n.readFileSync(file, 'utf-8');
     // no url()
     const hasUrls = cssUrlRE.test(content);
     // data-uri() calls
@@ -39930,8 +40117,8 @@ async function rebaseUrls(file, rootFile, alias) {
                 return url;
             }
         }
-        const absolute = path$p.resolve(fileDir, url);
-        const relative = path$p.relative(rootDir, absolute);
+        const absolute = path$q.resolve(fileDir, url);
+        const relative = path$q.relative(rootDir, absolute);
         return normalizePath$3(relative);
     };
     // fix css imports in less such as `@import "foo.css"`
@@ -40012,7 +40199,7 @@ function createViteLessPlugin(less, rootFile, alias, resolvers) {
                 return false;
             }
             async loadFile(filename, dir, opts, env) {
-                const resolved = await this.resolvers.less(filename, path$p.join(dir, '*'));
+                const resolved = await this.resolvers.less(filename, path$q.join(dir, '*'));
                 if (resolved) {
                     const result = await rebaseUrls(resolved, this.rootFile, this.alias);
                     let contents;
@@ -40020,10 +40207,10 @@ function createViteLessPlugin(less, rootFile, alias, resolvers) {
                         contents = result.contents;
                     }
                     else {
-                        contents = fs__default.readFileSync(resolved, 'utf-8');
+                        contents = fs$n.readFileSync(resolved, 'utf-8');
                     }
                     return {
-                        filename: path$p.resolve(resolved),
+                        filename: path$q.resolve(resolved),
                         contents
                     };
                 }
@@ -40048,7 +40235,7 @@ const styl = async (source, root, options) => {
     const { content, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap, '\n');
     // Get preprocessor options.imports dependencies as stylus
     // does not return them with its builtin `.deps()` method
-    const importsDeps = (options.imports ?? []).map((dep) => path$p.resolve(dep));
+    const importsDeps = (options.imports ?? []).map((dep) => path$q.resolve(dep));
     try {
         const ref = nodeStylus(content, options);
         if (options.enableSourcemap) {
@@ -40079,7 +40266,7 @@ function formatStylusSourceMap(mapBefore, root) {
     if (!mapBefore)
         return undefined;
     const map = { ...mapBefore };
-    const resolveFromRoot = (p) => normalizePath$3(path$p.resolve(root, p));
+    const resolveFromRoot = (p) => normalizePath$3(path$q.resolve(root, p));
     if (map.file) {
         map.file = resolveFromRoot(map.file);
     }
@@ -40121,15 +40308,203 @@ function isPreProcessor(lang) {
     return lang && lang in preProcessors;
 }
 
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var ParseOptions;
+(function (ParseOptions) {
+    ParseOptions.DEFAULT = {
+        allowTrailingComma: false
+    };
+})(ParseOptions || (ParseOptions = {}));
+
+function matchAll(regex, string, addition) {
+  const matches = [];
+  for (const match of string.matchAll(regex)) {
+    matches.push({
+      ...addition,
+      ...match.groups,
+      code: match[0],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  return matches;
+}
+
+const ESM_STATIC_IMPORT_RE = /(?<=\s|^|;)import\s*(["'\s]*(?<imports>[\w*${}\n\r\t, /]+)from\s*)?["']\s*(?<specifier>(?<="\s*)[^"]*[^"\s](?=\s*")|(?<='\s*)[^']*[^'\s](?=\s*'))\s*["'][\s;]*/gm;
+function findStaticImports(code) {
+  return matchAll(ESM_STATIC_IMPORT_RE, code, { type: "static" });
+}
+function parseStaticImport(matched) {
+  const cleanedImports = (matched.imports || "").replace(/(\/\/[^\n]*\n|\/\*.*\*\/)/g, "").replace(/\s+/g, " ");
+  const namedImports = {};
+  for (const namedImport of cleanedImports.match(/\{([^}]*)\}/)?.[1]?.split(",") || []) {
+    const [, source = namedImport.trim(), importName = source] = namedImport.match(/^\s*([^\s]*) as ([^\s]*)\s*$/) || [];
+    if (source) {
+      namedImports[source] = importName;
+    }
+  }
+  const topLevelImports = cleanedImports.replace(/\{([^}]*)\}/, "");
+  const namespacedImport = topLevelImports.match(/\* as \s*([^\s]*)/)?.[1];
+  const defaultImport = topLevelImports.split(",").find((i) => !i.match(/[*{}]/))?.trim() || void 0;
+  return {
+    ...matched,
+    defaultImport,
+    namespacedImport,
+    namedImports
+  };
+}
+
+const isWindows$3 = process.platform === "win32";
+const own$1 = {}.hasOwnProperty;
+const messages = /* @__PURE__ */ new Map();
+const nodeInternalPrefix = "__node_internal_";
+let userStackTraceLimit;
+createError("ERR_INVALID_MODULE_SPECIFIER", (request, reason, base = void 0) => {
+  return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+}, TypeError);
+createError("ERR_INVALID_PACKAGE_CONFIG", (path, base, message) => {
+  return `Invalid package config ${path}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+}, Error);
+createError("ERR_INVALID_PACKAGE_TARGET", (pkgPath, key, target, isImport = false, base = void 0) => {
+  const relError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
+  if (key === ".") {
+    assert$3(isImport === false);
+    return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`;
+  }
+  return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(target)} defined for '${key}' in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`;
+}, Error);
+createError("ERR_MODULE_NOT_FOUND", (path, base, type = "package") => {
+  return `Cannot find ${type} '${path}' imported from ${base}`;
+}, Error);
+createError("ERR_PACKAGE_IMPORT_NOT_DEFINED", (specifier, packagePath, base) => {
+  return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base}`;
+}, TypeError);
+createError("ERR_PACKAGE_PATH_NOT_EXPORTED", (pkgPath, subpath, base = void 0) => {
+  if (subpath === ".") {
+    return `No "exports" main defined in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`;
+  }
+  return `Package subpath '${subpath}' is not defined by "exports" in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`;
+}, Error);
+createError("ERR_UNSUPPORTED_DIR_IMPORT", "Directory import '%s' is not supported resolving ES modules imported from %s", Error);
+createError("ERR_UNKNOWN_FILE_EXTENSION", 'Unknown file extension "%s" for %s', TypeError);
+createError("ERR_INVALID_ARG_VALUE", (name, value, reason = "is invalid") => {
+  let inspected = inspect(value);
+  if (inspected.length > 128) {
+    inspected = `${inspected.slice(0, 128)}...`;
+  }
+  const type = name.includes(".") ? "property" : "argument";
+  return `The ${type} '${name}' ${reason}. Received ${inspected}`;
+}, TypeError);
+createError("ERR_UNSUPPORTED_ESM_URL_SCHEME", (url) => {
+  let message = "Only file and data URLs are supported by the default ESM loader";
+  if (isWindows$3 && url.protocol.length === 2) {
+    message += ". On Windows, absolute paths must be valid file:// URLs";
+  }
+  message += `. Received protocol '${url.protocol}'`;
+  return message;
+}, Error);
+function createError(sym, value, def) {
+  messages.set(sym, value);
+  return makeNodeErrorWithCode(def, sym);
+}
+function makeNodeErrorWithCode(Base, key) {
+  return NodeError;
+  function NodeError(...args) {
+    const limit = Error.stackTraceLimit;
+    if (isErrorStackTraceLimitWritable()) {
+      Error.stackTraceLimit = 0;
+    }
+    const error = new Base();
+    if (isErrorStackTraceLimitWritable()) {
+      Error.stackTraceLimit = limit;
+    }
+    const message = getMessage(key, args, error);
+    Object.defineProperty(error, "message", {
+      value: message,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+    Object.defineProperty(error, "toString", {
+      value() {
+        return `${this.name} [${key}]: ${this.message}`;
+      },
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+    addCodeToName(error, Base.name, key);
+    error.code = key;
+    return error;
+  }
+}
+const addCodeToName = hideStackFrames(function(error, name, code) {
+  error = captureLargerStackTrace(error);
+  error.name = `${name} [${code}]`;
+  if (name === "SystemError") {
+    Object.defineProperty(error, "name", {
+      value: name,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  } else {
+    delete error.name;
+  }
+});
+function isErrorStackTraceLimitWritable() {
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+  if (desc === void 0) {
+    return Object.isExtensible(Error);
+  }
+  return own$1.call(desc, "writable") ? desc.writable : desc.set !== void 0;
+}
+function hideStackFrames(fn) {
+  const hidden = nodeInternalPrefix + fn.name;
+  Object.defineProperty(fn, "name", { value: hidden });
+  return fn;
+}
+const captureLargerStackTrace = hideStackFrames(function(error) {
+  const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+  if (stackTraceLimitIsWritable) {
+    userStackTraceLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+  }
+  Error.captureStackTrace(error);
+  if (stackTraceLimitIsWritable) {
+    Error.stackTraceLimit = userStackTraceLimit;
+  }
+  return error;
+});
+function getMessage(key, args, self) {
+  const message = messages.get(key);
+  if (typeof message === "function") {
+    assert$3(message.length <= args.length, `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${message.length}).`);
+    return Reflect.apply(message, self, args);
+  }
+  const expectedLength = (message.match(/%[dfijoOs]/g) || []).length;
+  assert$3(expectedLength === args.length, `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`);
+  if (args.length === 0) {
+    return message;
+  }
+  args.unshift(message);
+  return Reflect.apply(format$2, null, args);
+}
+Object.freeze(["node", "import"]);
+pathToFileURL$1(process.cwd());
+
 const debugHmr = createDebugger('vite:hmr');
 const normalizedClientDir = normalizePath$3(CLIENT_DIR);
 function getShortName(file, root) {
-    return file.startsWith(root + '/') ? path$p.posix.relative(root, file) : file;
+    return file.startsWith(root + '/') ? path$q.posix.relative(root, file) : file;
 }
 async function handleHMRUpdate(file, server) {
     const { ws, config, moduleGraph } = server;
     const shortFile = getShortName(file, config.root);
-    const fileName = path$p.basename(file);
+    const fileName = path$q.basename(file);
     const isConfig = file === config.configFile;
     const isConfigDependency = config.configFileDependencies.some((name) => file === name);
     const isEnv = config.inlineConfig.envFile !== false &&
@@ -40137,7 +40512,7 @@ async function handleHMRUpdate(file, server) {
     if (isConfig || isConfigDependency || isEnv) {
         // auto restart server
         debugHmr(`[config change] ${colors$1.dim(shortFile)}`);
-        config.logger.info(colors$1.green(`${path$p.relative(process.cwd(), file)} changed, restarting server...`), { clear: true, timestamp: true });
+        config.logger.info(colors$1.green(`${path$q.relative(process.cwd(), file)} changed, restarting server...`), { clear: true, timestamp: true });
         try {
             await server.restart();
         }
@@ -40184,7 +40559,7 @@ async function handleHMRUpdate(file, server) {
                 type: 'full-reload',
                 path: config.server.middlewareMode
                     ? '*'
-                    : '/' + normalizePath$3(path$p.relative(config.root, file))
+                    : '/' + normalizePath$3(path$q.relative(config.root, file))
             });
         }
         else {
@@ -40243,6 +40618,14 @@ async function handleFileAddUnlink(file, server) {
         updateModules(getShortName(file, server.config.root), unique(modules), Date.now(), server);
     }
 }
+function areAllImportsAccepted(importedBindings, acceptedExports) {
+    for (const binding of importedBindings) {
+        if (!acceptedExports.has(binding)) {
+            return false;
+        }
+    }
+    return true;
+}
 function propagateUpdate(node, boundaries, currentChain = [node]) {
     // #7561
     // if the imports of `node` have not been analyzed, then `node` has not
@@ -40264,15 +40647,28 @@ function propagateUpdate(node, boundaries, currentChain = [node]) {
         }
         return false;
     }
-    if (!node.importers.size) {
-        return true;
+    // A partially accepted module with no importers is considered self accepting,
+    // because the deal is "there are parts of myself I can't self accept if they
+    // are used outside of me".
+    // Also, the imported module (this one) must be updated before the importers,
+    // so that they do get the fresh imported module when/if they are reloaded.
+    if (node.acceptedHmrExports) {
+        boundaries.add({
+            boundary: node,
+            acceptedVia: node
+        });
     }
-    // #3716, #3913
-    // For a non-CSS file, if all of its importers are CSS files (registered via
-    // PostCSS plugins) it should be considered a dead end and force full reload.
-    if (!isCSSRequest(node.url) &&
-        [...node.importers].every((i) => isCSSRequest(i.url))) {
-        return true;
+    else {
+        if (!node.importers.size) {
+            return true;
+        }
+        // #3716, #3913
+        // For a non-CSS file, if all of its importers are CSS files (registered via
+        // PostCSS plugins) it should be considered a dead end and force full reload.
+        if (!isCSSRequest(node.url) &&
+            [...node.importers].every((i) => isCSSRequest(i.url))) {
+            return true;
+        }
     }
     for (const importer of node.importers) {
         const subChain = currentChain.concat(importer);
@@ -40283,6 +40679,13 @@ function propagateUpdate(node, boundaries, currentChain = [node]) {
             });
             continue;
         }
+        if (node.id && node.acceptedHmrExports && importer.importedBindings) {
+            const importedBindingsFromNode = importer.importedBindings.get(node.id);
+            if (importedBindingsFromNode &&
+                areAllImportsAccepted(importedBindingsFromNode, node.acceptedHmrExports)) {
+                continue;
+            }
+        }
         if (currentChain.includes(importer)) {
             // circular deps is considered dead end
             return true;
@@ -40442,6 +40845,14 @@ function lexAcceptedHmrDeps(code, start, urls) {
     }
     return false;
 }
+function lexAcceptedHmrExports(code, start, exportNames) {
+    const urls = new Set();
+    lexAcceptedHmrDeps(code, start, urls);
+    for (const { url } of urls) {
+        exportNames.add(url);
+    }
+    return urls.size > 0;
+}
 function error$1(pos) {
     const err = new Error(`import.meta.hot.accept() can only accept string literals or an ` +
         `Array of string literals.`);
@@ -40452,14 +40863,14 @@ function error$1(pos) {
 // change event and sometimes this can be too early and get an empty buffer.
 // Poll until the file's modified time has changed before reading again.
 async function readModifiedFile(file) {
-    const content = fs__default.readFileSync(file, 'utf-8');
+    const content = fs$n.readFileSync(file, 'utf-8');
     if (!content) {
-        const mtime = fs__default.statSync(file).mtimeMs;
+        const mtime = fs$n.statSync(file).mtimeMs;
         await new Promise((r) => {
             let n = 0;
             const poll = async () => {
                 n++;
-                const newMtime = fs__default.statSync(file).mtimeMs;
+                const newMtime = fs$n.statSync(file).mtimeMs;
                 if (newMtime !== mtime || n > 10) {
                     r(0);
                 }
@@ -40469,7 +40880,7 @@ async function readModifiedFile(file) {
             };
             setTimeout(poll, 10);
         });
-        return fs__default.readFileSync(file, 'utf-8');
+        return fs$n.readFileSync(file, 'utf-8');
     }
     else {
         return content;
@@ -40573,14 +40984,14 @@ function createIsSsrExternal(config) {
             return processedIds.get(id);
         }
         const external = !id.startsWith('.') &&
-            !path$p.isAbsolute(id) &&
+            !path$q.isAbsolute(id) &&
             (isBuiltin(id) || (isConfiguredAsExternal(id) && isValidPackageEntry(id)));
         processedIds.set(id, external);
         return external;
     };
 }
-// When ssr.format is 'cjs', this function is used reverting to the Vite 2.9
-// SSR externalization heuristics
+// 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) {
     const rootPkgContent = lookupFile(root, ['package.json']);
     if (!rootPkgContent) {
@@ -40619,7 +41030,7 @@ function cjsSsrCollectExternals(root, preserveSymlinks, ssrExternals, seen, logg
                     ssrExternals.add(id);
                 }
                 else {
-                    depsToTrace.add(path$p.dirname(pkgPath));
+                    depsToTrace.add(path$q.dirname(pkgPath));
                 }
                 continue;
             }
@@ -40635,7 +41046,7 @@ function cjsSsrCollectExternals(root, preserveSymlinks, ssrExternals, seen, logg
         // trace the dependencies of linked packages
         else if (!esmEntry.includes('node_modules')) {
             const pkgPath = resolveFrom(`${id}/package.json`, root);
-            depsToTrace.add(path$p.dirname(pkgPath));
+            depsToTrace.add(path$q.dirname(pkgPath));
         }
         // has separate esm/require entry, assume require entry is cjs
         else if (esmEntry !== requireEntry) {
@@ -40646,7 +41057,7 @@ function cjsSsrCollectExternals(root, preserveSymlinks, ssrExternals, seen, logg
         // for now, we'll just leave this as is
         else if (/\.m?js$/.test(esmEntry)) {
             const pkgPath = resolveFrom(`${id}/package.json`, root);
-            const pkgContent = fs__default.readFileSync(pkgPath, 'utf-8');
+            const pkgContent = fs$n.readFileSync(pkgPath, 'utf-8');
             if (!pkgContent) {
                 continue;
             }
@@ -40656,7 +41067,7 @@ function cjsSsrCollectExternals(root, preserveSymlinks, ssrExternals, seen, logg
                 continue;
             }
             // check if the entry is cjs
-            const content = fs__default.readFileSync(esmEntry, 'utf-8');
+            const content = fs$n.readFileSync(esmEntry, 'utf-8');
             if (CJS_CONTENT_RE.test(content)) {
                 ssrExternals.add(id);
                 continue;
@@ -40678,7 +41089,7 @@ function cjsShouldExternalizeForSSR(id, externals) {
         }
         // deep imports, check ext before externalizing - only externalize
         // extension-less imports and explicit .js imports
-        if (id.startsWith(e + '/') && (!path$p.extname(id) || id.endsWith('.js'))) {
+        if (id.startsWith(e + '/') && (!path$q.extname(id) || id.endsWith('.js'))) {
             return true;
         }
     });
@@ -40711,10 +41122,11 @@ function optimizedDepsPlugin(config) {
         // this.load({ id }) isn't implemented in PluginContainer
         // The logic to register an id to wait until it is processed
         // is in importAnalysis, see call to delayDepsOptimizerUntil
-        async load(id) {
+        async load(id, options) {
+            const ssr = options?.ssr ?? false;
             const depsOptimizer = getDepsOptimizer(config);
             if (depsOptimizer?.isOptimizedDepFile(id)) {
-                const metadata = depsOptimizer?.metadata;
+                const metadata = depsOptimizer?.metadata({ ssr });
                 if (metadata) {
                     const file = cleanUrl(id);
                     const versionMatch = id.match(DEP_VERSION_RE);
@@ -40738,7 +41150,7 @@ function optimizedDepsPlugin(config) {
                             throwProcessingError(id);
                             return;
                         }
-                        const newMetadata = depsOptimizer.metadata;
+                        const newMetadata = depsOptimizer.metadata({ ssr });
                         if (metadata !== newMetadata) {
                             const currentInfo = optimizedDepInfoFromFile(newMetadata, file);
                             if (info.browserHash !== currentInfo?.browserHash) {
@@ -40751,7 +41163,7 @@ function optimizedDepsPlugin(config) {
                     // load hooks to avoid race conditions, once processing is resolved,
                     // we are sure that the file has been properly save to disk
                     try {
-                        return await promises.readFile(file, 'utf-8');
+                        return await promises$2.readFile(file, 'utf-8');
                     }
                     catch (e) {
                         // Outdated non-entry points (CHUNK), loaded after a rerun
@@ -40780,9 +41192,10 @@ function optimizedDepsBuildPlugin(config) {
                 await this.load({ id });
             });
         },
-        async load(id) {
+        async load(id, options) {
+            const ssr = options?.ssr ?? false;
             const depsOptimizer = getDepsOptimizer(config);
-            const metadata = depsOptimizer?.metadata;
+            const metadata = depsOptimizer?.metadata({ ssr });
             if (!metadata || !depsOptimizer?.isOptimizedDepFile(id)) {
                 return;
             }
@@ -40811,7 +41224,7 @@ function optimizedDepsBuildPlugin(config) {
             // load hooks to avoid race conditions, once processing is resolved,
             // we are sure that the file has been properly save to disk
             try {
-                return await promises.readFile(file, 'utf-8');
+                return await promises$2.readFile(file, 'utf-8');
             }
             catch (e) {
                 // Outdated non-entry points (CHUNK), loaded after a rerun
@@ -40853,6 +41266,40 @@ function markExplicitImport(url) {
     }
     return url;
 }
+async function extractImportedBindings(id, source, importSpec, importedBindings) {
+    let bindings = importedBindings.get(id);
+    if (!bindings) {
+        bindings = new Set();
+        importedBindings.set(id, bindings);
+    }
+    const isDynamic = importSpec.d > -1;
+    const isMeta = importSpec.d === -2;
+    if (isDynamic || isMeta) {
+        // this basically means the module will be impacted by any change in its dep
+        bindings.add('*');
+        return;
+    }
+    const exp = source.slice(importSpec.ss, importSpec.se);
+    const [match0] = findStaticImports(exp);
+    if (!match0) {
+        return;
+    }
+    const parsed = parseStaticImport(match0);
+    if (!parsed) {
+        return;
+    }
+    if (parsed.namespacedImport) {
+        bindings.add('*');
+    }
+    if (parsed.defaultImport) {
+        bindings.add('default');
+    }
+    if (parsed.namedImports) {
+        for (const name of Object.keys(parsed.namedImports)) {
+            bindings.add(name);
+        }
+    }
+}
 /**
  * Server-only plugin that lexes, resolves, rewrites and analyzes url imports.
  *
@@ -40884,7 +41331,8 @@ function markExplicitImport(url) {
  */
 function importAnalysisPlugin(config) {
     const { root, base } = config;
-    const clientPublicPath = path$p.posix.join(base, CLIENT_PUBLIC_PATH);
+    const clientPublicPath = path$q.posix.join(base, CLIENT_PUBLIC_PATH);
+    const enablePartialAccept = config.experimental?.hmrPartialAccept;
     let server;
     return {
         name: 'vite:import-analysis',
@@ -40906,12 +41354,10 @@ function importAnalysisPlugin(config) {
             const start = performance.now();
             await init;
             let imports = [];
-            // strip UTF-8 BOM
-            if (source.charCodeAt(0) === 0xfeff) {
-                source = source.slice(1);
-            }
+            let exports = [];
+            source = stripBomTag(source);
             try {
-                imports = parse$g(source)[0];
+                [imports, exports] = parse$g(source);
             }
             catch (e) {
                 const isVue = importer.endsWith('.vue');
@@ -40920,7 +41366,7 @@ function importAnalysisPlugin(config) {
                     ? `Install @vitejs/plugin-vue to handle .vue files.`
                     : maybeJSX
                         ? `If you are using JSX, make sure to name the file with the .jsx or .tsx extension.`
-                        : `You may need to install appropriate plugins to handle the ${path$p.extname(importer)} file format, or if it's an asset, add "**/*${path$p.extname(importer)}" to \`assetsInclude\` in your configuration.`;
+                        : `You may need to install appropriate plugins to handle the ${path$q.extname(importer)} file format, or if it's an asset, add "**/*${path$q.extname(importer)}" to \`assetsInclude\` in your configuration.`;
                 this.error(`Failed to parse source for import analysis because the content ` +
                     `contains invalid JS syntax. ` +
                     msg, e.idx);
@@ -40952,7 +41398,12 @@ function importAnalysisPlugin(config) {
             const importedUrls = new Set();
             const staticImportedUrls = new Set();
             const acceptedUrls = new Set();
-            const toAbsoluteUrl = (url) => path$p.posix.resolve(path$p.posix.dirname(importerModule.url), url);
+            let isPartiallySelfAccepting = false;
+            const acceptedExports = new Set();
+            const importedBindings = enablePartialAccept
+                ? new Map()
+                : null;
+            const toAbsoluteUrl = (url) => path$q.posix.resolve(path$q.posix.dirname(importerModule.url), url);
             const normalizeUrl = async (url, pos) => {
                 if (base !== '/' && url.startsWith(base)) {
                     url = url.replace(base, '/');
@@ -40965,7 +41416,8 @@ function importAnalysisPlugin(config) {
                         // the dependency needs to be resolved starting from the original source location of the optimized file
                         // because starting from node_modules/.vite will not find the dependency if it was not hoisted
                         // (that is, if it is under node_modules directory in the package source of the optimized file)
-                        for (const optimizedModule of depsOptimizer.metadata.depInfoList) {
+                        for (const optimizedModule of depsOptimizer.metadata({ ssr })
+                            .depInfoList) {
                             if (!optimizedModule.src)
                                 continue; // Ignore chunks
                             if (optimizedModule.file === importerModule.file) {
@@ -40980,7 +41432,7 @@ function importAnalysisPlugin(config) {
                     if (ssr) {
                         return [url, url];
                     }
-                    this.error(`Failed to resolve import "${url}" from "${path$p.relative(process.cwd(), importerFile)}". Does the file exist?`, pos);
+                    this.error(`Failed to resolve import "${url}" from "${path$q.relative(process.cwd(), importerFile)}". Does the file exist?`, pos);
                 }
                 const isRelative = url.startsWith('.');
                 const isSelfImport = !isRelative && cleanUrl(url) === cleanUrl(importer);
@@ -40990,11 +41442,11 @@ function importAnalysisPlugin(config) {
                     // in root: infer short absolute path from root
                     url = resolved.id.slice(root.length);
                 }
-                else if (resolved.id.startsWith(getDepsCacheDir(config)) ||
-                    fs__default.existsSync(cleanUrl(resolved.id))) {
+                else if (resolved.id.startsWith(getDepsCacheDirPrefix(config)) ||
+                    fs$n.existsSync(cleanUrl(resolved.id))) {
                     // an optimized deps may not yet exists in the filesystem, or
                     // a regular file exists but is out of root: rewrite to absolute /@fs/ paths
-                    url = path$p.posix.join(FS_PREFIX + resolved.id);
+                    url = path$q.posix.join(FS_PREFIX + resolved.id);
                 }
                 else {
                     url = resolved.id;
@@ -41059,7 +41511,11 @@ function importAnalysisPlugin(config) {
                         hasHMR = true;
                         if (source.slice(end + 4, end + 11) === '.accept') {
                             // further analyze accepted modules
-                            if (lexAcceptedHmrDeps(source, source.indexOf('(', end + 11) + 1, acceptedUrls)) {
+                            if (source.slice(end + 4, end + 18) === '.acceptExports') {
+                                lexAcceptedHmrExports(source, source.indexOf('(', end + 18) + 1, acceptedExports);
+                                isPartiallySelfAccepting = true;
+                            }
+                            else if (lexAcceptedHmrDeps(source, source.indexOf('(', end + 11) + 1, acceptedUrls)) {
                                 isSelfAccepting = true;
                             }
                         }
@@ -41079,7 +41535,7 @@ function importAnalysisPlugin(config) {
                     }
                     // skip ssr external
                     if (ssr) {
-                        if (config.ssr?.format === 'cjs') {
+                        if (config.legacy?.buildSsrCjsExternalHeuristics) {
                             if (cjsShouldExternalizeForSSR(specifier, server._ssrExternals)) {
                                 continue;
                             }
@@ -41117,7 +41573,7 @@ function importAnalysisPlugin(config) {
                             // The browserHash in resolvedId could be stale in which case there will be a full
                             // page reload. We could return a 404 in that case but it is safe to return the request
                             const file = cleanUrl(resolvedId); // Remove ?v={hash}
-                            const needsInterop = await optimizedDepNeedsInterop(depsOptimizer.metadata, file, config);
+                            const needsInterop = await optimizedDepNeedsInterop(depsOptimizer.metadata({ ssr }), file, config);
                             if (needsInterop === undefined) {
                                 // Non-entry dynamic imports from dependencies will reach here as there isn't
                                 // optimize info for them, but they don't need es interop. If the request isn't
@@ -41150,6 +41606,9 @@ function importAnalysisPlugin(config) {
                     // make sure to normalize away base
                     const urlWithoutBase = url.replace(base, '/');
                     importedUrls.add(urlWithoutBase);
+                    if (enablePartialAccept && importedBindings) {
+                        extractImportedBindings(resolvedId, source, imports[index], importedBindings);
+                    }
                     if (!isDynamicImport) {
                         // for pre-transforming
                         staticImportedUrls.add({ url: urlWithoutBase, id: resolvedId });
@@ -41199,9 +41658,11 @@ function importAnalysisPlugin(config) {
             if (hasHMR && !ssr) {
                 debugHmr(`${isSelfAccepting
                     ? `[self-accepts]`
-                    : acceptedUrls.size
-                        ? `[accepts-deps]`
-                        : `[detected api usage]`} ${prettyImporter}`);
+                    : isPartiallySelfAccepting
+                        ? `[accepts-exports]`
+                        : acceptedUrls.size
+                            ? `[accepts-deps]`
+                            : `[detected api usage]`} ${prettyImporter}`);
                 // inject hot context
                 str().prepend(`import { createHotContext as __vite__createHotContext } from "${clientPublicPath}";` +
                     `import.meta.hot = __vite__createHotContext(${JSON.stringify(importerModule.url)});`);
@@ -41233,7 +41694,15 @@ function importAnalysisPlugin(config) {
                 if (ssr && importerModule.isSelfAccepting) {
                     isSelfAccepting = true;
                 }
-                const prunedImports = await moduleGraph.updateModuleInfo(importerModule, importedUrls, normalizedAcceptedUrls, isSelfAccepting, ssr);
+                // a partially accepted module that accepts all its exports
+                // behaves like a self-accepted module in practice
+                if (!isSelfAccepting &&
+                    isPartiallySelfAccepting &&
+                    acceptedExports.size >= exports.length &&
+                    exports.every((name) => acceptedExports.has(name))) {
+                    isSelfAccepting = true;
+                }
+                const prunedImports = await moduleGraph.updateModuleInfo(importerModule, importedUrls, importedBindings, normalizedAcceptedUrls, isPartiallySelfAccepting ? acceptedExports : null, isSelfAccepting, ssr);
                 if (hasHMR && prunedImports) {
                     handlePrunedModules(prunedImports, server);
                 }
@@ -41255,7 +41724,7 @@ function importAnalysisPlugin(config) {
                         // Unexpected error, log the issue but avoid an unhandled exception
                         config.logger.error(e.message);
                     });
-                    if (depsOptimizer && !config.optimizeDeps.devScan) {
+                    if (depsOptimizer && !config.legacy?.devDepsScanner) {
                         depsOptimizer.delayDepsOptimizerUntil(id, () => request);
                     }
                 });
@@ -41372,7 +41841,6 @@ function transformCjsImport(importExp, url, rawUrl, importIndex) {
     }
 }
 
-// import fs from 'fs'
 /**
  * A flag for injected helpers. This flag will be set to `false` if the output
  * target is not native es - so that injected helper logic can be conditionally
@@ -41444,13 +41912,16 @@ function buildImportAnalysisPlugin(config) {
     const ssr = !!config.build.ssr;
     const isWorker = config.isWorker;
     const insertPreload = !(ssr || !!config.build.lib || isWorker);
-    const relativeBase = isRelativeBase(config.base);
+    const assetsBase = config.experimental.buildAdvancedBaseOptions.assets;
+    const relativePreloadUrls = !(assetsBase.url || assetsBase.runtime);
     const scriptRel = config.build.polyfillModulePreload
         ? `'modulepreload'`
         : `(${detectScriptRel.toString()})()`;
-    const assetsURL = relativeBase
+    const assetsURL = relativePreloadUrls
         ? `function(dep,importerUrl) { return new URL(dep, importerUrl).href }`
-        : `function(dep) { return ${JSON.stringify(config.base)}+dep }`;
+        : `function(dep) { return ${assetsBase.runtime
+            ? assetsBase.runtime('dep')
+            : `${JSON.stringify(assetsBase.url ?? config.base)}+dep`}}`;
     const preloadCode = `const scriptRel = ${scriptRel};const assetsURL = ${assetsURL};const seen = {};export const ${preloadMethod} = ${preload.toString()}`;
     return {
         name: 'vite:build-import-analysis',
@@ -41491,7 +41962,8 @@ function buildImportAnalysisPlugin(config) {
                         // the dependency needs to be resolved starting from the original source location of the optimized file
                         // because starting from node_modules/.vite will not find the dependency if it was not hoisted
                         // (that is, if it is under node_modules directory in the package source of the optimized file)
-                        for (const optimizedModule of depsOptimizer.metadata.depInfoList) {
+                        for (const optimizedModule of depsOptimizer.metadata({ ssr })
+                            .depInfoList) {
                             if (!optimizedModule.src)
                                 continue; // Ignore chunks
                             if (optimizedModule.file === importer) {
@@ -41506,7 +41978,7 @@ function buildImportAnalysisPlugin(config) {
                     if (ssr) {
                         return [url, url];
                     }
-                    this.error(`Failed to resolve import "${url}" from "${path$p.relative(process.cwd(), importerFile)}". Does the file exist?`, pos);
+                    this.error(`Failed to resolve import "${url}" from "${path$q.relative(process.cwd(), importerFile)}". Does the file exist?`, pos);
                 }
                 // normalize all imports into resolved URLs
                 // e.g. `import 'foo'` -> `import '/@fs/.../node_modules/foo/index.js'`
@@ -41531,7 +42003,7 @@ function buildImportAnalysisPlugin(config) {
                 if (isDynamicImport && insertPreload) {
                     needPreloadHelper = true;
                     str().prependLeft(expStart, `${preloadMethod}(() => `);
-                    str().appendRight(expEnd, `,${isModernFlag}?"${preloadMarker}":void 0${relativeBase ? ',import.meta.url' : ''})`);
+                    str().appendRight(expEnd, `,${isModernFlag}?"${preloadMarker}":void 0${relativePreloadUrls ? ',import.meta.url' : ''})`);
                 }
                 if (!depsOptimizer) {
                     continue;
@@ -41549,7 +42021,7 @@ function buildImportAnalysisPlugin(config) {
                         if (depsOptimizer.isOptimizedDepFile(resolvedId) &&
                             !resolvedId.match(optimizedDepChunkRE)) {
                             const file = cleanUrl(resolvedId); // Remove ?v={hash}
-                            const needsInterop = await optimizedDepNeedsInterop(depsOptimizer.metadata, file, config);
+                            const needsInterop = await optimizedDepNeedsInterop(depsOptimizer.metadata({ ssr }), file, config);
                             let rewriteDone = false;
                             if (needsInterop === undefined) {
                                 // Non-entry dynamic imports from dependencies will reach here as there isn't
@@ -41673,7 +42145,7 @@ function buildImportAnalysisPlugin(config) {
                                         }
                                     }
                                 };
-                                const normalizedFile = path$p.posix.join(path$p.posix.dirname(chunk.fileName), url);
+                                const normalizedFile = path$q.posix.join(path$q.posix.dirname(chunk.fileName), url);
                                 addDeps(normalizedFile);
                             }
                             let markerStartPos = code.indexOf(preloadMarkerWithQuote, end);
@@ -41690,8 +42162,8 @@ function buildImportAnalysisPlugin(config) {
                                     // main chunk is removed
                                     (hasRemovedPureCssChunk && deps.size > 0)
                                     ? `[${[...deps]
-                                        .map((d) => JSON.stringify(relativeBase
-                                        ? path$p.relative(path$p.dirname(file), d)
+                                        .map((d) => JSON.stringify(relativePreloadUrls
+                                        ? path$q.relative(path$q.dirname(file), d)
                                         : d))
                                         .join(',')}]`
                                     : `[]`, { contentOnly: true });
@@ -41729,7 +42201,7 @@ function buildImportAnalysisPlugin(config) {
 function ssrManifestPlugin(config) {
     // module id => preload assets mapping
     const ssrManifest = {};
-    const base = config.base;
+    const base = config.base; // TODO:base
     return {
         name: 'vite:ssr-manifest',
         generateBundle(_options, bundle) {
@@ -41779,14 +42251,14 @@ function ssrManifestPlugin(config) {
                                     const chunk = bundle[filename];
                                     if (chunk) {
                                         chunk.viteMetadata.importedCss.forEach((file) => {
-                                            deps.push(join$1(config.base, file));
+                                            deps.push(join$2(base, file)); // TODO:base
                                         });
                                         chunk.imports.forEach(addDeps);
                                     }
                                 };
-                                const normalizedFile = normalizePath$3(join$1(dirname$1(chunk.fileName), url.slice(1, -1)));
+                                const normalizedFile = normalizePath$3(join$2(dirname$2(chunk.fileName), url.slice(1, -1)));
                                 addDeps(normalizedFile);
-                                ssrManifest[basename$1(name)] = deps;
+                                ssrManifest[basename$2(name)] = deps;
                             }
                         }
                     }
@@ -41847,7 +42319,7 @@ function assetImportMetaUrlPlugin(config) {
                         }
                     }
                     const url = rawUrl.slice(1, -1);
-                    const file = path$p.resolve(path$p.dirname(id), url);
+                    const file = path$q.resolve(path$q.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(() => {
@@ -41893,10 +42365,10 @@ function loadFallbackPlugin() {
         async load(id) {
             try {
                 // if we don't add `await` here, we couldn't catch the error in readFile
-                return await promises.readFile(cleanUrl(id), 'utf-8');
+                return await promises$2.readFile(cleanUrl(id), 'utf-8');
             }
             catch (e) {
-                return promises.readFile(id, 'utf-8');
+                return promises$2.readFile(id, 'utf-8');
             }
         }
     };
@@ -41917,7 +42389,7 @@ function ensureWatchPlugin() {
     };
 }
 
-function resolveBuildOptions(raw) {
+function resolveBuildOptions(raw, isBuild, logger) {
     const resolved = {
         target: 'modules',
         polyfillModulePreload: true,
@@ -41985,7 +42457,7 @@ function resolveBuildPlugins(config) {
         pre: [
             ...(options.watch ? [ensureWatchPlugin()] : []),
             watchPackageDataPlugin(config),
-            ...(!isDepsOptimizerEnabled(config)
+            ...(config.legacy?.buildRollupPluginCommonjs
                 ? [commonjs(options.commonjsOptions)]
                 : []),
             dataURIPlugin(),
@@ -42036,7 +42508,7 @@ async function doBuild(inlineConfig = {}) {
     const ssr = !!options.ssr;
     const libOptions = options.lib;
     config.logger.info(colors$1.cyan(`vite v${VERSION} ${colors$1.green(`building ${ssr ? `SSR bundle ` : ``}for ${config.mode}...`)}`));
-    const resolve = (p) => path$p.resolve(config.root, p);
+    const resolve = (p) => path$q.resolve(config.root, p);
     const input = libOptions
         ? resolve(libOptions.entry)
         : typeof options.ssr === 'string'
@@ -42054,7 +42526,7 @@ async function doBuild(inlineConfig = {}) {
     // In CJS, we can pass the externals to rollup as is. In ESM, we need to
     // do it in the resolve plugin so we can add the resolved extension for
     // deep node_modules imports
-    if (ssr && config.ssr?.format === 'cjs') {
+    if (ssr && config.legacy?.buildSsrCjsExternalHeuristics) {
         external = await cjsSsrResolveExternal(config, userExternal);
     }
     if (isDepsOptimizerEnabled(config)) {
@@ -42094,9 +42566,10 @@ async function doBuild(inlineConfig = {}) {
                     `This is deprecated and will override all Vite.js default output options. ` +
                     `Please use "rollupOptions.output" instead.`);
             }
+            const ssrWorkerBuild = ssr && config.ssr?.target !== 'webworker';
             const cjsSsrBuild = ssr && config.ssr?.format === 'cjs';
             const format = output.format || (cjsSsrBuild ? 'cjs' : 'es');
-            const jsExt = (ssr && config.ssr?.target !== 'webworker') || libOptions
+            const jsExt = ssrWorkerBuild || libOptions
                 ? resolveOutputJsExtension(format, getPkgJson(config.root)?.type)
                 : 'js';
             return {
@@ -42114,16 +42587,16 @@ async function doBuild(inlineConfig = {}) {
                     ? `[name].${jsExt}`
                     : libOptions
                         ? resolveLibFilename(libOptions, format, config.root, jsExt)
-                        : path$p.posix.join(options.assetsDir, `[name].[hash].js`),
+                        : path$q.posix.join(options.assetsDir, `[name].[hash].js`),
                 chunkFileNames: libOptions
                     ? `[name].[hash].${jsExt}`
-                    : path$p.posix.join(options.assetsDir, `[name].[hash].js`),
+                    : path$q.posix.join(options.assetsDir, `[name].[hash].js`),
                 assetFileNames: libOptions
                     ? `[name].[ext]`
-                    : path$p.posix.join(options.assetsDir, `[name].[hash].[ext]`),
+                    : path$q.posix.join(options.assetsDir, `[name].[hash].[ext]`),
                 inlineDynamicImports: output.format === 'umd' ||
                     output.format === 'iife' ||
-                    (ssr && typeof input === 'string'),
+                    (ssrWorkerBuild && typeof input === 'string'),
                 ...output
             };
         };
@@ -42204,7 +42677,7 @@ async function doBuild(inlineConfig = {}) {
     }
 }
 function prepareOutDir(outDir, emptyOutDir, config) {
-    if (fs__default.existsSync(outDir)) {
+    if (fs$n.existsSync(outDir)) {
         if (emptyOutDir == null &&
             !normalizePath$3(outDir).startsWith(config.root + '/')) {
             // warn if outDir is outside of root
@@ -42215,7 +42688,7 @@ function prepareOutDir(outDir, emptyOutDir, config) {
             emptyDir(outDir, ['.git']);
         }
     }
-    if (config.publicDir && fs__default.existsSync(config.publicDir)) {
+    if (config.publicDir && fs$n.existsSync(config.publicDir)) {
         copyDir(config.publicDir, outDir);
     }
 }
@@ -42306,9 +42779,9 @@ function onRollupWarning(warning, warn, config) {
 async function cjsSsrResolveExternal(config, user) {
     // see if we have cached deps data available
     let knownImports;
-    const dataPath = path$p.join(getDepsCacheDir(config), '_metadata.json');
+    const dataPath = path$q.join(getDepsCacheDir(config, false), '_metadata.json');
     try {
-        const data = JSON.parse(fs__default.readFileSync(dataPath, 'utf-8'));
+        const data = JSON.parse(fs$n.readFileSync(dataPath, 'utf-8'));
         knownImports = Object.keys(data.optimized);
     }
     catch (e) { }
@@ -42381,6 +42854,39 @@ function wrapSsrTransform(fn) {
 function injectSsrFlag(options) {
     return { ...(options ?? {}), ssr: true };
 }
+/**
+ * Resolve base. Note that some users use Vite to build for non-web targets like
+ * electron or expects to deploy
+ */
+function resolveBuildAdvancedBaseConfig(baseConfig, resolvedBase, isBuild, logger) {
+    baseConfig ?? (baseConfig = {});
+    const relativeBaseShortcut = resolvedBase === '' || resolvedBase === './';
+    const resolved = {
+        relative: baseConfig?.relative ?? relativeBaseShortcut,
+        url: baseConfig?.url
+            ? resolveBaseUrl(baseConfig?.url, isBuild, logger, 'experimental.buildAdvancedBaseOptions.url')
+            : undefined,
+        runtime: baseConfig?.runtime
+    };
+    return {
+        ...resolved,
+        assets: resolveBuildBaseSpecificOptions(baseConfig?.assets, resolved, isBuild, logger, 'assets'),
+        public: resolveBuildBaseSpecificOptions(baseConfig?.public, resolved, isBuild, logger, 'public')
+    };
+}
+function resolveBuildBaseSpecificOptions(options, parent, isBuild, logger, optionName) {
+    const urlConfigPath = `experimental.buildAdvancedBaseOptions.${optionName}.url`;
+    if (typeof options === 'string') {
+        options = { url: options };
+    }
+    return {
+        relative: options?.relative ?? parent.relative,
+        url: options?.url
+            ? resolveBaseUrl(options?.url, isBuild, logger, urlConfigPath)
+            : parent.url,
+        runtime: options?.runtime ?? parent.runtime
+    };
+}
 
 var build$1 = {
 	__proto__: null,
@@ -42388,7 +42894,8 @@ var build$1 = {
 	resolveBuildPlugins: resolveBuildPlugins,
 	build: build,
 	resolveLibFilename: resolveLibFilename,
-	onRollupWarning: onRollupWarning
+	onRollupWarning: onRollupWarning,
+	resolveBuildAdvancedBaseConfig: resolveBuildAdvancedBaseConfig
 };
 
 var src = {exports: {}};
@@ -42949,8 +43456,8 @@ var node = {exports: {}};
  */
 
 (function (module, exports) {
-var tty = require$$0$2;
-var util = require$$0$4;
+var tty = require$$0$3;
+var util = require$$0$5;
 
 /**
  * This is the Node.js implementation of `debug()`.
@@ -43130,7 +43637,7 @@ function createWritableStdioStream (fd) {
       break;
 
     case 'FILE':
-      var fs = fs__default;
+      var fs = require$$0__default;
       stream = new fs.SyncWriteStream(fd, { autoClose: false });
       stream._type = 'fs';
       break;
@@ -43647,7 +44154,7 @@ var parseurl$1 = {exports: {}};
  * @private
  */
 
-var url$3 = require$$0$8;
+var url$3 = require$$0$9;
 var parse$9 = url$3.parse;
 var Url = url$3.Url;
 
@@ -44409,7 +44916,7 @@ module.exports = function(a, b){
  */
 
 var debug$4 = src.exports('connect:dispatcher');
-var EventEmitter$3 = require$$0$3.EventEmitter;
+var EventEmitter$3 = require$$0$4.EventEmitter;
 var finalhandler = finalhandler_1;
 var http$4 = require$$1$3;
 var merge = utilsMerge.exports;
@@ -45155,10 +45662,10 @@ var corsMiddleware = lib$2.exports;
 
 var chokidar = {};
 
-const fs$b = fs__default;
-const { Readable } = require$$0$5;
+const fs$b = require$$0__default;
+const { Readable } = require$$0$6;
 const sysPath$3 = path$p;
-const { promisify: promisify$3 } = require$$0$4;
+const { promisify: promisify$3 } = require$$0$5;
 const picomatch$1 = picomatch$3;
 
 const readdir$1 = promisify$3(fs$b.readdir);
@@ -45921,9 +46428,9 @@ exports.isLinux = platform === 'linux';
 exports.isIBMi = os.type() === 'OS400';
 }(constants$1));
 
-const fs$a = fs__default;
+const fs$a = require$$0__default;
 const sysPath$2 = path$p;
-const { promisify: promisify$2 } = require$$0$4;
+const { promisify: promisify$2 } = require$$0$5;
 const isBinaryPath = isBinaryPath$1;
 const {
   isWindows: isWindows$2,
@@ -46566,9 +47073,9 @@ var nodefsHandler = NodeFsHandler$1;
 
 var fseventsHandler = {exports: {}};
 
-const fs$9 = fs__default;
+const fs$9 = require$$0__default;
 const sysPath$1 = path$p;
-const { promisify: promisify$1 } = require$$0$4;
+const { promisify: promisify$1 } = require$$0$5;
 
 let fsevents;
 try {
@@ -47089,10 +47596,10 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
 fseventsHandler.exports = FsEventsHandler$1;
 fseventsHandler.exports.canUse = canUse;
 
-const { EventEmitter: EventEmitter$2 } = require$$0$3;
-const fs$8 = fs__default;
+const { EventEmitter: EventEmitter$2 } = require$$0$4;
+const fs$8 = require$$0__default;
 const sysPath = path$p;
-const { promisify } = require$$0$4;
+const { promisify } = require$$0$5;
 const readdirp = readdirp_1;
 const anymatch = anymatch$2.exports.default;
 const globParent = globParent$2;
@@ -48489,7 +48996,7 @@ var getArgs = function getArgumentsForPosition (
  * Modified by Yuxi Evan You
  */
 
-const fs$7 = fs__default;
+const fs$7 = require$$0__default;
 const os$2 = require$$1;
 const path$6 = path$p;
 const colors = picocolors.exports;
@@ -48618,7 +49125,7 @@ function launchEditor (file, specifiedEditor, onErrorCallback) {
 
 var launchEditor_1 = launchEditor;
 
-const url$2 = require$$0$8;
+const url$2 = require$$0$9;
 const path$5 = path$p;
 const launch = launchEditor_1;
 
@@ -48689,7 +49196,7 @@ async function resolveHttpsConfig(https, cacheDir) {
 function readFileIfExists(value) {
     if (typeof value === 'string') {
         try {
-            return fs__default.readFileSync(path$p.resolve(value));
+            return fs$n.readFileSync(path$q.resolve(value));
         }
         catch (e) {
             return value;
@@ -48698,11 +49205,11 @@ function readFileIfExists(value) {
     return value;
 }
 async function getCertificate(cacheDir) {
-    const cachePath = path$p.join(cacheDir, '_cert.pem');
+    const cachePath = path$q.join(cacheDir, '_cert.pem');
     try {
         const [stat, content] = await Promise.all([
-            promises.stat(cachePath),
-            promises.readFile(cachePath, 'utf8')
+            promises$2.stat(cachePath),
+            promises$2.readFile(cachePath, 'utf8')
         ]);
         if (Date.now() - stat.ctime.valueOf() > 30 * 24 * 60 * 60 * 1000) {
             throw new Error('cache is outdated.');
@@ -48710,22 +49217,16 @@ async function getCertificate(cacheDir) {
         return content;
     }
     catch {
-        const content = (await import('./dep-fb927717.js')).createCertificate();
-        promises
+        const content = (await import('./dep-f75aea7c.js')).createCertificate();
+        promises$2
             .mkdir(cacheDir, { recursive: true })
-            .then(() => promises.writeFile(cachePath, content))
+            .then(() => promises$2.writeFile(cachePath, content))
             .catch(() => { });
         return content;
     }
 }
 async function httpServerStart(httpServer, serverOptions) {
     let { port, strictPort, host, logger } = serverOptions;
-    // This could be removed when Vite only supports Node 17+ because verbatim=true is default
-    // https://github.com/nodejs/node/pull/39987
-    if (host === 'localhost') {
-        const addr = await promises$1.lookup('localhost', { verbatim: true });
-        host = addr.address;
-    }
     return new Promise((resolve, reject) => {
         const onError = (e) => {
             if (e.code === 'EADDRINUSE') {
@@ -48965,7 +49466,7 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
         // #3087 dynamic import vars is ignored at rewrite import path,
         // so here need process relative path
         if (dep[0] === '.') {
-            dep = path$p.posix.resolve(path$p.dirname(url), dep);
+            dep = path$q.posix.resolve(path$q.dirname(url), dep);
         }
         return ssrImport(dep);
     };
@@ -49021,7 +49522,7 @@ async function nodeImport(id, importer, resolveOptions) {
         // Use the Vite resolver only for bare imports while skipping
         // any absolute paths, built-in modules and binary modules.
         if (!bareImportRE.test(id) ||
-            path$p.isAbsolute(id) ||
+            path$q.isAbsolute(id) ||
             isBuiltin(id) ||
             id.endsWith('.node')) {
             return nodeResolve(id, parent, isMain, options);
@@ -49031,7 +49532,7 @@ async function nodeImport(id, importer, resolveOptions) {
             if (resolved) {
                 // hookNodeResolve must use platform-specific path.normalize
                 // to be compatible with dynamicImport (#6080)
-                resolved = path$p.normalize(resolved);
+                resolved = path$q.normalize(resolved);
             }
             return resolved;
         }
@@ -49281,7 +49782,7 @@ class Limiter$1 {
 
 var limiter = Limiter$1;
 
-const zlib = zlib$1;
+const zlib = require$$0$a;
 
 const bufferUtil = bufferUtil$1.exports;
 const Limiter = limiter;
@@ -49917,7 +50418,7 @@ if (!process.env.WS_NO_UTF_8_VALIDATE) {
   }
 }
 
-const { Writable: Writable$1 } = require$$0$5;
+const { Writable: Writable$1 } = require$$0$6;
 
 const PerMessageDeflate$3 = permessageDeflate;
 const {
@@ -51477,13 +51978,13 @@ var extension$1 = { format: format$1, parse: parse$6 };
 
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Readable$" }] */
 
-const EventEmitter$1 = require$$0$3;
+const EventEmitter$1 = require$$0$4;
 const https$2 = require$$1$4;
 const http$3 = require$$1$3;
 const net = require$$3$1;
 const tls = require$$4;
 const { randomBytes, createHash: createHash$1 } = require$$1$2;
-const { URL: URL$2 } = require$$0$8;
+const { URL: URL$2 } = require$$0$9;
 
 const PerMessageDeflate$1 = permessageDeflate;
 const Receiver = receiver;
@@ -52832,7 +53333,7 @@ var subprotocol$1 = { parse: parse$4 };
 
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^net|tls|https$" }] */
 
-const EventEmitter = require$$0$3;
+const EventEmitter = require$$0$4;
 const http$2 = require$$1$3;
 const { createHash } = require$$1$2;
 
@@ -53559,16 +54060,16 @@ function createWebSocketServer(server, config, httpsOptions) {
 
 // this middleware is only active when (config.base !== '/')
 function baseMiddleware({ config }) {
-    const base = config.base;
+    const devBase = config.base;
     // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
     return function viteBaseMiddleware(req, res, next) {
         const url = req.url;
         const parsed = new URL(url, 'http://vitejs.dev');
         const path = parsed.pathname || '/';
-        if (path.startsWith(base)) {
+        if (path.startsWith(devBase)) {
             // rewrite url to remove base.. this ensures that other middleware does
             // not need to consider base being prepended or not
-            req.url = url.replace(base, '/');
+            req.url = url.replace(devBase, '/');
             return next();
         }
         // skip redirect and error fallback on middleware mode, #4057
@@ -53578,18 +54079,18 @@ function baseMiddleware({ config }) {
         if (path === '/' || path === '/index.html') {
             // redirect root visit to based url with search and hash
             res.writeHead(302, {
-                Location: base + (parsed.search || '') + (parsed.hash || '')
+                Location: devBase + (parsed.search || '') + (parsed.hash || '')
             });
             res.end();
             return;
         }
         else if (req.headers.accept?.includes('text/html')) {
             // non-based page visit
-            const redirectPath = base + url.slice(1);
+            const redirectPath = devBase + url.slice(1);
             res.writeHead(404, {
                 'Content-Type': 'text/html'
             });
-            res.end(`The server is configured with a public base URL of ${base} - ` +
+            res.end(`The server is configured with a public base URL of ${devBase} - ` +
                 `did you mean to visit <a href="${redirectPath}">${redirectPath}</a> instead?`);
             return;
         }
@@ -53980,8 +54481,8 @@ var requiresPort = function required(port, protocol) {
 
 (function (exports) {
 var common   = exports,
-    url      = require$$0$8,
-    extend   = require$$0$4._extend,
+    url      = require$$0$9,
+    extend   = require$$0$5._extend,
     required = requiresPort;
 
 var upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i,
@@ -54228,7 +54729,7 @@ function hasPort(host) {
   return !!~host.indexOf(':');
 }}(common$3));
 
-var url$1    = require$$0$8,
+var url$1    = require$$0$9,
     common$2 = common$3;
 
 
@@ -54394,12 +54895,12 @@ var debug_1 = function () {
   debug$3.apply(null, arguments);
 };
 
-var url = require$$0$8;
+var url = require$$0$9;
 var URL$1 = url.URL;
 var http$1 = require$$1$3;
 var https$1 = require$$1$4;
-var Writable = require$$0$5.Writable;
-var assert = require$$5;
+var Writable = require$$0$6.Writable;
+var assert = assert$3;
 var debug$2 = debug_1;
 
 // Create handlers that pass events from native requests
@@ -55348,8 +55849,8 @@ var wsIncoming = {
 
 (function (module) {
 var httpProxy = module.exports,
-    extend    = require$$0$4._extend,
-    parse_url = require$$0$8.parse,
+    extend    = require$$0$5._extend,
+    parse_url = require$$0$9.parse,
     EE3       = eventemitter3.exports,
     http      = require$$1$3,
     https     = require$$1$4,
@@ -55458,7 +55959,7 @@ function ProxyServer(options) {
 
 }
 
-require$$0$4.inherits(ProxyServer, EE3);
+require$$0$5.inherits(ProxyServer, EE3);
 
 ProxyServer.prototype.onError = function (err) {
   //
@@ -55623,11 +56124,16 @@ function proxyMiddleware(httpServer, options, config) {
             opts = { target: opts, changeOrigin: true };
         }
         const proxy = httpProxy.createProxyServer(opts);
-        proxy.on('error', (err) => {
+        proxy.on('error', (err, req, res) => {
             config.logger.error(`${colors$1.red(`http proxy error:`)}\n${err.stack}`, {
                 timestamp: true,
                 error: err
             });
+            res
+                .writeHead(500, {
+                'Content-Type': 'text/plain'
+            })
+                .end();
         });
         if (opts.configure) {
             opts.configure(proxy, opts);
@@ -55698,7 +56204,7 @@ var lib$1 = {exports: {}};
 
 (function (module, exports) {
 
-var url = require$$0$8;
+var url = require$$0$9;
 
 module.exports = function historyApiFallback(options) {
   options = options || {};
@@ -55829,7 +56335,7 @@ function spaFallbackMiddleware(root) {
                 from: /\/$/,
                 to({ parsedUrl }) {
                     const rewritten = decodeURIComponent(parsedUrl.pathname) + 'index.html';
-                    if (fs__default.existsSync(path$p.join(root, rewritten))) {
+                    if (fs$n.existsSync(path$q.join(root, rewritten))) {
                         return rewritten;
                     }
                     else {
@@ -55907,9 +56413,9 @@ function transformMiddleware(server) {
                     // means that the dependency has already been pre-bundled and loaded
                     const mapFile = url.startsWith(FS_PREFIX)
                         ? fsPathFromId(url)
-                        : normalizePath$3(ensureVolumeInPath(path$p.resolve(root, url.slice(1))));
+                        : normalizePath$3(ensureVolumeInPath(path$q.resolve(root, url.slice(1))));
                     try {
-                        const map = await promises.readFile(mapFile, 'utf-8');
+                        const map = await promises$2.readFile(mapFile, 'utf-8');
                         return send(req, res, map, 'json', {
                             headers: server.config.server.headers
                         });
@@ -56058,7 +56564,7 @@ function getHtmlFilename(url, server) {
         return decodeURIComponent(fsPathFromId(url));
     }
     else {
-        return decodeURIComponent(normalizePath$3(path$p.join(server.config.root, url.slice(1))));
+        return decodeURIComponent(normalizePath$3(path$q.join(server.config.root, url.slice(1))));
     }
 }
 const startsWithSingleSlashRE = /^\/(?!\/)/;
@@ -56070,15 +56576,16 @@ const processNodeUrl = (node, s, config, htmlPath, originalUrl, moduleGraph) =>
             url = injectQuery(url, `t=${mod.lastHMRTimestamp}`);
         }
     }
+    const devBase = config.base;
     if (startsWithSingleSlashRE.test(url)) {
         // prefix with base (dev only, base is never relative)
-        s.overwrite(node.value.loc.start.offset, node.value.loc.end.offset, `"${config.base + url.slice(1)}"`, { contentOnly: true });
+        s.overwrite(node.value.loc.start.offset, node.value.loc.end.offset, `"${devBase + url.slice(1)}"`, { contentOnly: true });
     }
     else if (url.startsWith('.') &&
         originalUrl &&
         originalUrl !== '/' &&
         htmlPath === '/index.html') {
-        const replacer = (url) => path$p.posix.join(config.base, path$p.posix.relative(originalUrl, config.base), url.slice(1));
+        const replacer = (url) => path$q.posix.join(devBase, path$q.posix.relative(originalUrl, devBase), url.slice(1));
         // #3230 if some request url (localhost:3000/a/b) return to fallback html, the relative assets
         // path will add `/a/` prefix, it will caused 404.
         // rewrite before `./index.js` -> `localhost:5173/a/index.js`.
@@ -56094,7 +56601,7 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
     let proxyModulePath;
     let proxyModuleUrl;
     const trailingSlash = htmlPath.endsWith('/');
-    if (!trailingSlash && fs__default.existsSync(filename)) {
+    if (!trailingSlash && fs$n.existsSync(filename)) {
         proxyModulePath = htmlPath;
         proxyModuleUrl = base + htmlPath.slice(1);
     }
@@ -56185,7 +56692,7 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
                 tag: 'script',
                 attrs: {
                     type: 'module',
-                    src: path$p.posix.join(base, CLIENT_PUBLIC_PATH)
+                    src: path$q.posix.join(base, CLIENT_PUBLIC_PATH)
                 },
                 injectTo: 'head-prepend'
             }
@@ -56202,9 +56709,9 @@ function indexHtmlMiddleware(server) {
         // spa-fallback always redirects to /index.html
         if (url?.endsWith('.html') && req.headers['sec-fetch-dest'] !== 'script') {
             const filename = getHtmlFilename(url, server);
-            if (fs__default.existsSync(filename)) {
+            if (fs$n.existsSync(filename)) {
                 try {
-                    let html = fs__default.readFileSync(filename, 'utf-8');
+                    let html = fs$n.readFileSync(filename, 'utf-8');
                     html = await server.transformIndexHtml(url, html, req.originalUrl);
                     return send(req, res, html, 'html', {
                         headers: server.config.server.headers
@@ -56244,6 +56751,8 @@ class ModuleNode {
         this.importers = new Set();
         this.importedModules = new Set();
         this.acceptedHmrDeps = new Set();
+        this.acceptedHmrExports = null;
+        this.importedBindings = null;
         this.transformResult = null;
         this.ssrTransformResult = null;
         this.ssrModule = null;
@@ -56319,7 +56828,7 @@ class ModuleGraph {
      * If there are dependencies that no longer have any importers, they are
      * returned as a Set.
      */
-    async updateModuleInfo(mod, importedModules, acceptedModules, isSelfAccepting, ssr) {
+    async updateModuleInfo(mod, importedModules, importedBindings, acceptedModules, acceptedExports, isSelfAccepting, ssr) {
         mod.isSelfAccepting = isSelfAccepting;
         const prevImports = mod.importedModules;
         const nextImports = (mod.importedModules = new Set());
@@ -56349,6 +56858,9 @@ class ModuleGraph {
                 : accepted;
             deps.add(dep);
         }
+        // update accepted hmr exports
+        mod.acceptedHmrExports = acceptedExports;
+        mod.importedBindings = importedBindings;
         return noLongerImported;
     }
     async ensureEntryFromUrl(rawUrl, ssr) {
@@ -56401,7 +56913,7 @@ class ModuleGraph {
         url = removeImportQuery(removeTimestampQuery(url));
         const resolved = await this.resolveId(url, !!ssr);
         const resolvedId = resolved?.id || url;
-        const ext = extname(cleanUrl(resolvedId));
+        const ext = extname$1(cleanUrl(resolvedId));
         const { pathname, search, hash } = parse$m(url);
         if (ext && !pathname.endsWith(ext)) {
             url = pathname + ext + (search || '') + (hash || '');
@@ -56412,7 +56924,7 @@ class ModuleGraph {
 
 var isWsl$2 = {exports: {}};
 
-const fs$6 = fs__default;
+const fs$6 = require$$0__default;
 
 let isDocker$2;
 
@@ -56442,7 +56954,7 @@ var isDocker_1 = () => {
 };
 
 const os$1 = require$$1;
-const fs$5 = fs__default;
+const fs$5 = require$$0__default;
 const isDocker$1 = isDocker_1;
 
 const isWsl$1 = () => {
@@ -56493,7 +57005,7 @@ var defineLazyProp = (object, propertyName, fn) => {
 
 const path$4 = path$p;
 const childProcess = require$$2;
-const {promises: fs$4, constants: fsConstants} = fs__default;
+const {promises: fs$4, constants: fsConstants} = require$$0__default;
 const isWsl = isWsl$2.exports;
 const isDocker = isDocker_1;
 const defineLazyProperty = defineLazyProp;
@@ -56812,7 +57324,7 @@ var crossSpawn = {exports: {}};
 var windows = isexe$3;
 isexe$3.sync = sync$2;
 
-var fs$3 = fs__default;
+var fs$3 = require$$0__default;
 
 function checkPathExt (path, options) {
   var pathext = options.pathExt !== undefined ?
@@ -56855,7 +57367,7 @@ function sync$2 (path, options) {
 var mode = isexe$2;
 isexe$2.sync = sync$1;
 
-var fs$2 = fs__default;
+var fs$2 = require$$0__default;
 
 function isexe$2 (path, options, cb) {
   fs$2.stat(path, function (er, stat) {
@@ -57212,7 +57724,7 @@ var shebangCommand$1 = (string = '') => {
 	return argument ? `${binary} ${argument}` : binary;
 };
 
-const fs$1 = fs__default;
+const fs$1 = require$$0__default;
 const shebangCommand = shebangCommand$1;
 
 function readShebang$1(command) {
@@ -57473,7 +57985,7 @@ function startBrowserProcess(browser, url) {
             // on OS X Google Chrome with AppleScript
             execSync('ps cax | grep "Google Chrome"');
             execSync('osascript openChrome.applescript "' + encodeURI(url) + '"', {
-                cwd: join$1(VITE_PACKAGE_DIR, 'bin'),
+                cwd: join$2(VITE_PACKAGE_DIR, 'bin'),
                 stdio: 'ignore'
             });
             return true;
@@ -57517,19 +58029,19 @@ const ROOT_FILES = [
 // npm: https://docs.npmjs.com/cli/v7/using-npm/workspaces#installing-workspaces
 // yarn: https://classic.yarnpkg.com/en/docs/workspaces/#toc-how-to-use-it
 function hasWorkspacePackageJSON(root) {
-    const path = join$1(root, 'package.json');
+    const path = join$2(root, 'package.json');
     if (!isFileReadable(path)) {
         return false;
     }
-    const content = JSON.parse(fs__default.readFileSync(path, 'utf-8')) || {};
+    const content = JSON.parse(fs$n.readFileSync(path, 'utf-8')) || {};
     return !!content.workspaces;
 }
 function hasRootFile(root) {
-    return ROOT_FILES.some((file) => fs__default.existsSync(join$1(root, file)));
+    return ROOT_FILES.some((file) => fs$n.existsSync(join$2(root, file)));
 }
 function hasPackageJSON(root) {
-    const path = join$1(root, 'package.json');
-    return fs__default.existsSync(path);
+    const path = join$2(root, 'package.json');
+    return fs$n.existsSync(path);
 }
 /**
  * Search up for the nearest `package.json`
@@ -57537,7 +58049,7 @@ function hasPackageJSON(root) {
 function searchForPackageRoot(current, root = current) {
     if (hasPackageJSON(current))
         return current;
-    const dir = dirname$1(current);
+    const dir = dirname$2(current);
     // reach the fs root
     if (!dir || dir === current)
         return root;
@@ -57551,7 +58063,7 @@ function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
         return current;
     if (hasWorkspacePackageJSON(current))
         return current;
-    const dir = dirname$1(current);
+    const dir = dirname$2(current);
     // reach the fs root
     if (!dir || dir === current)
         return root;
@@ -57562,17 +58074,14 @@ async function createServer(inlineConfig = {}) {
     const config = await resolveConfig(inlineConfig, 'serve', 'development');
     const { root, server: serverConfig } = config;
     const httpsOptions = await resolveHttpsConfig(config.server.https, config.cacheDir);
-    let { middlewareMode } = serverConfig;
-    if (middlewareMode === true) {
-        middlewareMode = 'ssr';
-    }
+    const { middlewareMode } = serverConfig;
     const middlewares = connect();
     const httpServer = middlewareMode
         ? null
         : await resolveHttpServer(serverConfig, middlewares, httpsOptions);
     const ws = createWebSocketServer(httpServer, config, httpsOptions);
     const { ignored = [], ...watchOptions } = serverConfig.watch || {};
-    const watcher = chokidar.watch(path$p.resolve(root), {
+    const watcher = chokidar.watch(path$q.resolve(root), {
         ignored: [
             '**/node_modules/**',
             '**/.git/**',
@@ -57634,9 +58143,9 @@ async function createServer(inlineConfig = {}) {
                 closeHttpServer()
             ]);
         },
-        printUrls() {
+        async printUrls() {
             if (httpServer) {
-                printCommonServerUrls(httpServer, config.server, config);
+                await printCommonServerUrls(httpServer, config.server, config);
             }
             else {
                 throw new Error('cannot print server URLs in middleware mode.');
@@ -57735,7 +58244,8 @@ async function createServer(inlineConfig = {}) {
         middlewares.use(proxyMiddleware(httpServer, proxy, config));
     }
     // base
-    if (config.base !== '/') {
+    const devBase = config.base;
+    if (devBase !== '/') {
         middlewares.use(baseMiddleware(server));
     }
     // open in editor support
@@ -57751,20 +58261,17 @@ async function createServer(inlineConfig = {}) {
     // serve static files
     middlewares.use(serveRawFsMiddleware(server));
     middlewares.use(serveStaticMiddleware(root, server));
-    const isMiddlewareMode = middlewareMode && middlewareMode !== 'html';
     // spa fallback
-    if (config.spa && !isMiddlewareMode) {
+    if (config.appType === 'spa') {
         middlewares.use(spaFallbackMiddleware(root));
     }
     // run post config hooks
     // This is applied before the html middleware so that user middleware can
     // serve custom content instead of index.html.
     postHooks.forEach((fn) => fn && fn());
-    if (config.spa && !isMiddlewareMode) {
+    if (config.appType === 'spa' || config.appType === 'mpa') {
         // transform index.html
         middlewares.use(indexHtmlMiddleware(server));
-    }
-    if (!isMiddlewareMode) {
         // handle 404s
         // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
         middlewares.use(function vite404Middleware(_, res) {
@@ -57773,7 +58280,7 @@ async function createServer(inlineConfig = {}) {
         });
     }
     // error handler
-    middlewares.use(errorMiddleware(server, !!middlewareMode));
+    middlewares.use(errorMiddleware(server, middlewareMode));
     const initOptimizer = async () => {
         if (isDepsOptimizerEnabled(config)) {
             await initDepsOptimizer(config, server);
@@ -57811,10 +58318,10 @@ async function startServer(server, inlinePort, isRestart = false) {
     }
     const options = server.config.server;
     const port = inlinePort ?? options.port ?? 5173;
-    const hostname = resolveHostname(options.host);
+    const hostname = await resolveHostname(options.host);
     const protocol = options.https ? 'https' : 'http';
     const info = server.config.logger.info;
-    const base = server.config.base;
+    const devBase = server.config.base;
     const serverPort = await httpServerStart(httpServer, {
         port,
         strictPort: options.strictPort,
@@ -57827,8 +58334,8 @@ async function startServer(server, inlinePort, isRestart = false) {
         profileSession.post('Profiler.stop', (err, { profile }) => {
             // Write profile to disk, upload, etc.
             if (!err) {
-                const outPath = path$p.resolve('./vite-profile.cpuprofile');
-                fs__default.writeFileSync(outPath, JSON.stringify(profile));
+                const outPath = path$q.resolve('./vite-profile.cpuprofile');
+                fs$n.writeFileSync(outPath, JSON.stringify(profile));
                 info(colors$1.yellow(`  CPU profile written to ${colors$1.white(colors$1.dim(outPath))}\n`));
             }
             else {
@@ -57837,7 +58344,7 @@ async function startServer(server, inlinePort, isRestart = false) {
         });
     }
     if (options.open && !isRestart) {
-        const path = typeof options.open === 'string' ? options.open : base;
+        const path = typeof options.open === 'string' ? options.open : devBase;
         openBrowser(path.startsWith('http')
             ? path
             : `${protocol}://${hostname.name}:${serverPort}${path}`, true, server.config.logger);
@@ -57877,12 +58384,13 @@ function createServerCloseFn(server) {
     });
 }
 function resolvedAllowDir(root, dir) {
-    return normalizePath$3(path$p.resolve(root, dir));
+    return normalizePath$3(path$q.resolve(root, dir));
 }
 function resolveServerOptions(root, raw, logger) {
     const server = {
         preTransformRequests: true,
-        ...raw
+        ...raw,
+        middlewareMode: !!raw?.middlewareMode
     };
     let allowDirs = server.fs?.allow;
     const deny = server.fs?.deny || ['.env', '.env.*', '*.{crt,pem}'];
@@ -57957,13 +58465,15 @@ async function restartServer(server) {
 }
 async function updateCjsSsrExternals(server) {
     if (!server._ssrExternals) {
+        // We use the non-ssr optimized deps to find known imports
         let knownImports = [];
         const depsOptimizer = getDepsOptimizer(server.config);
         if (depsOptimizer) {
             await depsOptimizer.scanProcessing;
+            const metadata = depsOptimizer.metadata({ ssr: false });
             knownImports = [
-                ...Object.keys(depsOptimizer.metadata.optimized),
-                ...Object.keys(depsOptimizer.metadata.discovered)
+                ...Object.keys(metadata.optimized),
+                ...Object.keys(metadata.discovered)
             ];
         }
         server._ssrExternals = cjsSsrResolveExternals(server.config, knownImports);
@@ -58121,21 +58631,21 @@ async function preview(inlineConfig = {}) {
         app.use(proxyMiddleware(httpServer, proxy, config));
     }
     app.use(compression());
+    const previewBase = config.base === './' || config.base === '' ? '/' : config.base;
     // static assets
-    const distDir = path$p.resolve(config.root, config.build.outDir);
-    app.use(config.base, sirv(distDir, {
+    const distDir = path$q.resolve(config.root, config.build.outDir);
+    app.use(previewBase, sirv(distDir, {
         etag: true,
         dev: true,
-        single: config.spa
+        single: config.appType === 'spa'
     }));
     // apply post server hooks from plugins
     postHooks.forEach((fn) => fn && fn());
     const options = config.preview;
-    const hostname = resolveHostname(options.host);
+    const hostname = await resolveHostname(options.host);
     const port = options.port ?? 4173;
     const protocol = options.https ? 'https' : 'http';
     const logger = config.logger;
-    const base = config.base;
     const serverPort = await httpServerStart(httpServer, {
         port,
         strictPort: options.strictPort,
@@ -58143,7 +58653,7 @@ async function preview(inlineConfig = {}) {
         logger
     });
     if (options.open) {
-        const path = typeof options.open === 'string' ? options.open : base;
+        const path = typeof options.open === 'string' ? options.open : previewBase;
         openBrowser(path.startsWith('http')
             ? path
             : `${protocol}://${hostname.name}:${serverPort}${path}`, true, logger);
@@ -58151,8 +58661,8 @@ async function preview(inlineConfig = {}) {
     return {
         config,
         httpServer,
-        printUrls() {
-            printCommonServerUrls(httpServer, config.preview, config);
+        async printUrls() {
+            await printCommonServerUrls(httpServer, config.preview, config);
         }
     };
 }
@@ -58173,38 +58683,39 @@ const normalizedEnvEntry = normalizePath$3(ENV_ENTRY);
 function clientInjectionsPlugin(config) {
     return {
         name: 'vite:client-inject',
-        transform(code, id, options) {
+        async transform(code, id, options) {
             if (id === normalizedClientEntry || id === normalizedEnvEntry) {
-                let options = config.server.hmr;
-                options = options && typeof options !== 'boolean' ? options : {};
-                const host = options.host || null;
-                const protocol = options.protocol || null;
-                const timeout = options.timeout || 30000;
-                const overlay = options.overlay !== false;
-                let port;
-                if (isObject$2(config.server.hmr)) {
-                    port = config.server.hmr.clientPort || config.server.hmr.port;
-                }
+                let hmrConfig = config.server.hmr;
+                hmrConfig = isObject$2(hmrConfig) ? hmrConfig : undefined;
+                const host = hmrConfig?.host || null;
+                const protocol = hmrConfig?.protocol || null;
+                const timeout = hmrConfig?.timeout || 30000;
+                const overlay = hmrConfig?.overlay !== false;
+                // hmr.clientPort -> hmr.port
+                // -> (24678 if middleware mode) -> new URL(import.meta.url).port
+                let port = hmrConfig
+                    ? String(hmrConfig.clientPort || hmrConfig.port)
+                    : null;
                 if (config.server.middlewareMode) {
-                    port = String(port || 24678);
-                }
-                else {
-                    port = String(port || options.port || config.server.port);
-                }
-                let hmrBase = config.base;
-                if (options.path) {
-                    hmrBase = path$p.posix.join(hmrBase, options.path);
+                    port || (port = '24678');
                 }
-                if (hmrBase !== '/') {
-                    port = path$p.posix.normalize(`${port}${hmrBase}`);
+                const devBase = config.base;
+                let directTarget = hmrConfig?.host || (await resolveHostname(config.server.host)).name;
+                directTarget += `:${hmrConfig?.port || config.server.port}`;
+                directTarget += devBase;
+                let hmrBase = devBase;
+                if (hmrConfig?.path) {
+                    hmrBase = path$q.posix.join(hmrBase, hmrConfig.path);
                 }
                 return code
                     .replace(`__MODE__`, JSON.stringify(config.mode))
-                    .replace(`__BASE__`, JSON.stringify(config.base))
+                    .replace(`__BASE__`, JSON.stringify(devBase))
                     .replace(`__DEFINES__`, serializeDefine(config.define || {}))
                     .replace(`__HMR_PROTOCOL__`, JSON.stringify(protocol))
                     .replace(`__HMR_HOSTNAME__`, JSON.stringify(host))
                     .replace(`__HMR_PORT__`, JSON.stringify(port))
+                    .replace(`__HMR_DIRECT_TARGET__`, JSON.stringify(directTarget))
+                    .replace(`__HMR_BASE__`, JSON.stringify(hmrBase))
                     .replace(`__HMR_TIMEOUT__`, JSON.stringify(timeout))
                     .replace(`__HMR_ENABLE_OVERLAY__`, JSON.stringify(overlay));
             }
@@ -58231,11 +58742,21 @@ const wasmHelperId = '/__vite-wasm-helper';
 const wasmHelper = async (opts = {}, url) => {
     let result;
     if (url.startsWith('data:')) {
-        // @ts-ignore
-        const binaryString = atob(url.replace(/^data:.*?base64,/, ''));
-        const bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
+        const urlContent = url.replace(/^data:.*?base64,/, '');
+        let bytes;
+        if (typeof Buffer === 'function' && typeof Buffer.from === 'function') {
+            bytes = Buffer.from(urlContent, 'base64');
+        }
+        else if (typeof atob === 'function') {
+            // @ts-ignore
+            const binaryString = atob(urlContent);
+            bytes = new Uint8Array(binaryString.length);
+            for (let i = 0; i < binaryString.length; i++) {
+                bytes[i] = binaryString.charCodeAt(i);
+            }
+        }
+        else {
+            throw new Error('Failed to decode base64-encoded data URL, Buffer and atob are not supported');
         }
         // @ts-ignore
         result = await WebAssembly.instantiate(bytes, opts);
@@ -58332,9 +58853,9 @@ async function bundleWorkerEntry(config, id, query) {
                 : workerOutputConfig
             : {};
         const { output: [outputChunk, ...outputChunks] } = await bundle.generate({
-            entryFileNames: path$p.posix.join(config.build.assetsDir, '[name].[hash].js'),
-            chunkFileNames: path$p.posix.join(config.build.assetsDir, '[name].[hash].js'),
-            assetFileNames: path$p.posix.join(config.build.assetsDir, '[name].[hash].[ext]'),
+            entryFileNames: path$q.posix.join(config.build.assetsDir, '[name].[hash].js'),
+            chunkFileNames: path$q.posix.join(config.build.assetsDir, '[name].[hash].js'),
+            assetFileNames: path$q.posix.join(config.build.assetsDir, '[name].[hash].[ext]'),
             ...workerConfig,
             format,
             sourcemap: config.build.sourcemap
@@ -58386,7 +58907,7 @@ function emitSourcemapForWorkerEntry(config, query, chunk) {
                 // non-inline web workers can use a relative path
                 const sourceMapUrl = query?.inline != null
                     ? mapFileName
-                    : path$p.relative(config.build.assetsDir, mapFileName);
+                    : path$q.relative(config.build.assetsDir, mapFileName);
                 chunk.code += `//# sourceMappingURL=${sourceMapUrl}`;
             }
         }
@@ -58415,9 +58936,10 @@ async function workerFileToUrl(config, id, query) {
         });
         workerMap.bundle.set(id, fileName);
     }
-    return isRelativeBase(config.base)
+    const assetsBase = config.experimental.buildAdvancedBaseOptions.assets;
+    return assetsBase.relative || assetsBase.runtime
         ? encodeWorkerAssetFileName(fileName, workerMap)
-        : config.base + fileName;
+        : (assetsBase.url ?? config.base) + fileName;
 }
 function webWorkerPlugin(config) {
     const isBuild = config.command === 'build';
@@ -58546,14 +59068,28 @@ function webWorkerPlugin(config) {
                 // Replace "__VITE_WORKER_ASSET__5aa0ddc0__" using relative paths
                 const workerMap = workerCache.get(config.mainConfig || config);
                 const { fileNameHash } = workerMap;
+                const assetsBase = config.experimental.buildAdvancedBaseOptions.assets;
                 while ((match = workerAssetUrlRE.exec(code))) {
                     const [full, hash] = match;
                     const filename = fileNameHash.get(hash);
-                    let outputFilepath = path$p.posix.relative(path$p.dirname(chunk.fileName), filename);
-                    if (!outputFilepath.startsWith('.')) {
-                        outputFilepath = './' + outputFilepath;
+                    let replacement;
+                    if (assetsBase.runtime) {
+                        replacement = `"+${assetsBase.runtime(JSON.stringify(filename))}+"`;
+                    }
+                    else {
+                        // Relative base
+                        let outputFilepath;
+                        if (assetsBase.relative && !config.build.ssr) {
+                            outputFilepath = path$q.posix.relative(path$q.dirname(chunk.fileName), filename);
+                            if (!outputFilepath.startsWith('.')) {
+                                outputFilepath = './' + outputFilepath;
+                            }
+                        }
+                        else {
+                            outputFilepath = (assetsBase.url ?? config.base) + filename;
+                        }
+                        replacement = JSON.stringify(outputFilepath).slice(1, -1);
                     }
-                    const replacement = JSON.stringify(outputFilepath).slice(1, -1);
                     s.overwrite(match.index, match.index + full.length, replacement, {
                         contentOnly: true
                     });
@@ -58583,12 +59119,10 @@ function preAliasPlugin(config) {
     return {
         name: 'vite:pre-alias',
         async resolveId(id, importer, options) {
+            const ssr = options?.ssr ?? false;
             const depsOptimizer = getDepsOptimizer(config);
-            if (depsOptimizer &&
-                !options?.ssr &&
-                bareImportRE.test(id) &&
-                !options?.scan) {
-                return await tryOptimizedResolve(depsOptimizer, id, importer);
+            if (depsOptimizer && bareImportRE.test(id) && !options?.scan) {
+                return await tryOptimizedResolve(depsOptimizer, ssr, id, importer);
             }
         }
     };
@@ -60180,7 +60714,7 @@ function workerImportMetaUrlPlugin(config) {
                     }
                     s || (s = new MagicString(code));
                     const workerType = getWorkerType(code, cleanString, index + allExp.length);
-                    const file = normalizePath$3(path$p.resolve(path$p.dirname(id), rawUrl.slice(1, -1)));
+                    const file = normalizePath$3(path$q.resolve(path$q.dirname(id), rawUrl.slice(1, -1)));
                     let url;
                     if (isBuild) {
                         getDepsOptimizer(config)?.registerWorkersSource(id);
@@ -60365,7 +60899,7 @@ async function transformDynamicImport(importSource, importer, resolve) {
         if (!resolvedFileName) {
             return null;
         }
-        const relativeFileName = posix$1.relative(posix$1.dirname(normalizePath$3(importer)), normalizePath$3(resolvedFileName));
+        const relativeFileName = posix$2.relative(posix$2.dirname(normalizePath$3(importer)), normalizePath$3(resolvedFileName));
         importSource = normalizePath$3('`' + (relativeFileName[0] === '.' ? '' : './') + relativeFileName + '`');
     }
     const dynamicImportPattern = parseDynamicImportPattern(importSource);
@@ -60522,7 +61056,7 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
 
 var main$1 = {exports: {}};
 
-const fs = fs__default;
+const fs = require$$0__default;
 const path = path$p;
 const os = require$$1;
 
@@ -60736,7 +61270,7 @@ function loadEnv(mode, envDir, prefixes = 'VITE_') {
     for (const file of envFiles) {
         const path = lookupFile(envDir, [file], { pathOnly: true, rootDir: envDir });
         if (path) {
-            const parsed = dotenv.parse(fs__default.readFileSync(path), {
+            const parsed = dotenv.parse(fs$n.readFileSync(path), {
                 debug: process.env.DEBUG?.includes('vite:dotenv') || undefined
             });
             // let environment variables use each other
@@ -60822,7 +61356,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
     mode = inlineConfig.mode || config.mode || mode;
     configEnv.mode = mode;
     // resolve plugins
-    const rawUserPlugins = (config.plugins || []).flat(Infinity).filter((p) => {
+    const rawUserPlugins = (await asyncFlatten(config.plugins || [])).filter((p) => {
         if (!p) {
             return false;
         }
@@ -60854,7 +61388,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
         }
     }
     // resolve root
-    const resolvedRoot = normalizePath$3(config.root ? path$p.resolve(config.root) : process.cwd());
+    const resolvedRoot = normalizePath$3(config.root ? path$q.resolve(config.root) : process.cwd());
     const clientAlias = [
         { find: /^[\/]?@vite\/env/, replacement: () => ENV_ENTRY },
         { find: /^[\/]?@vite\/client/, replacement: () => CLIENT_ENTRY }
@@ -60870,7 +61404,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
     };
     // load .env files
     const envDir = config.envDir
-        ? normalizePath$3(path$p.resolve(resolvedRoot, config.envDir))
+        ? normalizePath$3(path$q.resolve(resolvedRoot, config.envDir))
         : resolvedRoot;
     const userEnv = inlineConfig.envFile !== false &&
         loadEnv(mode, envDir, resolveEnvPrefix(config));
@@ -60884,15 +61418,31 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
         process.env.NODE_ENV = 'production';
     }
     // resolve public base url
-    const BASE_URL = resolveBaseUrl(config.base, command === 'build', logger);
+    const isBuild = command === 'build';
+    const relativeBaseShortcut = config.base === '' || config.base === './';
+    // During dev, we ignore relative base and fallback to '/'
+    // For the SSR build, relative base isn't possible by means
+    // of import.meta.url. The user will be able to work out a setup
+    // using experimental.buildAdvancedBaseOptions
+    const base = relativeBaseShortcut && (!isBuild || config.build?.ssr)
+        ? '/'
+        : config.base ?? '/';
+    let resolvedBase = relativeBaseShortcut
+        ? base
+        : resolveBaseUrl(base, isBuild, logger, 'base');
+    if (config.experimental?.buildAdvancedBaseOptions?.relative &&
+        config.base === undefined) {
+        resolvedBase = './';
+    }
+    const resolvedBuildAdvancedBaseOptions = resolveBuildAdvancedBaseConfig(config.experimental?.buildAdvancedBaseOptions, resolvedBase, isBuild, logger);
     const resolvedBuildOptions = resolveBuildOptions(config.build);
     // resolve cache directory
     const pkgPath = lookupFile(resolvedRoot, [`package.json`], { pathOnly: true });
     const cacheDir = config.cacheDir
-        ? path$p.resolve(resolvedRoot, config.cacheDir)
+        ? path$q.resolve(resolvedRoot, config.cacheDir)
         : pkgPath
-            ? path$p.join(path$p.dirname(pkgPath), `node_modules/.vite`)
-            : path$p.join(resolvedRoot, `.vite`);
+            ? path$q.join(path$q.dirname(pkgPath), `node_modules/.vite`)
+            : path$q.join(resolvedRoot, `.vite`);
     const assetsFilter = config.assetsInclude
         ? createFilter(config.assetsInclude)
         : () => false;
@@ -60937,18 +61487,26 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
     };
     const { publicDir } = config;
     const resolvedPublicDir = publicDir !== false && publicDir !== ''
-        ? path$p.resolve(resolvedRoot, typeof publicDir === 'string' ? publicDir : 'public')
+        ? path$q.resolve(resolvedRoot, typeof publicDir === 'string' ? publicDir : 'public')
         : '';
     const server = resolveServerOptions(resolvedRoot, config.server, logger);
-    const ssr = resolveSSROptions(config.ssr);
+    let ssr = resolveSSROptions(config.ssr);
+    if (config.legacy?.buildSsrCjsExternalHeuristics) {
+        if (ssr)
+            ssr.format = 'cjs';
+        else
+            ssr = { target: 'node', format: 'cjs' };
+    }
+    const middlewareMode = config?.server?.middlewareMode;
     const optimizeDeps = config.optimizeDeps || {};
+    const BASE_URL = resolvedBase;
     const resolved = {
         ...config,
         configFile: configFile ? normalizePath$3(configFile) : undefined,
-        configFileDependencies: configFileDependencies.map((name) => normalizePath$3(path$p.resolve(name))),
+        configFileDependencies: configFileDependencies.map((name) => normalizePath$3(path$q.resolve(name))),
         inlineConfig,
         root: resolvedRoot,
-        base: BASE_URL,
+        base: resolvedBase,
         resolve: resolveOptions,
         publicDir: resolvedPublicDir,
         cacheDir,
@@ -60983,9 +61541,32 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
             }
         },
         worker: resolvedWorkerOptions,
-        spa: config.spa ?? true
+        appType: config.appType ?? middlewareMode === 'ssr' ? 'custom' : 'spa',
+        experimental: {
+            importGlobRestoreExtension: false,
+            hmrPartialAccept: false,
+            ...config.experimental,
+            buildAdvancedBaseOptions: resolvedBuildAdvancedBaseOptions
+        }
     };
-    // flat config.worker.plugin
+    if (middlewareMode === 'ssr') {
+        logger.warn(colors$1.yellow(`server.middlewareMode 'ssr' is now deprecated, use server.middlewareMode true and appType 'custom'`));
+    }
+    if (middlewareMode === 'html') {
+        logger.warn(colors$1.yellow(`server.middlewareMode 'html' is now deprecated, use server.middlewareMode true`));
+    }
+    if (resolved.legacy?.buildRollupPluginCommonjs) {
+        const optimizerDisabled = resolved.optimizeDeps.disabled;
+        if (!optimizerDisabled) {
+            resolved.optimizeDeps.disabled = 'build';
+        }
+        else if (optimizerDisabled === 'dev') {
+            resolved.optimizeDeps.disabled = true; // Also disabled during build
+        }
+    }
+    // Some plugins that aren't intended to work in the bundling of workers (doing post-processing at build time for example).
+    // And Plugins may also have cached that could be corrupted by being used in these extra rollup calls.
+    // So we need to separate the worker plugin from the plugin that vite needs to run.
     const [workerPrePlugins, workerNormalPlugins, workerPostPlugins] = sortUserPlugins(config.worker?.plugins);
     const workerResolved = {
         ...resolved,
@@ -61009,19 +61590,31 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
             `Note Vite now defaults to use esbuild for minification. If you still ` +
             `prefer Terser, set build.minify to "terser".`));
     }
+    // Check if all assetFileNames have the same reference.
+    // If not, display a warn for user.
+    const outputOption = config.build?.rollupOptions?.output ?? [];
+    // Use isArray to narrow its type to array
+    if (Array.isArray(outputOption)) {
+        const assetFileNamesList = outputOption.map((output) => output.assetFileNames);
+        if (assetFileNamesList.length > 1) {
+            const firstAssetFileNames = assetFileNamesList[0];
+            const hasDifferentReference = assetFileNamesList.some((assetFileNames) => assetFileNames !== firstAssetFileNames);
+            if (hasDifferentReference) {
+                resolved.logger.warn(colors$1.yellow(`
+assetFileNames isn't equal for every build.rollupOptions.output. A single pattern across all outputs is supported by Vite.
+`));
+            }
+        }
+    }
     return resolved;
 }
 /**
- * Resolve base. Note that some users use Vite to build for non-web targets like
+ * Resolve base url. Note that some users use Vite to build for non-web targets like
  * electron or expects to deploy
  */
-function resolveBaseUrl(base = '/', isBuild, logger) {
-    // #1669 special treatment for empty for same dir relative base
-    if (base === '' || base === './') {
-        return isBuild ? base : '/';
-    }
+function resolveBaseUrl(base = '/', isBuild, logger, optionName) {
     if (base.startsWith('.')) {
-        logger.warn(colors$1.yellow(colors$1.bold(`(!) invalid "base" option: ${base}. The value can only be an absolute ` +
+        logger.warn(colors$1.yellow(colors$1.bold(`(!) invalid "${optionName}" option: ${base}. The value can only be an absolute ` +
             `URL, ./, or an empty string.`)));
         base = '/';
     }
@@ -61036,13 +61629,13 @@ function resolveBaseUrl(base = '/', isBuild, logger) {
     else {
         // ensure leading slash
         if (!base.startsWith('/')) {
-            logger.warn(colors$1.yellow(colors$1.bold(`(!) "base" option should start with a slash.`)));
+            logger.warn(colors$1.yellow(colors$1.bold(`(!) "${optionName}" option should start with a slash.`)));
             base = '/' + base;
         }
     }
     // ensure ending slash
     if (!base.endsWith('/')) {
-        logger.warn(colors$1.yellow(colors$1.bold(`(!) "base" option should end with a slash.`)));
+        logger.warn(colors$1.yellow(colors$1.bold(`(!) "${optionName}" option should end with a slash.`)));
         base += '/';
     }
     return base;
@@ -61080,7 +61673,7 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
     catch (e) { }
     if (configFile) {
         // explicit config path is always resolved from cwd
-        resolvedPath = path$p.resolve(configFile);
+        resolvedPath = path$q.resolve(configFile);
         isTS = configFile.endsWith('.ts');
         if (configFile.endsWith('.mjs')) {
             isESM = true;
@@ -61089,27 +61682,27 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
     else {
         // implicit config file loaded from inline root (if present)
         // otherwise from cwd
-        const jsconfigFile = path$p.resolve(configRoot, 'vite.config.js');
-        if (fs__default.existsSync(jsconfigFile)) {
+        const jsconfigFile = path$q.resolve(configRoot, 'vite.config.js');
+        if (fs$n.existsSync(jsconfigFile)) {
             resolvedPath = jsconfigFile;
         }
         if (!resolvedPath) {
-            const mjsconfigFile = path$p.resolve(configRoot, 'vite.config.mjs');
-            if (fs__default.existsSync(mjsconfigFile)) {
+            const mjsconfigFile = path$q.resolve(configRoot, 'vite.config.mjs');
+            if (fs$n.existsSync(mjsconfigFile)) {
                 resolvedPath = mjsconfigFile;
                 isESM = true;
             }
         }
         if (!resolvedPath) {
-            const tsconfigFile = path$p.resolve(configRoot, 'vite.config.ts');
-            if (fs__default.existsSync(tsconfigFile)) {
+            const tsconfigFile = path$q.resolve(configRoot, 'vite.config.ts');
+            if (fs$n.existsSync(tsconfigFile)) {
                 resolvedPath = tsconfigFile;
                 isTS = true;
             }
         }
         if (!resolvedPath) {
-            const cjsConfigFile = path$p.resolve(configRoot, 'vite.config.cjs');
-            if (fs__default.existsSync(cjsConfigFile)) {
+            const cjsConfigFile = path$q.resolve(configRoot, 'vite.config.cjs');
+            if (fs$n.existsSync(cjsConfigFile)) {
                 resolvedPath = cjsConfigFile;
                 isESM = false;
             }
@@ -61130,10 +61723,10 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
                 // with --experimental-loader themselves, we have to do a hack here:
                 // bundle the config file w/ ts transforms first, write it to disk,
                 // load it with native Node ESM, then delete the file.
-                fs__default.writeFileSync(resolvedPath + '.js', bundled.code);
+                fs$n.writeFileSync(resolvedPath + '.js', bundled.code);
                 userConfig = (await dynamicImport(`${fileUrl}.js?t=${Date.now()}`))
                     .default;
-                fs__default.unlinkSync(resolvedPath + '.js');
+                fs$n.unlinkSync(resolvedPath + '.js');
                 debug(`TS + native esm config loaded in ${getTime()}`, fileUrl);
             }
             else {
@@ -61189,7 +61782,7 @@ async function bundleConfigFile(fileName, isESM = false) {
                 setup(build) {
                     build.onResolve({ filter: /.*/ }, (args) => {
                         const id = args.path;
-                        if (id[0] !== '.' && !path$p.isAbsolute(id)) {
+                        if (id[0] !== '.' && !path$q.isAbsolute(id)) {
                             return {
                                 external: true
                             };
@@ -61201,8 +61794,8 @@ async function bundleConfigFile(fileName, isESM = false) {
                 name: 'inject-file-scope-variables',
                 setup(build) {
                     build.onLoad({ filter: /\.[jt]s$/ }, async (args) => {
-                        const contents = await fs__default.promises.readFile(args.path, 'utf8');
-                        const injectValues = `const __dirname = ${JSON.stringify(path$p.dirname(args.path))};` +
+                        const contents = await fs$n.promises.readFile(args.path, 'utf8');
+                        const injectValues = `const __dirname = ${JSON.stringify(path$q.dirname(args.path))};` +
                             `const __filename = ${JSON.stringify(args.path)};` +
                             `const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(args.path).href)};`;
                         return {
@@ -61222,7 +61815,7 @@ async function bundleConfigFile(fileName, isESM = false) {
 }
 const _require = createRequire$1(import.meta.url);
 async function loadConfigFromBundledFile(fileName, bundledCode) {
-    const realFileName = fs__default.realpathSync(fileName);
+    const realFileName = fs$n.realpathSync(fileName);
     const defaultLoader = _require.extensions['.js'];
     _require.extensions['.js'] = (module, filename) => {
         if (filename === realFileName) {
@@ -61246,4 +61839,4 @@ function isDepsOptimizerEnabled(config) {
         (command === 'serve' && optimizeDeps.disabled === 'dev'));
 }
 
-export { index$1 as A, build$1 as B, index as C, preview$1 as D, resolvePackageData as a, build as b, createServer as c, defineConfig as d, resolveConfig as e, formatPostcssSourceMap as f, mergeAlias as g, createFilter as h, isDepsOptimizerEnabled as i, send as j, createLogger as k, loadConfigFromFile as l, mergeConfig as m, normalizePath$3 as n, optimizeDeps as o, preview as p, searchForWorkspaceRoot as q, resolvePackageEntry as r, sortUserPlugins as s, transformWithEsbuild as t, loadEnv as u, resolveEnvPrefix as v, colors$1 as w, commonjsGlobal as x, getAugmentedNamespace as y, getDefaultExportFromCjs as z };
+export { getDefaultExportFromCjs as A, index$1 as B, build$1 as C, index as D, preview$1 as E, resolvePackageData as a, build as b, createServer as c, defineConfig as d, resolveConfig as e, formatPostcssSourceMap as f, resolveBaseUrl as g, mergeAlias as h, isDepsOptimizerEnabled as i, createFilter as j, send as k, loadConfigFromFile as l, mergeConfig as m, normalizePath$3 as n, optimizeDeps as o, preview as p, createLogger as q, resolvePackageEntry as r, sortUserPlugins as s, transformWithEsbuild as t, searchForWorkspaceRoot as u, loadEnv as v, resolveEnvPrefix as w, colors$1 as x, commonjsGlobal as y, getAugmentedNamespace as z };