vite 5.0.7 → 5.0.9

package/dist/node/chunks/{dep-wTaJK0Jt.js → dep-Pluk1iaB.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);
@@ -28480,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';
@@ -28786,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);
                     }
@@ -28840,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"
@@ -29313,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) {
-        resolved = safeRealpathSync(resolved);
-    }
-    return normalizePath$3(resolved);
-}
 
 var dist = {};
 
@@ -39025,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;
@@ -39775,8 +40076,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-tttr_ygS.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-iw_F17O-.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-rzQTjkv_.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-riInLuGl.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 /**
  * @experimental
@@ -41163,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) {
@@ -50224,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 {
@@ -50235,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
@@ -52517,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
@@ -52529,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;
@@ -53039,7 +53346,9 @@ let Receiver$1 = class Receiver extends Writable$1 {
       }
     }
 
-    this._state = WAIT_MICROTASK;
+    this._state = this._allowMultipleEventsPerMicrotask
+      ? GET_INFO
+      : WAIT_MICROTASK;
   }
 
   /**
@@ -53056,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);
 
@@ -53089,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;
   }
 };
 
@@ -54314,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
@@ -54323,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,
@@ -54740,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
@@ -54762,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,
@@ -54928,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)) {
         //
@@ -55113,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
@@ -55529,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
@@ -55555,6 +55876,7 @@ class WebSocketServer extends EventEmitter {
     super();
 
     options = {
+      allowMultipleEventsPerMicrotask: false,
       maxPayload: 100 * 1024 * 1024,
       skipUTF8Validation: false,
       perMessageDeflate: false,
@@ -55909,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
     });
@@ -58448,12 +58772,14 @@ 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 (
         // Only accept GET or HEAD
         (req.method !== 'GET' && req.method !== 'HEAD') ||
+            // Exclude default favicon requests
+            req.url === '/favicon.ico' ||
             // Require Accept: text/html or */*
             !(req.headers.accept === undefined || // equivalent to `Accept: */*`
                 req.headers.accept === '' || // equivalent to `Accept: */*`
@@ -58467,7 +58793,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();
@@ -58476,7 +58802,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;
@@ -58486,7 +58812,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;
@@ -58561,6 +58887,11 @@ const debugCache = createDebugger('vite:cache');
 const knownIgnoreList = new Set(['/', '/favicon.ico']);
 function transformMiddleware(server) {
     // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
+    // check if public dir is inside root dir
+    const { root } = server.config;
+    const publicDir = normalizePath$3(server.config.publicDir);
+    const publicDirInRoot = publicDir.startsWith(withTrailingSlash(root));
+    const publicPath = `${publicDir.slice(root.length)}/`;
     return async function viteTransformMiddleware(req, res, next) {
         if (req.method !== 'GET' || knownIgnoreList.has(req.url)) {
             return next();
@@ -58622,35 +58953,8 @@ function transformMiddleware(server) {
                     }
                 }
             }
-            // check if public dir is inside root dir
-            const publicDir = normalizePath$3(server.config.publicDir);
-            const rootDir = normalizePath$3(server.config.root);
-            if (publicDir.startsWith(withTrailingSlash(rootDir))) {
-                const publicPath = `${publicDir.slice(rootDir.length)}/`;
-                // warn explicit public paths
-                if (url.startsWith(withTrailingSlash(publicPath))) {
-                    let warning;
-                    if (isImportRequest(url)) {
-                        const rawUrl = removeImportQuery(url);
-                        if (urlRE.test(url)) {
-                            warning =
-                                `Assets in the public directory are served at the root path.\n` +
-                                    `Instead of ${colors$1.cyan(rawUrl)}, use ${colors$1.cyan(rawUrl.replace(publicPath, '/'))}.`;
-                        }
-                        else {
-                            warning =
-                                'Assets in public directory cannot be imported from JavaScript.\n' +
-                                    `If you intend to import that asset, put the file in the src directory, and use ${colors$1.cyan(rawUrl.replace(publicPath, '/src/'))} instead of ${colors$1.cyan(rawUrl)}.\n` +
-                                    `If you intend to use the URL of that asset, use ${colors$1.cyan(injectQuery(rawUrl.replace(publicPath, '/'), 'url'))}.`;
-                        }
-                    }
-                    else {
-                        warning =
-                            `Files in the public directory are served at the root path.\n` +
-                                `Instead of ${colors$1.cyan(url)}, use ${colors$1.cyan(url.replace(publicPath, '/'))}.`;
-                    }
-                    server.config.logger.warn(colors$1.yellow(warning));
-                }
+            if (publicDirInRoot && url.startsWith(publicPath)) {
+                warnAboutExplicitPublicPathInUrl(url);
             }
             if (isJSRequest(url) ||
                 isImportRequest(url) ||
@@ -58745,6 +59049,29 @@ function transformMiddleware(server) {
         }
         next();
     };
+    function warnAboutExplicitPublicPathInUrl(url) {
+        let warning;
+        if (isImportRequest(url)) {
+            const rawUrl = removeImportQuery(url);
+            if (urlRE.test(url)) {
+                warning =
+                    `Assets in the public directory are served at the root path.\n` +
+                        `Instead of ${colors$1.cyan(rawUrl)}, use ${colors$1.cyan(rawUrl.replace(publicPath, '/'))}.`;
+            }
+            else {
+                warning =
+                    'Assets in public directory cannot be imported from JavaScript.\n' +
+                        `If you intend to import that asset, put the file in the src directory, and use ${colors$1.cyan(rawUrl.replace(publicPath, '/src/'))} instead of ${colors$1.cyan(rawUrl)}.\n` +
+                        `If you intend to use the URL of that asset, use ${colors$1.cyan(injectQuery(rawUrl.replace(publicPath, '/'), 'url'))}.`;
+            }
+        }
+        else {
+            warning =
+                `Files in the public directory are served at the root path.\n` +
+                    `Instead of ${colors$1.cyan(url)}, use ${colors$1.cyan(url.replace(publicPath, '/'))}.`;
+        }
+        server.config.logger.warn(colors$1.yellow(warning));
+    }
 }
 
 function createDevHtmlTransformFn(config) {
@@ -58778,6 +59105,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)
@@ -58797,20 +59127,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))
@@ -58823,7 +59158,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);
     }
