vite 5.0.6 → 5.0.8

package/dist/node/chunks/{dep-Sacttr-6.js → dep-WV5u8Hxr.js}

@@ -1,4 +1,4 @@
-import { z as commonjsGlobal, y as getDefaultExportFromCjs } from './dep-YJaePtkC.js';
+import { z as commonjsGlobal, y as getDefaultExportFromCjs } from './dep-uAHLeuC6.js';
 import require$$0__default from 'fs';
 import require$$0 from 'postcss';
 import require$$0$1 from 'path';

package/dist/node/chunks/{dep-I1uDMLJL.js → dep-Y5q53UKR.js}

@@ -1,4 +1,4 @@
-import { y as getDefaultExportFromCjs } from './dep-YJaePtkC.js';
+import { y as getDefaultExportFromCjs } from './dep-uAHLeuC6.js';
 import require$$0 from 'path';
 import require$$0__default from 'fs';
 import { l as lib } from './dep-8a-6Quh6.js';

package/dist/node/chunks/{dep-YJaePtkC.js → dep-uAHLeuC6.js}

@@ -7709,7 +7709,7 @@ function getPackageEntryPoint(dirPath) {
   return entryPoint;
 }
 
-function isDirectory(path) {
+function isDirectory$1(path) {
   try {
     if (statSync$1(path).isDirectory()) return true;
   } catch (ignored) {
@@ -7730,7 +7730,7 @@ function getDynamicRequireModules(patterns, dynamicRequireRoot) {
     for (const path of glob$1.sync(isNegated ? pattern.substr(1) : pattern)) {
       const resolvedPath = resolve$3(path);
       const requirePath = normalizePathSlashes(resolvedPath);
-      if (isDirectory(resolvedPath)) {
+      if (isDirectory$1(resolvedPath)) {
         dirNames.add(resolvedPath);
         const modulePath = resolve$3(join$1(resolvedPath, getPackageEntryPoint(path)));
         modifyMap(requirePath, modulePath);
@@ -12419,6 +12419,7 @@ function copyDir(srcDir, destDir) {
         }
     }
 }
+const ERR_SYMLINK_IN_RECURSIVE_READDIR = 'ERR_SYMLINK_IN_RECURSIVE_READDIR';
 async function recursiveReaddir(dir) {
     if (!fs$l.existsSync(dir)) {
         return [];
@@ -12434,6 +12435,11 @@ async function recursiveReaddir(dir) {
         }
         throw e;
     }
+    if (dirents.some((dirent) => dirent.isSymbolicLink())) {
+        const err = new Error('Symbolic links are not supported in recursiveReaddir');
+        err.code = ERR_SYMLINK_IN_RECURSIVE_READDIR;
+        throw err;
+    }
     const files = await Promise.all(dirents.map((dirent) => {
         const res = path$o.resolve(dir, dirent.name);
         return dirent.isDirectory() ? recursiveReaddir(res) : normalizePath$3(res);
@@ -16424,7 +16430,16 @@ function lookup(extn) {
 
 const publicFilesMap = new WeakMap();
 async function initPublicFiles(config) {
-    const fileNames = await recursiveReaddir(config.publicDir);
+    let fileNames;
+    try {
+        fileNames = await recursiveReaddir(config.publicDir);
+    }
+    catch (e) {
+        if (e.code === ERR_SYMLINK_IN_RECURSIVE_READDIR) {
+            return;
+        }
+        throw e;
+    }
     const publicFiles = new Set(fileNames.map((fileName) => fileName.slice(config.publicDir.length)));
     publicFilesMap.set(config, publicFiles);
     return publicFiles;
@@ -16662,7 +16677,7 @@ function isGitLfsPlaceholder(content) {
  * Register an asset to be emitted as part of the bundle (if necessary)
  * and returns the resolved public URL
  */
-async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false) {
+async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false, shouldInline) {
     if (!skipPublicCheck && checkPublicFile(id, config)) {
         return publicFileToBuiltUrl(id, config);
     }
@@ -16673,13 +16688,17 @@ async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false
     }
     const file = cleanUrl(id);
     const content = await fsp.readFile(file);
+    if (shouldInline == null) {
+        shouldInline =
+            !!config.build.lib ||
+                // Don't inline SVG with fragments, as they are meant to be reused
+                (!(file.endsWith('.svg') && id.includes('#')) &&
+                    !file.endsWith('.html') &&
+                    content.length < Number(config.build.assetsInlineLimit) &&
+                    !isGitLfsPlaceholder(content));
+    }
     let url;
-    if (config.build.lib ||
-        // Don't inline SVG with fragments, as they are meant to be reused
-        (!(file.endsWith('.svg') && id.includes('#')) &&
-            !file.endsWith('.html') &&
-            content.length < Number(config.build.assetsInlineLimit) &&
-            !isGitLfsPlaceholder(content))) {
+    if (shouldInline) {
         if (config.build.lib && isGitLfsPlaceholder(content)) {
             config.logger.warn(colors$1.yellow(`Inlined file ${id} was not downloaded via Git LFS`));
         }
@@ -16709,7 +16728,7 @@ async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false
     cache.set(id, url);
     return url;
 }
-async function urlToBuiltUrl(url, importer, config, pluginContext) {
+async function urlToBuiltUrl(url, importer, config, pluginContext, shouldInline) {
     if (checkPublicFile(url, config)) {
         return publicFileToBuiltUrl(url, config);
     }
@@ -16718,7 +16737,7 @@ async function urlToBuiltUrl(url, importer, config, pluginContext) {
         : path$o.join(path$o.dirname(importer), url);
     return fileToBuiltUrl(file, config, pluginContext, 
     // skip public check since we just did it above
-    true);
+    true, shouldInline);
 }
 // Inspired by https://github.com/iconify/iconify/blob/main/packages/utils/src/svg/url.ts
 function svgToDataURL(content) {
@@ -28461,6 +28480,324 @@ function hasESMSyntax(code) {
   return ESM_RE.test(code);
 }
 
+// An implementation of fsUtils without caching
+const commonFsUtils = {
+    existsSync: fs$l.existsSync,
+    isDirectory,
+    tryResolveRealFile,
+    tryResolveRealFileWithExtensions,
+    tryResolveRealFileOrType,
+};
+const cachedFsUtilsMap = new WeakMap();
+function getFsUtils(config) {
+    let fsUtils = cachedFsUtilsMap.get(config);
+    if (!fsUtils) {
+        if (config.command !== 'serve' || !config.server.fs.cachedChecks) {
+            // cached fsUtils is only used in the dev server for now, and only when the watcher isn't configured
+            // we can support custom ignored patterns later
+            fsUtils = commonFsUtils;
+        } /* TODO: Enabling for testing, we need to review if this guard is needed
+        else if (config.server.watch === null || config.server.watch?.ignored) {
+          config.logger.warn(
+            colors.yellow(
+              `${colors.bold(
+                `(!)`,
+              )} server.fs.cachedChecks isn't supported if server.watch is null or a custom server.watch.ignored is configured\n`,
+            ),
+          )
+          fsUtils = commonFsUtils
+        } */
+        else if (!config.resolve.preserveSymlinks &&
+            config.root !== getRealPath(config.root)) {
+            config.logger.warn(colors$1.yellow(`${colors$1.bold(`(!)`)} server.fs.cachedChecks isn't supported when resolve.preserveSymlinks is false and root is symlinked\n`));
+            fsUtils = commonFsUtils;
+        }
+        else {
+            fsUtils = createCachedFsUtils(config);
+        }
+        cachedFsUtilsMap.set(config, fsUtils);
+    }
+    return fsUtils;
+}
+function readDirCacheSync(file) {
+    let dirents;
+    try {
+        dirents = fs$l.readdirSync(file, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    return direntsToDirentMap(dirents);
+}
+function direntsToDirentMap(fsDirents) {
+    const dirents = new Map();
+    for (const dirent of fsDirents) {
+        // We ignore non directory, file, and symlink entries
+        const type = dirent.isDirectory()
+            ? 'directory'
+            : dirent.isSymbolicLink()
+                ? 'symlink'
+                : dirent.isFile()
+                    ? 'file'
+                    : undefined;
+        if (type) {
+            dirents.set(dirent.name, { type });
+        }
+    }
+    return dirents;
+}
+function ensureFileMaybeSymlinkIsResolved(direntCache, filePath) {
+    if (direntCache.type !== 'file_maybe_symlink')
+        return;
+    const isSymlink = fs$l
+        .lstatSync(filePath, { throwIfNoEntry: false })
+        ?.isSymbolicLink();
+    direntCache.type =
+        isSymlink === undefined ? 'error' : isSymlink ? 'symlink' : 'file';
+}
+function pathUntilPart(root, parts, i) {
+    let p = root;
+    for (let k = 0; k < i; k++)
+        p += '/' + parts[k];
+    return p;
+}
+function createCachedFsUtils(config) {
+    const root = config.root; // root is resolved and normalized, so it doesn't have a trailing slash
+    const rootDirPath = `${root}/`;
+    const rootCache = { type: 'directory' }; // dirents will be computed lazily
+    const getDirentCacheSync = (parts) => {
+        let direntCache = rootCache;
+        for (let i = 0; i < parts.length; i++) {
+            if (direntCache.type === 'directory') {
+                let dirPath;
+                if (!direntCache.dirents) {
+                    dirPath = pathUntilPart(root, parts, i);
+                    const dirents = readDirCacheSync(dirPath);
+                    if (!dirents) {
+                        direntCache.type = 'error';
+                        return;
+                    }
+                    direntCache.dirents = dirents;
+                }
+                const nextDirentCache = direntCache.dirents.get(parts[i]);
+                if (!nextDirentCache) {
+                    return;
+                }
+                if (nextDirentCache.type === 'directory_maybe_symlink') {
+                    dirPath ??= pathUntilPart(root, parts, i);
+                    const isSymlink = fs$l
+                        .lstatSync(dirPath, { throwIfNoEntry: false })
+                        ?.isSymbolicLink();
+                    direntCache.type = isSymlink ? 'symlink' : 'directory';
+                }
+                direntCache = nextDirentCache;
+            }
+            else if (direntCache.type === 'symlink') {
+                // early return if we encounter a symlink
+                return direntCache;
+            }
+            else if (direntCache.type === 'error') {
+                return direntCache;
+            }
+            else {
+                if (i !== parts.length - 1) {
+                    return;
+                }
+                if (direntCache.type === 'file_maybe_symlink') {
+                    ensureFileMaybeSymlinkIsResolved(direntCache, pathUntilPart(root, parts, i));
+                    return direntCache;
+                }
+                else if (direntCache.type === 'file') {
+                    return direntCache;
+                }
+                else {
+                    return;
+                }
+            }
+        }
+        return direntCache;
+    };
+    function getDirentCacheFromPath(normalizedFile) {
+        if (normalizedFile === root) {
+            return rootCache;
+        }
+        if (!normalizedFile.startsWith(rootDirPath)) {
+            return undefined;
+        }
+        const pathFromRoot = normalizedFile.slice(rootDirPath.length);
+        const parts = pathFromRoot.split('/');
+        const direntCache = getDirentCacheSync(parts);
+        if (!direntCache || direntCache.type === 'error') {
+            return false;
+        }
+        return direntCache;
+    }
+    function onPathAdd(file, type) {
+        const direntCache = getDirentCacheFromPath(path$o.dirname(file));
+        if (direntCache &&
+            direntCache.type === 'directory' &&
+            direntCache.dirents) {
+            direntCache.dirents.set(path$o.basename(file), { type });
+        }
+    }
+    function onPathUnlink(file) {
+        const direntCache = getDirentCacheFromPath(path$o.dirname(file));
+        if (direntCache &&
+            direntCache.type === 'directory' &&
+            direntCache.dirents) {
+            direntCache.dirents.delete(path$o.basename(file));
+        }
+    }
+    return {
+        existsSync(file) {
+            if (isInNodeModules$1(file)) {
+                return fs$l.existsSync(file);
+            }
+            const normalizedFile = normalizePath$3(file);
+            const direntCache = getDirentCacheFromPath(normalizedFile);
+            if (direntCache === undefined ||
+                (direntCache && direntCache.type === 'symlink')) {
+                // fallback to built-in fs for out-of-root and symlinked files
+                return fs$l.existsSync(file);
+            }
+            return !!direntCache;
+        },
+        tryResolveRealFile(file, preserveSymlinks) {
+            if (isInNodeModules$1(file)) {
+                return tryResolveRealFile(file, preserveSymlinks);
+            }
+            const normalizedFile = normalizePath$3(file);
+            const direntCache = getDirentCacheFromPath(normalizedFile);
+            if (direntCache === undefined ||
+                (direntCache && direntCache.type === 'symlink')) {
+                // fallback to built-in fs for out-of-root and symlinked files
+                return tryResolveRealFile(file, preserveSymlinks);
+            }
+            if (!direntCache || direntCache.type === 'directory') {
+                return;
+            }
+            // We can avoid getRealPath even if preserveSymlinks is false because we know it's
+            // a file without symlinks in its path
+            return normalizedFile;
+        },
+        tryResolveRealFileWithExtensions(file, extensions, preserveSymlinks) {
+            if (isInNodeModules$1(file)) {
+                return tryResolveRealFileWithExtensions(file, extensions, preserveSymlinks);
+            }
+            const normalizedFile = normalizePath$3(file);
+            const dirPath = path$o.posix.dirname(normalizedFile);
+            const direntCache = getDirentCacheFromPath(dirPath);
+            if (direntCache === undefined ||
+                (direntCache && direntCache.type === 'symlink')) {
+                // fallback to built-in fs for out-of-root and symlinked files
+                return tryResolveRealFileWithExtensions(file, extensions, preserveSymlinks);
+            }
+            if (!direntCache || direntCache.type !== 'directory') {
+                return;
+            }
+            if (!direntCache.dirents) {
+                const dirents = readDirCacheSync(dirPath);
+                if (!dirents) {
+                    direntCache.type = 'error';
+                    return;
+                }
+                direntCache.dirents = dirents;
+            }
+            const base = path$o.posix.basename(normalizedFile);
+            for (const ext of extensions) {
+                const fileName = base + ext;
+                const fileDirentCache = direntCache.dirents.get(fileName);
+                if (fileDirentCache) {
+                    const filePath = dirPath + '/' + fileName;
+                    ensureFileMaybeSymlinkIsResolved(fileDirentCache, filePath);
+                    if (fileDirentCache.type === 'symlink') {
+                        // fallback to built-in fs for symlinked files
+                        return tryResolveRealFile(filePath, preserveSymlinks);
+                    }
+                    if (fileDirentCache.type === 'file') {
+                        return filePath;
+                    }
+                }
+            }
+        },
+        tryResolveRealFileOrType(file, preserveSymlinks) {
+            if (isInNodeModules$1(file)) {
+                return tryResolveRealFileOrType(file, preserveSymlinks);
+            }
+            const normalizedFile = normalizePath$3(file);
+            const direntCache = getDirentCacheFromPath(normalizedFile);
+            if (direntCache === undefined ||
+                (direntCache && direntCache.type === 'symlink')) {
+                // fallback to built-in fs for out-of-root and symlinked files
+                return tryResolveRealFileOrType(file, preserveSymlinks);
+            }
+            if (!direntCache) {
+                return;
+            }
+            if (direntCache.type === 'directory') {
+                return { type: 'directory' };
+            }
+            // We can avoid getRealPath even if preserveSymlinks is false because we know it's
+            // a file without symlinks in its path
+            return { path: normalizedFile, type: 'file' };
+        },
+        isDirectory(dirPath) {
+            if (isInNodeModules$1(dirPath)) {
+                return isDirectory(dirPath);
+            }
+            const direntCache = getDirentCacheFromPath(normalizePath$3(dirPath));
+            if (direntCache === undefined ||
+                (direntCache && direntCache.type === 'symlink')) {
+                // fallback to built-in fs for out-of-root and symlinked files
+                return isDirectory(dirPath);
+            }
+            return direntCache && direntCache.type === 'directory';
+        },
+        initWatcher(watcher) {
+            watcher.on('add', (file) => {
+                onPathAdd(file, 'file_maybe_symlink');
+            });
+            watcher.on('addDir', (dir) => {
+                onPathAdd(dir, 'directory_maybe_symlink');
+            });
+            watcher.on('unlink', onPathUnlink);
+            watcher.on('unlinkDir', onPathUnlink);
+        },
+    };
+}
+function tryResolveRealFile(file, preserveSymlinks) {
+    const stat = tryStatSync(file);
+    if (stat?.isFile())
+        return getRealPath(file, preserveSymlinks);
+}
+function tryResolveRealFileWithExtensions(filePath, extensions, preserveSymlinks) {
+    for (const ext of extensions) {
+        const res = tryResolveRealFile(filePath + ext, preserveSymlinks);
+        if (res)
+            return res;
+    }
+}
+function tryResolveRealFileOrType(file, preserveSymlinks) {
+    const fileStat = tryStatSync(file);
+    if (fileStat?.isFile()) {
+        return { path: getRealPath(file, preserveSymlinks), type: 'file' };
+    }
+    if (fileStat?.isDirectory()) {
+        return { type: 'directory' };
+    }
+    return;
+}
+function getRealPath(resolved, preserveSymlinks) {
+    if (!preserveSymlinks) {
+        resolved = safeRealpathSync(resolved);
+    }
+    return normalizePath$3(resolved);
+}
+function isDirectory(path) {
+    const stat = tryStatSync(path);
+    return stat?.isDirectory() ?? false;
+}
+
 const normalizedClientEntry$1 = normalizePath$3(CLIENT_ENTRY);
 const normalizedEnvEntry$1 = normalizePath$3(ENV_ENTRY);
 const ERR_RESOLVE_PACKAGE_ENTRY_FAIL = 'ERR_RESOLVE_PACKAGE_ENTRY_FAIL';
@@ -28767,46 +29104,46 @@ const knownTsOutputRE = /\.(?:js|mjs|cjs|jsx)$/;
 const isPossibleTsOutput = (url) => knownTsOutputRE.test(url);
 function tryCleanFsResolve(file, options, tryIndex = true, targetWeb = true, skipPackageJson = false) {
     const { tryPrefix, extensions, preserveSymlinks } = options;
-    const fileStat = tryStatSync(file);
-    // Try direct match first
-    if (fileStat?.isFile())
-        return getRealPath(file, options.preserveSymlinks);
+    const fsUtils = options.fsUtils ?? commonFsUtils;
+    // Optimization to get the real type or file type (directory, file, other)
+    const fileResult = fsUtils.tryResolveRealFileOrType(file, options.preserveSymlinks);
+    if (fileResult?.path)
+        return fileResult.path;
     let res;
     // If path.dirname is a valid directory, try extensions and ts resolution logic
     const possibleJsToTs = options.isFromTsImporter && isPossibleTsOutput(file);
-    if (possibleJsToTs || extensions.length || tryPrefix) {
+    if (possibleJsToTs || options.extensions.length || tryPrefix) {
         const dirPath = path$o.dirname(file);
-        const dirStat = tryStatSync(dirPath);
-        if (dirStat?.isDirectory()) {
+        if (fsUtils.isDirectory(dirPath)) {
             if (possibleJsToTs) {
                 // try resolve .js, .mjs, .cjs or .jsx import to typescript file
                 const fileExt = path$o.extname(file);
                 const fileName = file.slice(0, -fileExt.length);
-                if ((res = tryResolveRealFile(fileName + fileExt.replace('js', 'ts'), preserveSymlinks)))
+                if ((res = fsUtils.tryResolveRealFile(fileName + fileExt.replace('js', 'ts'), preserveSymlinks)))
                     return res;
                 // for .js, also try .tsx
                 if (fileExt === '.js' &&
-                    (res = tryResolveRealFile(fileName + '.tsx', preserveSymlinks)))
+                    (res = fsUtils.tryResolveRealFile(fileName + '.tsx', preserveSymlinks)))
                     return res;
             }
-            if ((res = tryResolveRealFileWithExtensions(file, extensions, preserveSymlinks)))
+            if ((res = fsUtils.tryResolveRealFileWithExtensions(file, extensions, preserveSymlinks)))
                 return res;
             if (tryPrefix) {
                 const prefixed = `${dirPath}/${options.tryPrefix}${path$o.basename(file)}`;
-                if ((res = tryResolveRealFile(prefixed, preserveSymlinks)))
+                if ((res = fsUtils.tryResolveRealFile(prefixed, preserveSymlinks)))
                     return res;
-                if ((res = tryResolveRealFileWithExtensions(prefixed, extensions, preserveSymlinks)))
+                if ((res = fsUtils.tryResolveRealFileWithExtensions(prefixed, extensions, preserveSymlinks)))
                     return res;
             }
         }
     }
-    if (tryIndex && fileStat) {
+    if (tryIndex && fileResult?.type === 'directory') {
         // Path points to a directory, check for package.json and entry and /index file
         const dirPath = file;
         if (!skipPackageJson) {
             let pkgPath = `${dirPath}/package.json`;
             try {
-                if (fs$l.existsSync(pkgPath)) {
+                if (fsUtils.existsSync(pkgPath)) {
                     if (!options.preserveSymlinks) {
                         pkgPath = safeRealpathSync(pkgPath);
                     }
@@ -28821,26 +29158,14 @@ function tryCleanFsResolve(file, options, tryIndex = true, targetWeb = true, ski
                     throw e;
             }
         }
-        if ((res = tryResolveRealFileWithExtensions(`${dirPath}/index`, extensions, preserveSymlinks)))
+        if ((res = fsUtils.tryResolveRealFileWithExtensions(`${dirPath}/index`, extensions, preserveSymlinks)))
             return res;
         if (tryPrefix) {
-            if ((res = tryResolveRealFileWithExtensions(`${dirPath}/${options.tryPrefix}index`, extensions, preserveSymlinks)))
+            if ((res = fsUtils.tryResolveRealFileWithExtensions(`${dirPath}/${options.tryPrefix}index`, extensions, preserveSymlinks)))
                 return res;
         }
     }
 }
-function tryResolveRealFile(file, preserveSymlinks) {
-    const stat = tryStatSync(file);
-    if (stat?.isFile())
-        return getRealPath(file, preserveSymlinks);
-}
-function tryResolveRealFileWithExtensions(filePath, extensions, preserveSymlinks) {
-    for (const ext of extensions) {
-        const res = tryResolveRealFile(filePath + ext, preserveSymlinks);
-        if (res)
-            return res;
-    }
-}
 function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = false, externalize, allowLinkedExternal = true) {
     const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
     // check for deep import, e.g. "my-lib/foo"
@@ -29294,12 +29619,6 @@ function mapWithBrowserField(relativePathInPkgDir, map) {
 function equalWithoutSuffix(path, key, suffix) {
     return key.endsWith(suffix) && key.slice(0, -suffix.length) === path;
 }
-function getRealPath(resolved, preserveSymlinks) {
-    if (!preserveSymlinks && browserExternalId !== resolved) {
-        resolved = safeRealpathSync(resolved);
-    }
-    return normalizePath$3(resolved);
-}
 
 var dist = {};
 
@@ -38014,6 +38333,7 @@ const inlineCSSRE$1 = /__VITE_INLINE_CSS__([a-z\d]{8}_\d+)__/g;
 // Do not allow preceding '.', but do allow preceding '...' for spread operations
 const inlineImportRE = /(?<!(?<!\.\.)\.)\bimport\s*\(("(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*')\)/dg;
 const htmlLangRE = /\.(?:html|htm)$/;
+const spaceRe = /[\t\n\f\r ]/;
 const importMapRE = /[ \t]*<script[^>]*type\s*=\s*(?:"importmap"|'importmap'|importmap)[^>]*>.*?<\/script>/is;
 const moduleScriptRE = /[ \t]*<script[^>]*type\s*=\s*(?:"module"|'module'|module)[^>]*>/i;
 const modulePreloadLinkRE = /[ \t]*<link[^>]*rel\s*=\s*(?:"modulepreload"|'modulepreload'|modulepreload)[\s\S]*?\/>/i;
@@ -38076,6 +38396,16 @@ const assetAttrsConfig = {
     image: ['xlink:href', 'href'],
     use: ['xlink:href', 'href'],
 };
+// Some `<link rel>` elements should not be inlined in build. Excluding:
+// - `shortcut`                     : only valid for IE <9, use `icon`
+// - `mask-icon`                    : deprecated since Safari 12 (for pinned tabs)
+// - `apple-touch-icon-precomposed` : only valid for iOS <7 (for avoiding gloss effect)
+const noInlineLinkRels = new Set([
+    'icon',
+    'apple-touch-icon',
+    'apple-touch-startup-image',
+    'manifest',
+]);
 const isAsyncScriptMap = new WeakMap();
 function nodeIsElement(node) {
     return node.nodeName[0] !== '#';
@@ -38237,13 +38567,13 @@ function buildHtmlPlugin(config) {
                 // references the post-build location, ignoring empty attributes and
                 // attributes that directly reference named output.
                 const namedOutput = Object.keys(config?.build?.rollupOptions?.input || {});
-                const processAssetUrl = async (url) => {
+                const processAssetUrl = async (url, shouldInline) => {
                     if (url !== '' && // Empty attribute
                         !namedOutput.includes(url) && // Direct reference to named output
                         !namedOutput.includes(removeLeadingSlash(url)) // Allow for absolute references as named output can't be an absolute path
                     ) {
                         try {
-                            return await urlToBuiltUrl(url, id, config, this);
+                            return await urlToBuiltUrl(url, id, config, this, shouldInline);
                         }
                         catch (e) {
                             if (e.code !== 'ENOENT') {
@@ -38343,8 +38673,16 @@ function buildHtmlPlugin(config) {
                                             js += importExpression;
                                         }
                                         else {
+                                            // If the node is a link, check if it can be inlined. If not, set `shouldInline`
+                                            // to `false` to force no inline. If `undefined`, it leaves to the default heuristics.
+                                            const isNoInlineLink = node.nodeName === 'link' &&
+                                                node.attrs.some((p) => p.name === 'rel' &&
+                                                    p.value
+                                                        .split(spaceRe)
+                                                        .some((v) => noInlineLinkRels.has(v.toLowerCase())));
+                                            const shouldInline = isNoInlineLink ? false : undefined;
                                             assetUrlsPromises.push((async () => {
-                                                const processedUrl = await processAssetUrl(url);
+                                                const processedUrl = await processAssetUrl(url, shouldInline);
                                                 if (processedUrl !== url) {
                                                     overwriteAttrValue(s, getAttrSourceCodeLocation(node, attrKey), processedUrl);
                                                 }
@@ -38987,26 +39325,27 @@ function cssPlugin(config) {
             }
             const ssr = options?.ssr === true;
             const urlReplacer = async (url, importer) => {
-                if (checkPublicFile(url, config)) {
+                const decodedUrl = decodeURI(url);
+                if (checkPublicFile(decodedUrl, config)) {
                     if (encodePublicUrlsInCSS(config)) {
-                        return publicFileToBuiltUrl(url, config);
+                        return publicFileToBuiltUrl(decodedUrl, config);
                     }
                     else {
-                        return joinUrlSegments(config.base, url);
+                        return joinUrlSegments(config.base, decodedUrl);
                     }
                 }
-                const resolved = await resolveUrl(url, importer);
+                const resolved = await resolveUrl(decodedUrl, importer);
                 if (resolved) {
                     return fileToUrl$1(resolved, config, this);
                 }
                 if (config.command === 'build') {
                     const isExternal = config.build.rollupOptions.external
-                        ? resolveUserExternal(config.build.rollupOptions.external, url, // use URL as id since id could not be resolved
+                        ? resolveUserExternal(config.build.rollupOptions.external, decodedUrl, // use URL as id since id could not be resolved
                         id, false)
                         : false;
                     if (!isExternal) {
                         // #9800 If we cannot resolve the css url, leave a warning.
-                        config.logger.warnOnce(`\n${url} referenced in ${id} didn't resolve at build time, it will remain unchanged to be resolved at runtime`);
+                        config.logger.warnOnce(`\n${decodedUrl} referenced in ${id} didn't resolve at build time, it will remain unchanged to be resolved at runtime`);
                     }
                 }
                 return url;
@@ -39737,8 +40076,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-I1uDMLJL.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-Sacttr-6.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-Y5q53UKR.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-WV5u8Hxr.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 /**
  * @experimental
@@ -41125,7 +41464,7 @@ function throwOutdatedRequest(id) {
     throw err;
 }
 
-// AST walker module for Mozilla Parser API compatible trees
+// AST walker module for ESTree compatible trees
 
 
 function makeTest(test) {
@@ -48719,7 +49058,7 @@ function servePublicMiddleware(server, publicFiles) {
         // To avoid the performance impact of `existsSync` on every request, we check against an
         // in-memory set of known public files. This set is updated on restarts.
         // also skip import request and internal requests `/@fs/ /@vite-client` etc...
-        if (!publicFiles.has(toFilePath(req.url)) ||
+        if ((publicFiles && !publicFiles.has(toFilePath(req.url))) ||
             isImportRequest(req.url) ||
             isInternalRequest(req.url)) {
             return next();
@@ -50186,8 +50525,8 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
 // In node@12+ we can use dynamic import to load CJS and ESM
 async function nodeImport(id, importer, resolveOptions, metadata) {
     let url;
-    const isRuntimeHandled = id.startsWith('data:') || isBuiltin(id);
-    if (isRuntimeHandled) {
+    let filePath;
+    if (id.startsWith('data:') || isBuiltin(id)) {
         url = id;
     }
     else {
@@ -50197,18 +50536,19 @@ async function nodeImport(id, importer, resolveOptions, metadata) {
             err.code = 'ERR_MODULE_NOT_FOUND';
             throw err;
         }
+        filePath = resolved.id;
         url = pathToFileURL(resolved.id).toString();
     }
     const mod = await import(url);
     if (resolveOptions.legacyProxySsrExternalModules) {
         return proxyESM(mod);
     }
-    else if (isRuntimeHandled) {
-        return mod;
+    else if (filePath) {
+        analyzeImportedModDifference(mod, filePath, id, metadata, resolveOptions.packageCache);
+        return proxyGuardOnlyEsm(mod, id);
     }
     else {
-        analyzeImportedModDifference(mod, url, id, metadata, resolveOptions.packageCache);
-        return proxyGuardOnlyEsm(mod, id);
+        return mod;
     }
 }
 // rollup-style default import interop for cjs
@@ -52479,6 +52819,9 @@ let Receiver$1 = class Receiver extends Writable$1 {
    * Creates a Receiver instance.
    *
    * @param {Object} [options] Options object
+   * @param {Boolean} [options.allowMultipleEventsPerMicrotask=false] Specifies
+   *     whether or not to process more than one of the `'message'`, `'ping'`,
+   *     and `'pong'` events per microtask
    * @param {String} [options.binaryType=nodebuffer] The type for binary data
    * @param {Object} [options.extensions] An object containing the negotiated
    *     extensions
@@ -52491,6 +52834,8 @@ let Receiver$1 = class Receiver extends Writable$1 {
   constructor(options = {}) {
     super();
 
+    this._allowMultipleEventsPerMicrotask =
+      !!options.allowMultipleEventsPerMicrotask;
     this._binaryType = options.binaryType || BINARY_TYPES$1[0];
     this._extensions = options.extensions || {};
     this._isServer = !!options.isServer;
@@ -53001,7 +53346,9 @@ let Receiver$1 = class Receiver extends Writable$1 {
       }
     }
 
-    this._state = WAIT_MICROTASK;
+    this._state = this._allowMultipleEventsPerMicrotask
+      ? GET_INFO
+      : WAIT_MICROTASK;
   }
 
   /**
@@ -53018,8 +53365,6 @@ let Receiver$1 = class Receiver extends Writable$1 {
       if (data.length === 0) {
         this.emit('conclude', 1005, EMPTY_BUFFER$2);
         this.end();
-
-        this._state = GET_INFO;
       } else {
         const code = data.readUInt16BE(0);
 
@@ -53051,16 +53396,16 @@ let Receiver$1 = class Receiver extends Writable$1 {
 
         this.emit('conclude', code, buf);
         this.end();
-
-        this._state = GET_INFO;
       }
-    } else if (this._opcode === 0x09) {
-      this.emit('ping', data);
-      this._state = WAIT_MICROTASK;
-    } else {
-      this.emit('pong', data);
-      this._state = WAIT_MICROTASK;
+
+      this._state = GET_INFO;
+      return;
     }
+
+    this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
+    this._state = this._allowMultipleEventsPerMicrotask
+      ? GET_INFO
+      : WAIT_MICROTASK;
   }
 };
 
@@ -54276,6 +54621,9 @@ let WebSocket$1 = class WebSocket extends EventEmitter$1 {
    * @param {Duplex} socket The network socket between the server and client
    * @param {Buffer} head The first packet of the upgraded stream
    * @param {Object} options Options object
+   * @param {Boolean} [options.allowMultipleEventsPerMicrotask=false] Specifies
+   *     whether or not to process more than one of the `'message'`, `'ping'`,
+   *     and `'pong'` events per microtask
    * @param {Function} [options.generateMask] The function used to generate the
    *     masking key
    * @param {Number} [options.maxPayload=0] The maximum allowed message size
@@ -54285,6 +54633,7 @@ let WebSocket$1 = class WebSocket extends EventEmitter$1 {
    */
   setSocket(socket, head, options) {
     const receiver = new Receiver({
+      allowMultipleEventsPerMicrotask: options.allowMultipleEventsPerMicrotask,
       binaryType: this.binaryType,
       extensions: this._extensions,
       isServer: this._isServer,
@@ -54702,6 +55051,11 @@ var websocket = WebSocket$1;
  * @param {(String|URL)} address The URL to which to connect
  * @param {Array} protocols The subprotocols
  * @param {Object} [options] Connection options
+ * @param {Boolean} [options.allowMultipleEventsPerMicrotask=false] Specifies
+ *     whether or not to process more than one of the `'message'`, `'ping'`,
+ *     and `'pong'` events per microtask
+ * @param {Function} [options.finishRequest] A function which can be used to
+ *     customize the headers of each http request before it is sent
  * @param {Boolean} [options.followRedirects=false] Whether or not to follow
  *     redirects
  * @param {Function} [options.generateMask] The function used to generate the
@@ -54724,6 +55078,7 @@ var websocket = WebSocket$1;
  */
 function initAsClient(websocket, address, protocols, options) {
   const opts = {
+    allowMultipleEventsPerMicrotask: false,
     protocolVersion: protocolVersions[1],
     maxPayload: 100 * 1024 * 1024,
     skipUTF8Validation: false,
@@ -54890,8 +55245,8 @@ function initAsClient(websocket, address, protocols, options) {
           ? opts.socketPath === websocket._originalHostOrSocketPath
           : false
         : websocket._originalIpc
-        ? false
-        : parsedUrl.host === websocket._originalHostOrSocketPath;
+          ? false
+          : parsedUrl.host === websocket._originalHostOrSocketPath;
 
       if (!isSameHost || (websocket._originalSecure && !isSecure)) {
         //
@@ -55075,6 +55430,7 @@ function initAsClient(websocket, address, protocols, options) {
     }
 
     websocket.setSocket(socket, head, {
+      allowMultipleEventsPerMicrotask: opts.allowMultipleEventsPerMicrotask,
       generateMask: opts.generateMask,
       maxPayload: opts.maxPayload,
       skipUTF8Validation: opts.skipUTF8Validation
@@ -55491,6 +55847,9 @@ class WebSocketServer extends EventEmitter {
    * Create a `WebSocketServer` instance.
    *
    * @param {Object} options Configuration options
+   * @param {Boolean} [options.allowMultipleEventsPerMicrotask=false] Specifies
+   *     whether or not to process more than one of the `'message'`, `'ping'`,
+   *     and `'pong'` events per microtask
    * @param {Number} [options.backlog=511] The maximum length of the queue of
    *     pending connections
    * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
@@ -55517,6 +55876,7 @@ class WebSocketServer extends EventEmitter {
     super();
 
     options = {
+      allowMultipleEventsPerMicrotask: false,
       maxPayload: 100 * 1024 * 1024,
       skipUTF8Validation: false,
       perMessageDeflate: false,
@@ -55871,6 +56231,8 @@ class WebSocketServer extends EventEmitter {
     socket.removeListener('error', socketOnError);
 
     ws.setSocket(socket, head, {
+      allowMultipleEventsPerMicrotask:
+        this.options.allowMultipleEventsPerMicrotask,
       maxPayload: this.options.maxPayload,
       skipUTF8Validation: this.options.skipUTF8Validation
     });
@@ -58410,7 +58772,7 @@ function doesProxyContextMatchUrl(context, url) {
 }
 
 const debug$6 = createDebugger('vite:html-fallback');
-function htmlFallbackMiddleware(root, spaFallback) {
+function htmlFallbackMiddleware(root, spaFallback, fsUtils = commonFsUtils) {
     // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
     return function viteHtmlFallbackMiddleware(req, res, next) {
         if (
@@ -58429,7 +58791,7 @@ function htmlFallbackMiddleware(root, spaFallback) {
         // so we need to check if the file exists
         if (pathname.endsWith('.html')) {
             const filePath = path$o.join(root, pathname);
-            if (fs$l.existsSync(filePath)) {
+            if (fsUtils.existsSync(filePath)) {
                 debug$6?.(`Rewriting ${req.method} ${req.url} to ${url}`);
                 req.url = url;
                 return next();
@@ -58438,7 +58800,7 @@ function htmlFallbackMiddleware(root, spaFallback) {
         // trailing slash should check for fallback index.html
         else if (pathname[pathname.length - 1] === '/') {
             const filePath = path$o.join(root, pathname, 'index.html');
-            if (fs$l.existsSync(filePath)) {
+            if (fsUtils.existsSync(filePath)) {
                 const newUrl = url + 'index.html';
                 debug$6?.(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
                 req.url = newUrl;
@@ -58448,7 +58810,7 @@ function htmlFallbackMiddleware(root, spaFallback) {
         // non-trailing slash should check for fallback .html
         else {
             const filePath = path$o.join(root, pathname + '.html');
-            if (fs$l.existsSync(filePath)) {
+            if (fsUtils.existsSync(filePath)) {
                 const newUrl = url + '.html';
                 debug$6?.(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
                 req.url = newUrl;
@@ -58740,6 +59102,9 @@ function shouldPreTransform(url, config) {
     return (!checkPublicFile(url, config) && (isJSRequest(url) || isCSSRequest(url)));
 }
 const wordCharRE = /\w/;
+function isBareRelative(url) {
+    return wordCharRE.test(url[0]) && !url.includes(':');
+}
 const isSrcSet = (attr) => attr.name === 'srcset' && attr.prefix === undefined;
 const processNodeUrl = (url, useSrcSetReplacer, config, htmlPath, originalUrl, server) => {
     // prefix with base (dev only, base is never relative)
@@ -58759,20 +59124,25 @@ const processNodeUrl = (url, useSrcSetReplacer, config, htmlPath, originalUrl, s
             // rewrite `./index.js` -> `localhost:5173/a/index.js`.
             // rewrite `../index.js` -> `localhost:5173/index.js`.
             // rewrite `relative/index.js` -> `localhost:5173/a/relative/index.js`.
-            ((url[0] === '.' || (wordCharRE.test(url[0]) && !url.includes(':'))) &&
+            ((url[0] === '.' || isBareRelative(url)) &&
                 originalUrl &&
                 originalUrl !== '/' &&
                 htmlPath === '/index.html')) {
-            const devBase = config.base;
-            const fullUrl = path$o.posix.join(devBase, url);
-            if (server && shouldPreTransform(url, config)) {
-                preTransformRequest(server, fullUrl, devBase);
-            }
-            return fullUrl;
+            url = path$o.posix.join(config.base, url);
         }
-        else {
-            return url;
+        if (server && shouldPreTransform(url, config)) {
+            let preTransformUrl;
+            if (url[0] === '/') {
+                preTransformUrl = url;
+            }
+            else if (url[0] === '.' || isBareRelative(url)) {
+                preTransformUrl = path$o.posix.join(config.base, path$o.posix.dirname(htmlPath), url);
+            }
+            if (preTransformUrl) {
+                preTransformRequest(server, preTransformUrl, config.base);
+            }
         }
+        return url;
     };
     const processedUrl = useSrcSetReplacer
         ? processSrcSetSync(url, ({ url }) => replacer(url))
@@ -58785,7 +59155,7 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
     let proxyModulePath;
     let proxyModuleUrl;
     const trailingSlash = htmlPath.endsWith('/');
-    if (!trailingSlash && fs$l.existsSync(filename)) {
+    if (!trailingSlash && getFsUtils(config).existsSync(filename)) {
         proxyModulePath = htmlPath;
         proxyModuleUrl = joinUrlSegments(base, htmlPath);
     }
@@ -58936,6 +59306,7 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
 };
 function indexHtmlMiddleware(root, server) {
     const isDev = isDevServer(server);
+    const fsUtils = getFsUtils(server.config);
     // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
     return async function viteIndexHtmlMiddleware(req, res, next) {
         if (res.writableEnded) {
@@ -58951,7 +59322,7 @@ function indexHtmlMiddleware(root, server) {
             else {
                 filePath = path$o.join(root, decodeURIComponent(url));
             }
-            if (fs$l.existsSync(filePath)) {
+            if (fsUtils.existsSync(filePath)) {
                 const headers = isDev
                     ? server.config.server.headers
                     : server.config.preview.headers;
@@ -59807,11 +60178,14 @@ async function _createServer(inlineConfig = {}, options) {
             }
         }
     };
+    const normalizedPublicDir = normalizePath$3(config.publicDir);
     const onFileAddUnlink = async (file, isUnlink) => {
         file = normalizePath$3(file);
         await container.watchChange(file, { event: isUnlink ? 'delete' : 'create' });
-        if (config.publicDir && file.startsWith(config.publicDir)) {
-            publicFiles[isUnlink ? 'delete' : 'add'](file.slice(config.publicDir.length));
+        if (config.publicDir && publicFiles) {
+            if (file.startsWith(normalizedPublicDir)) {
+                publicFiles[isUnlink ? 'delete' : 'add'](file.slice(normalizedPublicDir.length));
+            }
         }
         await handleFileAddUnlink(file, server, isUnlink);
         await onHMRUpdate(file, true);
@@ -59823,8 +60197,13 @@ async function _createServer(inlineConfig = {}, options) {
         moduleGraph.onFileChange(file);
         await onHMRUpdate(file, false);
     });
-    watcher.on('add', (file) => onFileAddUnlink(file, false));
-    watcher.on('unlink', (file) => onFileAddUnlink(file, true));
+    getFsUtils(config).initWatcher?.(watcher);
+    watcher.on('add', (file) => {
+        onFileAddUnlink(file, false);
+    });
+    watcher.on('unlink', (file) => {
+        onFileAddUnlink(file, true);
+    });
     ws.on('vite:invalidate', async ({ path, message }) => {
         const mod = moduleGraph.urlToModuleMap.get(path);
         if (mod && mod.isSelfAccepting && mod.lastHMRTimestamp > 0) {
@@ -59893,7 +60272,7 @@ async function _createServer(inlineConfig = {}, options) {
     middlewares.use(serveStaticMiddleware(server));
     // html fallback
     if (config.appType === 'spa' || config.appType === 'mpa') {
-        middlewares.use(htmlFallbackMiddleware(root, config.appType === 'spa'));
+        middlewares.use(htmlFallbackMiddleware(root, config.appType === 'spa', getFsUtils(config)));
     }
     // run post config hooks
     // This is applied before the html middleware so that user middleware can
@@ -60035,6 +60414,7 @@ function resolveServerOptions(root, raw, logger) {
         strict: server.fs?.strict ?? true,
         allow: allowDirs,
         deny,
+        cachedChecks: server.fs?.cachedChecks ?? !!process.env.VITE_SERVER_FS_CACHED_CHECKS,
     };
     if (server.origin?.endsWith('/')) {
         server.origin = server.origin.slice(0, -1);
@@ -61166,6 +61546,7 @@ function extractImportedBindings(id, source, importSpec, importedBindings) {
  */
 function importAnalysisPlugin(config) {
     const { root, base } = config;
+    const fsUtils = getFsUtils(config);
     const clientPublicPath = path$o.posix.join(base, CLIENT_PUBLIC_PATH);
     const enablePartialAccept = config.experimental?.hmrPartialAccept;
     let server;
@@ -61294,7 +61675,7 @@ function importAnalysisPlugin(config) {
                 }
                 else if (depsOptimizer?.isOptimizedDepFile(resolved.id) ||
                     (path$o.isAbsolute(cleanUrl(resolved.id)) &&
-                        fs$l.existsSync(cleanUrl(resolved.id)))) {
+                        fsUtils.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$o.posix.join(FS_PREFIX, resolved.id);
@@ -61948,6 +62329,7 @@ function preAliasPlugin(config) {
     const findPatterns = getAliasPatterns(config.resolve.alias);
     const isConfiguredAsExternal = createIsConfiguredAsSsrExternal(config);
     const isBuild = config.command === 'build';
+    const fsUtils = getFsUtils(config);
     return {
         name: 'vite:pre-alias',
         async resolveId(id, importer, options) {
@@ -61976,7 +62358,7 @@ function preAliasPlugin(config) {
                         const resolvedId = cleanUrl(resolved.id);
                         const isVirtual = resolvedId === id || resolvedId.includes('\0');
                         if (!isVirtual &&
-                            fs$l.existsSync(resolvedId) &&
+                            fsUtils.existsSync(resolvedId) &&
                             !moduleListContains(optimizeDeps.exclude, id) &&
                             path$o.isAbsolute(resolvedId) &&
                             (isInNodeModules$1(resolvedId) ||
@@ -62674,6 +63056,7 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
             packageCache: config.packageCache,
             ssrConfig: config.ssr,
             asSrc: true,
+            fsUtils: getFsUtils(config),
             getDepsOptimizer: (ssr) => getDepsOptimizer(config, ssr),
             shouldExternalize: isBuild && config.build.ssr
                 ? (id, importer) => shouldExternalizeForSSR(id, importer, config)
@@ -64210,7 +64593,7 @@ async function createDepsOptimizer(config, server) {
         // Ensure that a rerun will not be issued for current discovered deps
         if (debounceProcessingHandle)
             clearTimeout(debounceProcessingHandle);
-        if (closed || Object.keys(metadata.discovered).length === 0) {
+        if (closed) {
             currentlyProcessing = false;
             return;
         }
@@ -64411,9 +64794,6 @@ async function createDepsOptimizer(config, server) {
         });
     }
     function debouncedProcessing(timeout = debounceMs) {
-        if (!newDepsDiscovered) {
-            return;
-        }
         // Debounced rerun, let other missing dependencies be discovered before
         // the running next optimizeDeps
         enqueuedRerun = undefined;
@@ -64455,8 +64835,10 @@ async function createDepsOptimizer(config, server) {
             const scanDeps = Object.keys(result.metadata.optimized);
             if (scanDeps.length === 0 && crawlDeps.length === 0) {
                 debug$2?.(colors$1.green(`✨ no dependencies found by the scanner or crawling static imports`));
-                result.cancel();
-                firstRunCalled = true;
+                // We still commit the result so the scanner isn't run on the next cold start
+                // for projects without dependencies
+                startNextDiscoveredBatch();
+                runOptimizer(result);
                 return;
             }
             const needsInteropMismatch = findInteropMismatches(metadata.discovered, result.metadata.optimized);
@@ -64490,10 +64872,8 @@ async function createDepsOptimizer(config, server) {
                 debug$2?.(colors$1.green(`✨ no dependencies found while crawling the static imports`));
                 firstRunCalled = true;
             }
-            else {
-                // queue the first optimizer run
-                debouncedProcessing(0);
-            }
+            // queue the first optimizer run, even without deps so the result is cached
+            debouncedProcessing(0);
         }
     }
     // Called during buildStart at build time, when build --watch is used.
@@ -67200,6 +67580,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
                                     tryIndex: true,
                                     ...options,
                                     idOnly: true,
+                                    fsUtils: getFsUtils(resolved),
                                 }),
                             ],
                         }));
@@ -67337,7 +67718,9 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         },
     });
     // validate config
-    if (config.build?.terserOptions && config.build.minify !== 'terser') {
+    if (config.build?.terserOptions &&
+        config.build.minify &&
+        config.build.minify !== 'terser') {
         logger.warn(colors$1.yellow(`build.terserOptions is specified but build.minify is not set to use Terser. ` +
             `Note Vite now defaults to use esbuild for minification. If you still ` +
             `prefer Terser, set build.minify to "terser".`));

package/dist/node/cli.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { performance } from 'node:perf_hooks';
 import { EventEmitter } from 'events';
-import { x as colors, k as createLogger, r as resolveConfig } from './chunks/dep-YJaePtkC.js';
+import { x as colors, k as createLogger, r as resolveConfig } from './chunks/dep-uAHLeuC6.js';
 import { VERSION } from './constants.js';
 import 'node:fs/promises';
 import 'node:url';
@@ -759,7 +759,7 @@ cli
     filterDuplicateOptions(options);
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await import('./chunks/dep-YJaePtkC.js').then(function (n) { return n.A; });
+    const { createServer } = await import('./chunks/dep-uAHLeuC6.js').then(function (n) { return n.A; });
     try {
         const server = await createServer({
             root,
@@ -839,7 +839,7 @@ cli
     .option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { build } = await import('./chunks/dep-YJaePtkC.js').then(function (n) { return n.C; });
+    const { build } = await import('./chunks/dep-uAHLeuC6.js').then(function (n) { return n.C; });
     const buildOptions = cleanOptions(options);
     try {
         await build({
@@ -867,7 +867,7 @@ cli
     .option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { optimizeDeps } = await import('./chunks/dep-YJaePtkC.js').then(function (n) { return n.B; });
+    const { optimizeDeps } = await import('./chunks/dep-uAHLeuC6.js').then(function (n) { return n.B; });
     try {
         const config = await resolveConfig({
             root,
@@ -893,7 +893,7 @@ cli
     .option('--outDir <dir>', `[string] output directory (default: dist)`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { preview } = await import('./chunks/dep-YJaePtkC.js').then(function (n) { return n.D; });
+    const { preview } = await import('./chunks/dep-uAHLeuC6.js').then(function (n) { return n.D; });
     try {
         const server = await preview({
             root,

package/dist/node/index.d.ts

@@ -1572,6 +1572,13 @@ interface FileSystemServeOptions {
      * @default ['.env', '.env.*', '*.crt', '*.pem']
      */
     deny?: string[];
+    /**
+     * Enable caching of fs calls.
+     *
+     * @experimental
+     * @default false
+     */
+    cachedChecks?: boolean;
 }
 type ServerHook = (this: void, server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>;
 type HttpServer = http.Server | Http2SecureServer;
@@ -2634,6 +2641,18 @@ interface ResolvedSSROptions extends SSROptions {
     optimizeDeps: SsrDepOptimizationOptions;
 }
 
+interface FsUtils {
+    existsSync: (path: string) => boolean;
+    isDirectory: (path: string) => boolean;
+    tryResolveRealFile: (path: string, preserveSymlinks?: boolean) => string | undefined;
+    tryResolveRealFileWithExtensions: (path: string, extensions: string[], preserveSymlinks?: boolean) => string | undefined;
+    tryResolveRealFileOrType: (path: string, preserveSymlinks?: boolean) => {
+        path?: string;
+        type: 'directory' | 'file';
+    } | undefined;
+    initWatcher?: (watcher: FSWatcher) => void;
+}
+
 interface ResolveOptions {
     /**
      * @default ['browser', 'module', 'jsnext:main', 'jsnext']
@@ -2656,6 +2675,7 @@ interface InternalResolveOptions extends Required<ResolveOptions> {
     isProduction: boolean;
     ssrConfig?: SSROptions;
     packageCache?: PackageCache;
+    fsUtils?: FsUtils;
     /**
      * src code mode also attempts the following:
      * - resolving /xxx as URLs

package/dist/node/index.js

@@ -1,6 +1,6 @@
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
-import { i as isInNodeModules } from './chunks/dep-YJaePtkC.js';
-export { b as build, e as buildErrorMessage, h as createFilter, k as createLogger, c as createServer, d as defineConfig, f as formatPostcssSourceMap, u as isFileServingAllowed, l as loadConfigFromFile, v as loadEnv, g as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, a as preprocessCSS, p as preview, r as resolveConfig, w as resolveEnvPrefix, q as searchForWorkspaceRoot, j as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-YJaePtkC.js';
+import { i as isInNodeModules } from './chunks/dep-uAHLeuC6.js';
+export { b as build, e as buildErrorMessage, h as createFilter, k as createLogger, c as createServer, d as defineConfig, f as formatPostcssSourceMap, u as isFileServingAllowed, l as loadConfigFromFile, v as loadEnv, g as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, a as preprocessCSS, p as preview, r as resolveConfig, w as resolveEnvPrefix, q as searchForWorkspaceRoot, j as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-uAHLeuC6.js';
 export { VERSION as version } from './constants.js';
 export { version as esbuildVersion } from 'esbuild';
 export { VERSION as rollupVersion } from 'rollup';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "5.0.6",
+  "version": "5.0.8",
   "type": "module",
   "license": "MIT",
   "author": "Evan You",
@@ -70,7 +70,7 @@
   },
   "devDependencies": {
     "@ampproject/remapping": "^2.2.1",
-    "@babel/parser": "^7.23.5",
+    "@babel/parser": "^7.23.6",
     "@jridgewell/trace-mapping": "^0.3.20",
     "@rollup/plugin-alias": "^5.1.0",
     "@rollup/plugin-commonjs": "^25.0.7",
@@ -82,7 +82,7 @@
     "@types/escape-html": "^1.0.4",
     "@types/pnpapi": "^0.0.5",
     "acorn": "^8.11.2",
-    "acorn-walk": "^8.3.0",
+    "acorn-walk": "^8.3.1",
     "cac": "^6.7.14",
     "chokidar": "^3.5.3",
     "connect": "^3.7.0",
@@ -126,7 +126,7 @@
     "tslib": "^2.6.2",
     "types": "link:./types",
     "ufo": "^1.3.2",
-    "ws": "^8.14.2"
+    "ws": "^8.15.0"
   },
   "peerDependencies": {
     "@types/node": "^18.0.0 || >=20.0.0",