@@ -58974,6 +59309,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) {
@@ -58989,7 +59325,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;
@@ -59653,7 +59989,7 @@ async function _createServer(inlineConfig = {}, options) {
     const watcher = watchEnabled
         ? chokidar.watch(
         // config file dependencies and env file might be outside of root
-        [root, ...config.configFileDependencies, config.envDir], resolvedWatchOptions)
+        [...new Set([root, ...config.configFileDependencies, config.envDir])], resolvedWatchOptions)
         : createNoopWatcher(resolvedWatchOptions);
     const moduleGraph = new ModuleGraph((url, ssr) => container.resolveId(url, undefined, { ssr }));
     const container = await createPluginContainer(config, moduleGraph, watcher);
@@ -59845,11 +60181,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 (publicFiles && 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);
@@ -59861,8 +60200,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) {
@@ -59931,7 +60275,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
@@ -60073,6 +60417,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);
@@ -60899,10 +61244,21 @@ async function workerFileToUrl(config, id, query) {
 function webWorkerPostPlugin() {
     return {
         name: 'vite:worker-post',
-        resolveImportMeta(property, { chunkId, format }) {
+        resolveImportMeta(property, { format }) {
             // document is undefined in the worker, so we need to avoid it in iife
-            if (property === 'url' && format === 'iife') {
-                return 'self.location.href';
+            if (format === 'iife') {
+                // compiling import.meta
+                if (!property) {
+                    // rollup only supports `url` property. we only support `url` property as well.
+                    // https://github.com/rollup/rollup/blob/62b648e1cc6a1f00260bb85aa2050097bb4afd2b/src/ast/nodes/MetaProperty.ts#L164-L173
+                    return `{
+            url: self.location.href
+          }`;
+                }
+                // compiling import.meta.url
+                if (property === 'url') {
+                    return 'self.location.href';
+                }
             }
             return null;
         },
@@ -61204,6 +61560,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;
@@ -61331,8 +61688,12 @@ function importAnalysisPlugin(config) {
                     url = resolved.id.slice(root.length);
                 }
                 else if (depsOptimizer?.isOptimizedDepFile(resolved.id) ||
-                    (path$o.isAbsolute(cleanUrl(resolved.id)) &&
-                        fs$l.existsSync(cleanUrl(resolved.id)))) {
+                    // vite-plugin-react isn't following the leading \0 virtual module convention.
+                    // This is a temporary hack to avoid expensive fs checks for React apps.
+                    // We'll remove this as soon we're able to fix the react plugins.
+                    (resolved.id !== '/@react-refresh' &&
+                        path$o.isAbsolute(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);
@@ -61986,6 +62347,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) {
@@ -62014,7 +62376,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) ||
@@ -62712,6 +63074,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)
@@ -63798,16 +64161,6 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                         external: doExternalize(path),
                     };
                 });
-                // onResolve is not called for glob imports.
-                // we need to add that here as well until esbuild calls onResolve for glob imports.
-                // https://github.com/evanw/esbuild/issues/3317
-                build.onLoad({ filter, namespace: 'file' }, () => {
-                    const externalOnLoadResult = {
-                        loader: 'js',
-                        contents: 'export default {}',
-                    };
-                    return externalOnLoadResult;
-                });
             };
             // css
             setupExternalize(CSS_LANGS_RE, isUnlessEntry);
@@ -63867,6 +64220,15 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                     contents,
                 };
             });
+            // onResolve is not called for glob imports.
+            // we need to add that here as well until esbuild calls onResolve for glob imports.
+            // https://github.com/evanw/esbuild/issues/3317
+            build.onLoad({ filter: /.*/, namespace: 'file' }, () => {
+                return {
+                    loader: 'js',
+                    contents: 'export default {}',
+                };
+            });
         },
     };
 }
@@ -64710,9 +65072,11 @@ async function optimizeServerSsrDeps(config) {
     return result.metadata;
 }
 function initDepsOptimizerMetadata(config, ssr, timestamp) {
-    const hash = getDepHash(config, ssr);
+    const { lockfileHash, configHash, hash } = getDepHash(config, ssr);
     return {
         hash,
+        lockfileHash,
+        configHash,
         browserHash: getOptimizedBrowserHash(hash, {}, timestamp),
         optimized: {},
         chunks: {},
@@ -64746,11 +65110,19 @@ async function loadCachedDepOptimizationMetadata(config, ssr, force = config.opt
         }
         catch (e) { }
         // hash is consistent, no need to re-bundle
-        if (cachedMetadata && cachedMetadata.hash === getDepHash(config, ssr)) {
-            log?.('Hash is consistent. Skipping. Use --force to override.');
-            // Nothing to commit or cancel as we are using the cache, we only
-            // need to resolve the processing promise so requests can move on
-            return cachedMetadata;
+        if (cachedMetadata) {
+            if (cachedMetadata.lockfileHash !== getLockfileHash(config)) {
+                config.logger.info('Re-optimizing dependencies because lockfile has changed');
+            }
+            else if (cachedMetadata.configHash !== getConfigHash(config, ssr)) {
+                config.logger.info('Re-optimizing dependencies because vite config has changed');
+            }
+            else {
+                log?.('Hash is consistent. Skipping. Use --force to override.');
+                // Nothing to commit or cancel as we are using the cache, we only
+                // need to resolve the processing promise so requests can move on
+                return cachedMetadata;
+            }
         }
     }
     else {
@@ -64780,7 +65152,7 @@ function discoverProjectDependencies(config) {
     };
 }
 function toDiscoveredDependencies(config, deps, ssr, timestamp) {
-    const browserHash = getOptimizedBrowserHash(getDepHash(config, ssr), deps, timestamp);
+    const browserHash = getOptimizedBrowserHash(getDepHash(config, ssr).hash, deps, timestamp);
     const discovered = {};
     for (const id in deps) {
         const src = deps[id];
@@ -64810,7 +65182,7 @@ function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.command
     };
     const depsCacheDir = getDepsCacheDir(resolvedConfig, ssr);
     const processingCacheDir = getProcessingDepsCacheDir(resolvedConfig, ssr);
-    // Create a temporal directory so we don't need to delete optimized deps
+    // Create a temporary 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
     fs$l.mkdirSync(processingCacheDir, { recursive: true });
@@ -64850,40 +65222,40 @@ function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.command
             // we finish commiting the new deps cache files to the deps folder
             committed = true;
             // Write metadata file, then commit the processing folder to the global deps cache
-            // Rewire the file paths from the temporal processing dir to the final deps cache dir
+            // Rewire the file paths from the temporary processing dir to the final deps cache dir
             const dataPath = path$o.join(processingCacheDir, '_metadata.json');
             debug$1?.(colors$1.green(`creating _metadata.json in ${processingCacheDir}`));
             fs$l.writeFileSync(dataPath, stringifyDepsOptimizerMetadata(metadata, depsCacheDir));
             // In order to minimize the time where the deps folder isn't in a consistent state,
-            // we first rename the old depsCacheDir to a temporal path, then we rename the
+            // we first rename the old depsCacheDir to a temporary path, then we rename the
             // new processing cache dir to the depsCacheDir. In systems where doing so in sync
             // is safe, we do an atomic operation (at least for this thread). For Windows, we
             // found there are cases where the rename operation may finish before it's done
             // so we do a graceful rename checking that the folder has been properly renamed.
             // We found that the rename-rename (then delete the old folder in the background)
             // is safer than a delete-rename operation.
-            const temporalPath = depsCacheDir + getTempSuffix();
+            const temporaryPath = depsCacheDir + getTempSuffix();
             const depsCacheDirPresent = fs$l.existsSync(depsCacheDir);
             if (isWindows$4) {
                 if (depsCacheDirPresent) {
-                    debug$1?.(colors$1.green(`renaming ${depsCacheDir} to ${temporalPath}`));
-                    await safeRename(depsCacheDir, temporalPath);
+                    debug$1?.(colors$1.green(`renaming ${depsCacheDir} to ${temporaryPath}`));
+                    await safeRename(depsCacheDir, temporaryPath);
                 }
                 debug$1?.(colors$1.green(`renaming ${processingCacheDir} to ${depsCacheDir}`));
                 await safeRename(processingCacheDir, depsCacheDir);
             }
             else {
                 if (depsCacheDirPresent) {
-                    debug$1?.(colors$1.green(`renaming ${depsCacheDir} to ${temporalPath}`));
-                    fs$l.renameSync(depsCacheDir, temporalPath);
+                    debug$1?.(colors$1.green(`renaming ${depsCacheDir} to ${temporaryPath}`));
+                    fs$l.renameSync(depsCacheDir, temporaryPath);
                 }
                 debug$1?.(colors$1.green(`renaming ${processingCacheDir} to ${depsCacheDir}`));
                 fs$l.renameSync(processingCacheDir, depsCacheDir);
             }
-            // Delete temporal path in the background
+            // Delete temporary path in the background
             if (depsCacheDirPresent) {
-                debug$1?.(colors$1.green(`removing cache temp dir ${temporalPath}`));
-                fsp.rm(temporalPath, { recursive: true, force: true });
+                debug$1?.(colors$1.green(`removing cache temp dir ${temporaryPath}`));
+                fsp.rm(temporaryPath, { recursive: true, force: true });
             }
         },
     };
@@ -65182,7 +65554,7 @@ function createIsOptimizedDepUrl(config) {
     };
 }
 function parseDepsOptimizerMetadata(jsonMetadata, depsCacheDir) {
-    const { hash, browserHash, optimized, chunks } = JSON.parse(jsonMetadata, (key, value) => {
+    const { hash, lockfileHash, configHash, browserHash, optimized, chunks } = JSON.parse(jsonMetadata, (key, value) => {
         // Paths can be absolute or relative to the deps cache dir where
         // the _metadata.json is located
         if (key === 'file' || key === 'src') {
@@ -65197,6 +65569,8 @@ function parseDepsOptimizerMetadata(jsonMetadata, depsCacheDir) {
     }
     const metadata = {
         hash,
+        lockfileHash,
+        configHash,
         browserHash,
         optimized: {},
         discovered: {},
@@ -65227,9 +65601,11 @@ function parseDepsOptimizerMetadata(jsonMetadata, depsCacheDir) {
  * browserHash to allow long term caching
  */
 function stringifyDepsOptimizerMetadata(metadata, depsCacheDir) {
-    const { hash, browserHash, optimized, chunks } = metadata;
+    const { hash, configHash, lockfileHash, browserHash, optimized, chunks } = metadata;
     return JSON.stringify({
         hash,
+        configHash,
+        lockfileHash,
         browserHash,
         optimized: Object.fromEntries(Object.values(optimized).map(({ id, src, file, fileHash, needsInterop }) => [
             id,
@@ -65343,25 +65719,11 @@ const lockfileFormats = [
     return process.env.npm_config_user_agent?.startsWith(manager) ? 1 : -1;
 });
 const lockfileNames = lockfileFormats.map((l) => l.name);
-function getDepHash(config, ssr) {
-    const lockfilePath = lookupFile(config.root, lockfileNames);
-    let content = lockfilePath ? fs$l.readFileSync(lockfilePath, 'utf-8') : '';
-    if (lockfilePath) {
-        const lockfileName = path$o.basename(lockfilePath);
-        const { checkPatches } = lockfileFormats.find((f) => f.name === lockfileName);
-        if (checkPatches) {
-            // Default of https://github.com/ds300/patch-package
-            const fullPath = path$o.join(path$o.dirname(lockfilePath), 'patches');
-            const stat = tryStatSync(fullPath);
-            if (stat?.isDirectory()) {
-                content += stat.mtimeMs.toString();
-            }
-        }
-    }
-    // also take config into account
+function getConfigHash(config, ssr) {
+    // Take config into account
     // only a subset of config options that can affect dep optimization
     const optimizeDeps = getDepOptimizationConfig(config, ssr);
-    content += JSON.stringify({
+    const content = JSON.stringify({
         mode: process.env.NODE_ENV || config.mode,
         root: config.root,
         resolve: config.resolve,
@@ -65369,8 +65731,12 @@ function getDepHash(config, ssr) {
         assetsInclude: config.assetsInclude,
         plugins: config.plugins.map((p) => p.name),
         optimizeDeps: {
-            include: optimizeDeps?.include,
-            exclude: optimizeDeps?.exclude,
+            include: optimizeDeps?.include
+                ? Array.from(new Set(optimizeDeps.include)).sort()
+                : undefined,
+            exclude: optimizeDeps?.exclude
+                ? Array.from(new Set(optimizeDeps.exclude)).sort()
+                : undefined,
             esbuildOptions: {
                 ...optimizeDeps?.esbuildOptions,
                 plugins: optimizeDeps?.esbuildOptions?.plugins?.map((p) => p.name),
@@ -65384,6 +65750,33 @@ function getDepHash(config, ssr) {
     });
     return getHash(content);
 }
+function getLockfileHash(config, ssr) {
+    const lockfilePath = lookupFile(config.root, lockfileNames);
+    let content = lockfilePath ? fs$l.readFileSync(lockfilePath, 'utf-8') : '';
+    if (lockfilePath) {
+        const lockfileName = path$o.basename(lockfilePath);
+        const { checkPatches } = lockfileFormats.find((f) => f.name === lockfileName);
+        if (checkPatches) {
+            // Default of https://github.com/ds300/patch-package
+            const fullPath = path$o.join(path$o.dirname(lockfilePath), 'patches');
+            const stat = tryStatSync(fullPath);
+            if (stat?.isDirectory()) {
+                content += stat.mtimeMs.toString();
+            }
+        }
+    }
+    return getHash(content);
+}
+function getDepHash(config, ssr) {
+    const lockfileHash = getLockfileHash(config);
+    const configHash = getConfigHash(config, ssr);
+    const hash = getHash(lockfileHash + configHash);
+    return {
+        hash,
+        lockfileHash,
+        configHash,
+    };
+}
 function getOptimizedBrowserHash(hash, deps, timestamp = '') {
     return getHash(hash + JSON.stringify(deps) + timestamp);
 }
@@ -65478,7 +65871,6 @@ var index = {
 	depsLogString: depsLogString,
 	discoverProjectDependencies: discoverProjectDependencies,
 	extractExportsData: extractExportsData,
-	getDepHash: getDepHash,
 	getDepsCacheDir: getDepsCacheDir,
 	getDepsOptimizer: getDepsOptimizer,
 	getOptimizedDepPath: getOptimizedDepPath,
@@ -67235,6 +67627,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
                                     tryIndex: true,
                                     ...options,
                                     idOnly: true,
+                                    fsUtils: getFsUtils(resolved),
                                 }),
                             ],
                         }));