vite 6.0.0-beta.7 → 6.0.0-beta.8

package/dist/node/chunks/{dep-Vd7gFLqj.js → dep-Ddvoc4zx.js}

@@ -7,7 +7,7 @@ import { promisify, format, inspect } from 'node:util';
 import { performance } from 'node:perf_hooks';
 import require$$0$3, { createRequire, builtinModules } from 'node:module';
 import esbuild, { transform, formatMessages, build as build$3 } from 'esbuild';
-import { CLIENT_ENTRY, OPTIMIZABLE_ENTRY_RE, wildcardHosts, loopbackHosts, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, DEFAULT_ASSETS_INLINE_LIMIT, ENV_ENTRY, SPECIAL_QUERY_RE, DEP_VERSION_RE, JS_TYPES_RE, KNOWN_ASSET_TYPES, CSS_LANGS_RE, METADATA_FILENAME, ESBUILD_MODULES_TARGET, ERR_OPTIMIZE_DEPS_PROCESSING_ERROR, ERR_OUTDATED_OPTIMIZED_DEP, ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR, VITE_PACKAGE_DIR, CLIENT_DIR, DEFAULT_DEV_PORT, VERSION, ROLLUP_HOOKS, DEFAULT_PREVIEW_PORT, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES, DEFAULT_EXTENSIONS, DEFAULT_MAIN_FIELDS } from '../constants.js';
+import { CLIENT_ENTRY, OPTIMIZABLE_ENTRY_RE, wildcardHosts, loopbackHosts, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, DEFAULT_ASSETS_INLINE_LIMIT, ENV_ENTRY, SPECIAL_QUERY_RE, DEP_VERSION_RE, DEV_PROD_CONDITION, JS_TYPES_RE, KNOWN_ASSET_TYPES, CSS_LANGS_RE, METADATA_FILENAME, ESBUILD_MODULES_TARGET, ERR_OPTIMIZE_DEPS_PROCESSING_ERROR, ERR_OUTDATED_OPTIMIZED_DEP, ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR, VITE_PACKAGE_DIR, CLIENT_DIR, DEFAULT_DEV_PORT, VERSION, ROLLUP_HOOKS, DEFAULT_PREVIEW_PORT, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES, DEFAULT_CONDITIONS, DEFAULT_EXTENSIONS, DEFAULT_MAIN_FIELDS, DEFAULT_EXTERNAL_CONDITIONS } from '../constants.js';
 import * as sysPath from 'path';
 import sysPath__default, { posix, win32, isAbsolute, resolve as resolve$2, relative as relative$1, basename as basename$1, extname, dirname as dirname$1, join, sep } from 'path';
 import require$$0$1, { existsSync, readFileSync, statSync, lstatSync, unwatchFile, watchFile, watch as watch$1, stat as stat$1, readdirSync } from 'fs';
@@ -9651,14 +9651,24 @@ function loadPackageData(pkgPath) {
 function getResolveCacheKey(key, options) {
   return [
     key,
-    options.webCompatible ? "1" : "0",
     options.isRequire ? "1" : "0",
     options.conditions.join("_"),
-    options.overrideConditions?.join("_") || "",
     options.extensions.join("_"),
     options.mainFields.join("_")
   ].join("|");
 }
+function findNearestNodeModules(basedir) {
+  while (basedir) {
+    const pkgPath = path.join(basedir, "node_modules");
+    if (tryStatSync(pkgPath)?.isDirectory()) {
+      return pkgPath;
+    }
+    const nextBasedir = path.dirname(basedir);
+    if (nextBasedir === basedir) break;
+    basedir = nextBasedir;
+  }
+  return null;
+}
 function watchPackageDataPlugin(packageCache) {
   const watchQueue = /* @__PURE__ */ new Set();
   const watchedDirs = /* @__PURE__ */ new Set();
@@ -9791,7 +9801,7 @@ const DEBUG = process.env.DEBUG;
 function createDebugger(namespace, options = {}) {
   const log = debug$e(namespace);
   const { onlyWhenFocused, depth } = options;
-  if (depth && log.inspectOpts.depth == null) {
+  if (depth && log.inspectOpts && log.inspectOpts.depth == null) {
     log.inspectOpts.depth = options.depth;
   }
   let enabled = log.enabled;
@@ -15820,283 +15830,6 @@ function hasESMSyntax(code, opts = {}) {
   return ESM_RE.test(code);
 }
 
-const commonFsUtils = {
-  existsSync: fs__default.existsSync,
-  isDirectory,
-  tryResolveRealFile,
-  tryResolveRealFileWithExtensions,
-  tryResolveRealFileOrType
-};
-const cachedFsUtilsMap = /* @__PURE__ */ new WeakMap();
-function getFsUtils(config) {
-  let fsUtils = cachedFsUtilsMap.get(config);
-  if (!fsUtils) {
-    if (config.command !== "serve" || config.server.fs.cachedChecks !== true || config.server.watch?.ignored || process.versions.pnp) {
-      fsUtils = commonFsUtils;
-    } else if (!config.resolve.preserveSymlinks && config.root !== getRealPath(config.root)) {
-      fsUtils = commonFsUtils;
-    } else {
-      fsUtils = createCachedFsUtils(config);
-    }
-    cachedFsUtilsMap.set(config, fsUtils);
-  }
-  return fsUtils;
-}
-function readDirCacheSync(file) {
-  let dirents;
-  try {
-    dirents = fs__default.readdirSync(file, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  return direntsToDirentMap(dirents);
-}
-function direntsToDirentMap(fsDirents) {
-  const dirents = /* @__PURE__ */ new Map();
-  for (const dirent of fsDirents) {
-    const type = dirent.isDirectory() ? "directory" : dirent.isSymbolicLink() ? "symlink" : dirent.isFile() ? "file" : void 0;
-    if (type) {
-      dirents.set(dirent.name, { type });
-    }
-  }
-  return dirents;
-}
-function ensureFileMaybeSymlinkIsResolved(direntCache, filePath) {
-  if (direntCache.type !== "file_maybe_symlink") return;
-  const isSymlink = fs__default.lstatSync(filePath, { throwIfNoEntry: false })?.isSymbolicLink();
-  direntCache.type = isSymlink === void 0 ? "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;
-  const rootDirPath = `${root}/`;
-  const rootCache = { type: "directory" };
-  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 + 1);
-          const isSymlink = fs__default.lstatSync(dirPath, { throwIfNoEntry: false })?.isSymbolicLink();
-          nextDirentCache.type = isSymlink ? "symlink" : "directory";
-        }
-        direntCache = nextDirentCache;
-      } else if (direntCache.type === "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[normalizedFile.length - 1] === "/") {
-      normalizedFile = normalizedFile.slice(0, -1);
-    }
-    if (normalizedFile === root) {
-      return rootCache;
-    }
-    if (!normalizedFile.startsWith(rootDirPath)) {
-      return void 0;
-    }
-    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(
-      normalizePath$1(path.dirname(file))
-    );
-    if (direntCache && direntCache.type === "directory" && direntCache.dirents) {
-      direntCache.dirents.set(path.basename(file), { type });
-    }
-  }
-  function onPathUnlink(file) {
-    const direntCache = getDirentCacheFromPath(
-      normalizePath$1(path.dirname(file))
-    );
-    if (direntCache && direntCache.type === "directory" && direntCache.dirents) {
-      direntCache.dirents.delete(path.basename(file));
-    }
-  }
-  return {
-    existsSync(file) {
-      if (isInNodeModules$1(file)) {
-        return fs__default.existsSync(file);
-      }
-      const normalizedFile = normalizePath$1(file);
-      const direntCache = getDirentCacheFromPath(normalizedFile);
-      if (direntCache === void 0 || direntCache && direntCache.type === "symlink") {
-        return fs__default.existsSync(file);
-      }
-      return !!direntCache;
-    },
-    tryResolveRealFile(file, preserveSymlinks) {
-      if (isInNodeModules$1(file)) {
-        return tryResolveRealFile(file, preserveSymlinks);
-      }
-      const normalizedFile = normalizePath$1(file);
-      const direntCache = getDirentCacheFromPath(normalizedFile);
-      if (direntCache === void 0 || direntCache && direntCache.type === "symlink") {
-        return tryResolveRealFile(file, preserveSymlinks);
-      }
-      if (!direntCache || direntCache.type === "directory") {
-        return;
-      }
-      return normalizedFile;
-    },
-    tryResolveRealFileWithExtensions(file, extensions, preserveSymlinks) {
-      if (isInNodeModules$1(file)) {
-        return tryResolveRealFileWithExtensions(
-          file,
-          extensions,
-          preserveSymlinks
-        );
-      }
-      const normalizedFile = normalizePath$1(file);
-      const dirPath = path.posix.dirname(normalizedFile);
-      const direntCache = getDirentCacheFromPath(dirPath);
-      if (direntCache === void 0 || direntCache && direntCache.type === "symlink") {
-        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.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") {
-            return tryResolveRealFile(filePath, preserveSymlinks);
-          }
-          if (fileDirentCache.type === "file") {
-            return filePath;
-          }
-        }
-      }
-    },
-    tryResolveRealFileOrType(file, preserveSymlinks) {
-      if (isInNodeModules$1(file)) {
-        return tryResolveRealFileOrType(file, preserveSymlinks);
-      }
-      const normalizedFile = normalizePath$1(file);
-      const direntCache = getDirentCacheFromPath(normalizedFile);
-      if (direntCache === void 0 || direntCache && direntCache.type === "symlink") {
-        return tryResolveRealFileOrType(file, preserveSymlinks);
-      }
-      if (!direntCache) {
-        return;
-      }
-      if (direntCache.type === "directory") {
-        return { type: "directory" };
-      }
-      return { path: normalizedFile, type: "file" };
-    },
-    isDirectory(dirPath) {
-      if (isInNodeModules$1(dirPath)) {
-        return isDirectory(dirPath);
-      }
-      const direntCache = getDirentCacheFromPath(normalizePath$1(dirPath));
-      if (direntCache === void 0 || direntCache && direntCache.type === "symlink") {
-        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$1(resolved);
-}
-function isDirectory(path2) {
-  const stat = tryStatSync(path2);
-  return stat?.isDirectory() ?? false;
-}
-
 const debug$b = createDebugger("vite:external");
 const isExternalCache = /* @__PURE__ */ new WeakMap();
 function shouldExternalize(environment, id, importer) {
@@ -16118,7 +15851,7 @@ function isConfiguredAsExternal(environment, id, importer) {
 }
 function createIsConfiguredAsExternal(environment) {
   const { config } = environment;
-  const { root, resolve, webCompatible } = config;
+  const { root, resolve } = config;
   const { external, noExternal } = resolve;
   const noExternalFilter = typeof noExternal !== "boolean" && !(Array.isArray(noExternal) && noExternal.length === 0) && createFilter(void 0, noExternal, { resolve: false });
   const targetConditions = resolve.externalConditions || [];
@@ -16127,8 +15860,7 @@ function createIsConfiguredAsExternal(environment) {
     root,
     isProduction: false,
     isBuild: true,
-    conditions: targetConditions,
-    webCompatible
+    conditions: targetConditions
   };
   const isExternalizable = (id, importer, configuredAsExternal) => {
     if (!bareImportRE.test(id) || id.includes("\0")) {
@@ -16237,12 +15969,10 @@ function resolvePlugin(resolveOptions, environmentsOptions) {
       const options = {
         isRequire,
         ...environmentResolveOptions,
-        webCompatible: currentEnvironmentOptions.webCompatible,
         ...resolveOptions,
         // plugin options + resolve options overrides
         scan: resolveOpts?.scan ?? resolveOptions.scan
       };
-      const depsOptimizerOptions = this.environment.config.optimizeDeps;
       const resolvedImports = resolveSubpathImports(id, importer, options);
       if (resolvedImports) {
         id = resolvedImports;
@@ -16291,14 +16021,7 @@ function resolvePlugin(resolveOptions, environmentsOptions) {
           }
           return normalizedFsPath;
         }
-        if (options.webCompatible && options.mainFields.includes("browser") && (res = tryResolveBrowserMapping(
-          fsPath,
-          importer,
-          options,
-          true,
-          void 0,
-          depsOptimizerOptions
-        ))) {
+        if (options.mainFields.includes("browser") && (res = tryResolveBrowserMapping(fsPath, importer, options, true))) {
           return res;
         }
         if (res = tryFsResolve(fsPath, options)) {
@@ -16351,13 +16074,12 @@ function resolvePlugin(resolveOptions, environmentsOptions) {
         ))) {
           return res;
         }
-        if (options.webCompatible && options.mainFields.includes("browser") && (res = tryResolveBrowserMapping(
+        if (options.mainFields.includes("browser") && (res = tryResolveBrowserMapping(
           id,
           importer,
           options,
           false,
-          external,
-          depsOptimizerOptions
+          external
         ))) {
           return res;
         }
@@ -16367,14 +16089,13 @@ function resolvePlugin(resolveOptions, environmentsOptions) {
           options,
           depsOptimizer,
           external,
-          void 0,
-          depsOptimizerOptions
+          void 0
         )) {
           return res;
         }
         if (isBuiltin(id)) {
           if (currentEnvironmentOptions.consumer === "server") {
-            if (options.webCompatible && options.noExternal === true && // if both noExternal and external are true, noExternal will take the higher priority and bundle it.
+            if (options.noExternal === true && // if both noExternal and external are true, noExternal will take the higher priority and bundle it.
             // only if the id is explicitly listed in external, we will externalize it and skip this error.
             (options.external === true || !options.external.includes(id))) {
               let message = `Cannot bundle Node.js built-in "${id}"`;
@@ -16479,32 +16200,25 @@ const knownTsOutputRE = /\.(?:js|mjs|cjs|jsx)$/;
 const isPossibleTsOutput = (url) => knownTsOutputRE.test(url);
 function tryCleanFsResolve(file, options, tryIndex = true, skipPackageJson = false) {
   const { tryPrefix, extensions, preserveSymlinks } = options;
-  const fsUtils = options.fsUtils ?? commonFsUtils;
-  const fileResult = fsUtils.tryResolveRealFileOrType(
-    file,
-    options.preserveSymlinks
-  );
+  const fileResult = tryResolveRealFileOrType(file, options.preserveSymlinks);
   if (fileResult?.path) return fileResult.path;
   let res;
   const possibleJsToTs = options.isFromTsImporter && isPossibleTsOutput(file);
   if (possibleJsToTs || options.extensions.length || tryPrefix) {
     const dirPath = path.dirname(file);
-    if (fsUtils.isDirectory(dirPath)) {
+    if (isDirectory(dirPath)) {
       if (possibleJsToTs) {
         const fileExt = path.extname(file);
         const fileName = file.slice(0, -fileExt.length);
-        if (res = fsUtils.tryResolveRealFile(
+        if (res = tryResolveRealFile(
           fileName + fileExt.replace("js", "ts"),
           preserveSymlinks
         ))
           return res;
-        if (fileExt === ".js" && (res = fsUtils.tryResolveRealFile(
-          fileName + ".tsx",
-          preserveSymlinks
-        )))
+        if (fileExt === ".js" && (res = tryResolveRealFile(fileName + ".tsx", preserveSymlinks)))
           return res;
       }
-      if (res = fsUtils.tryResolveRealFileWithExtensions(
+      if (res = tryResolveRealFileWithExtensions(
         file,
         extensions,
         preserveSymlinks
@@ -16512,9 +16226,8 @@ function tryCleanFsResolve(file, options, tryIndex = true, skipPackageJson = fal
         return res;
       if (tryPrefix) {
         const prefixed = `${dirPath}/${options.tryPrefix}${path.basename(file)}`;
-        if (res = fsUtils.tryResolveRealFile(prefixed, preserveSymlinks))
-          return res;
-        if (res = fsUtils.tryResolveRealFileWithExtensions(
+        if (res = tryResolveRealFile(prefixed, preserveSymlinks)) return res;
+        if (res = tryResolveRealFileWithExtensions(
           prefixed,
           extensions,
           preserveSymlinks
@@ -16528,7 +16241,7 @@ function tryCleanFsResolve(file, options, tryIndex = true, skipPackageJson = fal
     if (!skipPackageJson) {
       let pkgPath = `${dirPath}/package.json`;
       try {
-        if (fsUtils.existsSync(pkgPath)) {
+        if (fs__default.existsSync(pkgPath)) {
           if (!options.preserveSymlinks) {
             pkgPath = safeRealpathSync(pkgPath);
           }
@@ -16540,14 +16253,14 @@ function tryCleanFsResolve(file, options, tryIndex = true, skipPackageJson = fal
           throw e;
       }
     }
-    if (res = fsUtils.tryResolveRealFileWithExtensions(
+    if (res = tryResolveRealFileWithExtensions(
       `${dirPath}/index`,
       extensions,
       preserveSymlinks
     ))
       return res;
     if (tryPrefix) {
-      if (res = fsUtils.tryResolveRealFileWithExtensions(
+      if (res = tryResolveRealFileWithExtensions(
         `${dirPath}/${options.tryPrefix}index`,
         extensions,
         preserveSymlinks
@@ -16556,7 +16269,7 @@ function tryCleanFsResolve(file, options, tryIndex = true, skipPackageJson = fal
     }
   }
 }
-function tryNodeResolve(id, importer, options, depsOptimizer, externalize, allowLinkedExternal = true, depsOptimizerOptions) {
+function tryNodeResolve(id, importer, options, depsOptimizer, externalize, allowLinkedExternal = true) {
   const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
   const deepMatch = deepImportRE.exec(id);
   const pkgId = deepMatch ? deepMatch[1] || deepMatch[2] : cleanUrl(id);
@@ -16619,47 +16332,30 @@ function tryNodeResolve(id, importer, options, depsOptimizer, externalize, allow
     }
     return { ...resolved2, id: resolvedId, external: true };
   };
-  if (!options.idOnly && (!options.scan && isBuild && !depsOptimizer || externalize)) {
+  if (!options.idOnly && (!options.scan && isBuild || externalize)) {
     return processResult({
       id: resolved,
       moduleSideEffects: pkg.hasSideEffects(resolved)
     });
   }
-  if (!options.ssrOptimizeCheck && (!isInNodeModules$1(resolved) || // linked
+  if (!isInNodeModules$1(resolved) || // linked
   !depsOptimizer || // resolving before listening to the server
-  options.scan)) {
+  options.scan) {
     return { id: resolved };
   }
-  const isJsType = depsOptimizer ? isOptimizable(resolved, depsOptimizer.options) : OPTIMIZABLE_ENTRY_RE.test(resolved);
-  let exclude = depsOptimizer?.options.exclude;
-  if (options.ssrOptimizeCheck) {
-    exclude = depsOptimizerOptions?.exclude;
-  }
-  const skipOptimization = !options.ssrOptimizeCheck && depsOptimizer?.options.noDiscovery || !isJsType || importer && isInNodeModules$1(importer) || exclude?.includes(pkgId) || exclude?.includes(id) || SPECIAL_QUERY_RE.test(resolved);
-  if (options.ssrOptimizeCheck) {
-    return {
-      id: skipOptimization ? injectQuery(resolved, `__vite_skip_optimization`) : resolved
-    };
-  }
+  const isJsType = isOptimizable(resolved, depsOptimizer.options);
+  const exclude = depsOptimizer.options.exclude;
+  const skipOptimization = depsOptimizer.options.noDiscovery || !isJsType || importer && isInNodeModules$1(importer) || exclude?.includes(pkgId) || exclude?.includes(id) || SPECIAL_QUERY_RE.test(resolved);
   if (skipOptimization) {
-    if (!isBuild) {
-      const versionHash = depsOptimizer.metadata.browserHash;
-      if (versionHash && isJsType) {
-        resolved = injectQuery(resolved, `v=${versionHash}`);
-      }
+    const versionHash = depsOptimizer.metadata.browserHash;
+    if (versionHash && isJsType) {
+      resolved = injectQuery(resolved, `v=${versionHash}`);
     }
   } else {
     const optimizedInfo = depsOptimizer.registerMissingImport(id, resolved);
     resolved = depsOptimizer.getOptimizedDepId(optimizedInfo);
   }
-  if (!options.idOnly && !options.scan && isBuild) {
-    return {
-      id: resolved,
-      moduleSideEffects: pkg.hasSideEffects(resolved)
-    };
-  } else {
-    return { id: resolved };
-  }
+  return { id: resolved };
 }
 async function tryOptimizedResolve(depsOptimizer, id, importer, preserveSymlinks, packageCache) {
   await depsOptimizer.scanProcessing;
@@ -16705,11 +16401,9 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
     if (!entryPoint) {
       for (const field of options.mainFields) {
         if (field === "browser") {
-          if (options.webCompatible) {
-            entryPoint = tryResolveBrowserEntry(dir, data, options);
-            if (entryPoint) {
-              break;
-            }
+          entryPoint = tryResolveBrowserEntry(dir, data, options);
+          if (entryPoint) {
+            break;
           }
         } else if (typeof data[field] === "string") {
           entryPoint = data[field];
@@ -16726,7 +16420,7 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
         skipPackageJson = true;
       } else {
         const { browser: browserField } = data;
-        if (options.webCompatible && options.mainFields.includes("browser") && isObject(browserField)) {
+        if (options.mainFields.includes("browser") && isObject(browserField)) {
           entry = mapWithBrowserField(entry, browserField) || entry;
         }
       }
@@ -16760,29 +16454,19 @@ function packageEntryFailure(id, details) {
   throw err;
 }
 function resolveExportsOrImports(pkg, key, options, type) {
-  const additionalConditions = new Set(
-    options.overrideConditions || [
-      "production",
-      "development",
-      "module",
-      ...options.conditions
-    ]
-  );
-  const conditions = [...additionalConditions].filter((condition) => {
-    switch (condition) {
-      case "production":
-        return options.isProduction;
-      case "development":
-        return !options.isProduction;
+  const conditions = options.conditions.map((condition) => {
+    if (condition === DEV_PROD_CONDITION) {
+      return options.isProduction ? "production" : "development";
     }
-    return true;
+    return condition;
   });
+  if (options.isRequire) {
+    conditions.push("require");
+  } else {
+    conditions.push("import");
+  }
   const fn = type === "imports" ? f : o;
-  const result = fn(pkg, key, {
-    browser: options.webCompatible && !additionalConditions.has("node"),
-    require: options.isRequire && !additionalConditions.has("import"),
-    conditions
-  });
+  const result = fn(pkg, key, { conditions, unsafe: true });
   return result ? result[0] : void 0;
 }
 function resolveDeepImport(id, { setResolvedCache, getResolvedCache, dir, data }, options) {
@@ -16809,7 +16493,7 @@ function resolveDeepImport(id, { setResolvedCache, getResolvedCache, dir, data }
         `Package subpath '${relativeId}' is not defined by "exports" in ${path.join(dir, "package.json")}.`
       );
     }
-  } else if (options.webCompatible && options.mainFields.includes("browser") && isObject(browserField)) {
+  } else if (options.mainFields.includes("browser") && isObject(browserField)) {
     const { file, postfix } = splitFileAndPostfix(relativeId);
     const mapped = mapWithBrowserField(file, browserField);
     if (mapped) {
@@ -16835,7 +16519,7 @@ function resolveDeepImport(id, { setResolvedCache, getResolvedCache, dir, data }
     }
   }
 }
-function tryResolveBrowserMapping(id, importer, options, isFilePath, externalize, depsOptimizerOptions) {
+function tryResolveBrowserMapping(id, importer, options, isFilePath, externalize) {
   let res;
   const pkg = importer && findNearestPackageData(path.dirname(importer), options.packageCache);
   if (pkg && isObject(pkg.data.browser)) {
@@ -16848,8 +16532,7 @@ function tryResolveBrowserMapping(id, importer, options, isFilePath, externalize
         options,
         void 0,
         void 0,
-        void 0,
-        depsOptimizerOptions
+        void 0
       )?.id : tryFsResolve(path.join(pkg.dir, browserMappedPath), options)) {
         debug$a?.(`[browser mapped] ${colors.cyan(id)} -> ${colors.dim(res)}`);
         let result = { id: res };
@@ -16908,6 +16591,36 @@ function mapWithBrowserField(relativePathInPkgDir, map) {
 function equalWithoutSuffix(path2, key, suffix) {
   return key.endsWith(suffix) && key.slice(0, -suffix.length) === path2;
 }
+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$1(resolved);
+}
+function isDirectory(path2) {
+  const stat = tryStatSync(path2);
+  return stat?.isDirectory() ?? false;
+}
 
 const externalWithConversionNamespace = "vite:dep-pre-bundle:external-conversion";
 const convertedExternalPrefix = "vite-dep-pre-bundle-external:";
@@ -17179,7 +16892,6 @@ function getDefaultResolvedEnvironmentOptions(config) {
     define: config.define,
     resolve: config.resolve,
     consumer: "server",
-    webCompatible: false,
     optimizeDeps: config.optimizeDeps,
     dev: config.dev,
     build: config.build
@@ -18727,7 +18439,6 @@ function createOptimizeDepsIncludeResolver(environment) {
   const resolve = createBackCompatIdResolver(topLevelConfig, {
     asSrc: false,
     scan: true,
-    ssrOptimizeCheck: environment.config.consumer === "server",
     packageCache: /* @__PURE__ */ new Map()
   });
   return async (id) => {
@@ -19195,7 +18906,7 @@ async function prepareEsbuildOptimizerRun(environment, depsInfo, processingCache
       process.env.NODE_ENV || environment.config.mode
     )
   };
-  const platform = environment.config.webCompatible ? "browser" : "node";
+  const platform = environment.config.consumer === "client" ? "browser" : "node";
   const external = [...optimizeDeps2?.exclude ?? []];
   const plugins = [...pluginsFromConfig];
   if (external.length) {
@@ -19262,9 +18973,7 @@ async function addManuallyIncludedOptimizeDeps(environment, deps) {
         const entry = await resolve(id);
         if (entry) {
           if (isOptimizable(entry, optimizeDeps2)) {
-            if (!entry.endsWith("?__vite_skip_optimization")) {
-              deps[normalizedId] = entry;
-            }
+            deps[normalizedId] = entry;
           } else {
             unableToOptimize(id, "Cannot optimize dependency");
           }
@@ -19505,8 +19214,7 @@ function getConfigHash(environment) {
           ...optimizeDeps2?.esbuildOptions,
           plugins: optimizeDeps2?.esbuildOptions?.plugins?.map((p) => p.name)
         }
-      },
-      webCompatible: config.webCompatible
+      }
     },
     (_, value) => {
       if (typeof value === "function" || value instanceof RegExp) {
@@ -19640,6 +19348,7 @@ var index$1 = {
 };
 
 const jsonExtRE = /\.json(?:$|\?)(?!commonjs-(?:proxy|external))/;
+const jsonObjRE = /^\s*\{/;
 const jsonLangs = `\\.(?:json|json5)(?:$|\\?)`;
 const jsonLangRE = new RegExp(jsonLangs);
 const isJSONRequest = (request) => jsonLangRE.test(request);
@@ -19652,31 +19361,29 @@ function jsonPlugin(options = {}, isBuild) {
       json = stripBomTag(json);
       try {
         if (options.stringify !== false) {
-          if (options.namedExports) {
+          if (options.namedExports && jsonObjRE.test(json)) {
             const parsed = JSON.parse(json);
-            if (typeof parsed === "object" && parsed != null) {
-              const keys = Object.keys(parsed);
-              let code = "";
-              let defaultObjectCode = "{\n";
-              for (const key of keys) {
-                if (key === makeLegalIdentifier(key)) {
-                  code += `export const ${key} = ${serializeValue(parsed[key])};
+            const keys = Object.keys(parsed);
+            let code = "";
+            let defaultObjectCode = "{\n";
+            for (const key of keys) {
+              if (key === makeLegalIdentifier(key)) {
+                code += `export const ${key} = ${serializeValue(parsed[key])};
 `;
-                  defaultObjectCode += `  ${key},
+                defaultObjectCode += `  ${key},
 `;
-                } else {
-                  defaultObjectCode += `  ${JSON.stringify(key)}: ${serializeValue(parsed[key])},
+              } else {
+                defaultObjectCode += `  ${JSON.stringify(key)}: ${serializeValue(parsed[key])},
 `;
-                }
               }
-              defaultObjectCode += "}";
-              code += `export default ${defaultObjectCode};
-`;
-              return {
-                code,
-                map: { mappings: "" }
-              };
             }
+            defaultObjectCode += "}";
+            code += `export default ${defaultObjectCode};
+`;
+            return {
+              code,
+              map: { mappings: "" }
+            };
           }
           if (options.stringify === true || // use 10kB as a threshold
           // https://v8.dev/blog/cost-of-javascript-2019#:~:text=A%20good%20rule%20of%20thumb%20is%20to%20apply%20this%20technique%20for%20objects%20of%2010%20kB%20or%20larger
@@ -35791,7 +35498,7 @@ function doesProxyContextMatchUrl(context, url) {
 }
 
 const debug$4 = createDebugger("vite:html-fallback");
-function htmlFallbackMiddleware(root, spaFallback, fsUtils = commonFsUtils) {
+function htmlFallbackMiddleware(root, spaFallback) {
   return function viteHtmlFallbackMiddleware(req, _res, next) {
     if (
       // Only accept GET or HEAD
@@ -35807,14 +35514,14 @@ function htmlFallbackMiddleware(root, spaFallback, fsUtils = commonFsUtils) {
     const pathname = decodeURIComponent(url);
     if (pathname.endsWith(".html")) {
       const filePath = path.join(root, pathname);
-      if (fsUtils.existsSync(filePath)) {
+      if (fs__default.existsSync(filePath)) {
         debug$4?.(`Rewriting ${req.method} ${req.url} to ${url}`);
         req.url = url;
         return next();
       }
     } else if (pathname[pathname.length - 1] === "/") {
       const filePath = path.join(root, pathname, "index.html");
-      if (fsUtils.existsSync(filePath)) {
+      if (fs__default.existsSync(filePath)) {
         const newUrl = url + "index.html";
         debug$4?.(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
         req.url = newUrl;
@@ -35822,7 +35529,7 @@ function htmlFallbackMiddleware(root, spaFallback, fsUtils = commonFsUtils) {
       }
     } else {
       const filePath = path.join(root, pathname + ".html");
-      if (fsUtils.existsSync(filePath)) {
+      if (fs__default.existsSync(filePath)) {
         const newUrl = url + ".html";
         debug$4?.(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
         req.url = newUrl;
@@ -36743,6 +36450,108 @@ async function handleModuleSoftInvalidation(environment, mod, timestamp) {
   return result;
 }
 
+const ALLOWED_META_NAME = [
+  "msapplication-tileimage",
+  "msapplication-square70x70logo",
+  "msapplication-square150x150logo",
+  "msapplication-wide310x150logo",
+  "msapplication-square310x310logo",
+  "msapplication-config",
+  "twitter:image"
+];
+const ALLOWED_META_PROPERTY = [
+  "og:image",
+  "og:image:url",
+  "og:image:secure_url",
+  "og:audio",
+  "og:audio:secure_url",
+  "og:video",
+  "og:video:secure_url"
+];
+const DEFAULT_HTML_ASSET_SOURCES = {
+  audio: {
+    srcAttributes: ["src"]
+  },
+  embed: {
+    srcAttributes: ["src"]
+  },
+  img: {
+    srcAttributes: ["src"],
+    srcsetAttributes: ["srcset"]
+  },
+  image: {
+    srcAttributes: ["href", "xlink:href"]
+  },
+  input: {
+    srcAttributes: ["src"]
+  },
+  link: {
+    srcAttributes: ["href"],
+    srcsetAttributes: ["imagesrcset"]
+  },
+  object: {
+    srcAttributes: ["data"]
+  },
+  source: {
+    srcAttributes: ["src"],
+    srcsetAttributes: ["srcset"]
+  },
+  track: {
+    srcAttributes: ["src"]
+  },
+  use: {
+    srcAttributes: ["href", "xlink:href"]
+  },
+  video: {
+    srcAttributes: ["src", "poster"]
+  },
+  meta: {
+    srcAttributes: ["content"],
+    filter({ attributes }) {
+      if (attributes.name && ALLOWED_META_NAME.includes(attributes.name.trim().toLowerCase())) {
+        return true;
+      }
+      if (attributes.property && ALLOWED_META_PROPERTY.includes(attributes.property.trim().toLowerCase())) {
+        return true;
+      }
+      return false;
+    }
+  }
+};
+function getNodeAssetAttributes(node) {
+  const matched = DEFAULT_HTML_ASSET_SOURCES[node.nodeName];
+  if (!matched) return [];
+  const attributes = {};
+  for (const attr of node.attrs) {
+    attributes[getAttrKey(attr)] = attr.value;
+  }
+  if ("vite-ignore" in attributes) {
+    return [
+      {
+        type: "remove",
+        key: "vite-ignore",
+        value: "",
+        attributes,
+        location: node.sourceCodeLocation.attrs["vite-ignore"]
+      }
+    ];
+  }
+  const actions = [];
+  function handleAttributeKey(key, type) {
+    const value = attributes[key];
+    if (!value) return;
+    if (matched.filter && !matched.filter({ key, value, attributes })) return;
+    const location = node.sourceCodeLocation.attrs[key];
+    actions.push({ type, key, value, attributes, location });
+  }
+  matched.srcAttributes?.forEach((key) => handleAttributeKey(key, "src"));
+  matched.srcsetAttributes?.forEach((key) => handleAttributeKey(key, "srcset"));
+  return actions;
+}
+function getAttrKey(attr) {
+  return attr.prefix === void 0 ? attr.name : `${attr.prefix}:${attr.name}`;
+}
+
 const modulePreloadPolyfillId = "vite/modulepreload-polyfill";
 const resolvedModulePreloadPolyfillId = "\0" + modulePreloadPolyfillId + ".js";
 function modulePreloadPolyfillPlugin(config) {
@@ -36859,14 +36668,6 @@ function addToHTMLProxyCache(config, filePath, index, result) {
 function addToHTMLProxyTransformResult(hash, code) {
   htmlProxyResult.set(hash, code);
 }
-const assetAttrsConfig = {
-  link: ["href"],
-  video: ["src", "poster"],
-  source: ["src", "srcset"],
-  img: ["src", "srcset"],
-  image: ["xlink:href", "href"],
-  use: ["xlink:href", "href"]
-};
 const noInlineLinkRels = /* @__PURE__ */ new Set([
   "icon",
   "apple-touch-icon",
@@ -37120,84 +36921,69 @@ import "${id}?html-proxy&index=${inlineModuleIndex}.js"`;
               }
             }
           }
-          const assetAttrs = assetAttrsConfig[node.nodeName];
-          if (assetAttrs) {
-            const nodeAttrs = {};
-            for (const attr of node.attrs) {
-              nodeAttrs[getAttrKey(attr)] = attr.value;
-            }
-            const shouldIgnore = node.nodeName === "link" && "vite-ignore" in nodeAttrs;
-            if (shouldIgnore) {
-              removeViteIgnoreAttr(s, node.sourceCodeLocation);
-            } else {
-              for (const attrKey in nodeAttrs) {
-                const attrValue = nodeAttrs[attrKey];
-                if (attrValue && assetAttrs.includes(attrKey)) {
-                  if (attrKey === "srcset") {
-                    assetUrlsPromises.push(
-                      (async () => {
-                        const processedEncodedUrl = await processSrcSet(
-                          attrValue,
-                          async ({ url }) => {
-                            const decodedUrl = decodeURI(url);
-                            if (!isExcludedUrl(decodedUrl)) {
-                              const result = await processAssetUrl(url);
-                              return result !== decodedUrl ? encodeURIPath(result) : url;
-                            }
-                            return url;
-                          }
-                        );
-                        if (processedEncodedUrl !== attrValue) {
-                          overwriteAttrValue(
-                            s,
-                            getAttrSourceCodeLocation(node, attrKey),
-                            processedEncodedUrl
-                          );
-                        }
-                      })()
-                    );
-                  } else {
-                    const url = decodeURI(attrValue);
-                    if (checkPublicFile(url, config)) {
-                      overwriteAttrValue(
-                        s,
-                        getAttrSourceCodeLocation(node, attrKey),
-                        partialEncodeURIPath(toOutputPublicFilePath(url))
-                      );
-                    } else if (!isExcludedUrl(url)) {
-                      if (node.nodeName === "link" && isCSSRequest(url) && // should not be converted if following attributes are present (#6748)
-                      !("media" in nodeAttrs || "disabled" in nodeAttrs)) {
-                        const importExpression = `
-import ${JSON.stringify(url)}`;
-                        styleUrls.push({
-                          url,
-                          start: nodeStartWithLeadingWhitespace(node),
-                          end: node.sourceCodeLocation.endOffset
-                        });
-                        js += importExpression;
-                      } else {
-                        const isNoInlineLink = node.nodeName === "link" && nodeAttrs.rel && parseRelAttr(nodeAttrs.rel).some(
-                          (v) => noInlineLinkRels.has(v)
-                        );
-                        const shouldInline = isNoInlineLink ? false : void 0;
-                        assetUrlsPromises.push(
-                          (async () => {
-                            const processedUrl = await processAssetUrl(
-                              url,
-                              shouldInline
-                            );
-                            if (processedUrl !== url) {
-                              overwriteAttrValue(
-                                s,
-                                getAttrSourceCodeLocation(node, attrKey),
-                                partialEncodeURIPath(processedUrl)
-                              );
-                            }
-                          })()
-                        );
+          const assetAttributes = getNodeAssetAttributes(node);
+          for (const attr of assetAttributes) {
+            if (attr.type === "remove") {
+              s.remove(attr.location.startOffset, attr.location.endOffset);
+              continue;
+            } else if (attr.type === "srcset") {
+              assetUrlsPromises.push(
+                (async () => {
+                  const processedEncodedUrl = await processSrcSet(
+                    attr.value,
+                    async ({ url }) => {
+                      const decodedUrl = decodeURI(url);
+                      if (!isExcludedUrl(decodedUrl)) {
+                        const result = await processAssetUrl(url);
+                        return result !== decodedUrl ? encodeURIPath(result) : url;
                       }
+                      return url;
                     }
+                  );
+                  if (processedEncodedUrl !== attr.value) {
+                    overwriteAttrValue(s, attr.location, processedEncodedUrl);
                   }
+                })()
+              );
+            } else if (attr.type === "src") {
+              const url = decodeURI(attr.value);
+              if (checkPublicFile(url, config)) {
+                overwriteAttrValue(
+                  s,
+                  attr.location,
+                  partialEncodeURIPath(toOutputPublicFilePath(url))
+                );
+              } else if (!isExcludedUrl(url)) {
+                if (node.nodeName === "link" && isCSSRequest(url) && // should not be converted if following attributes are present (#6748)
+                !("media" in attr.attributes || "disabled" in attr.attributes)) {
+                  const importExpression = `
+import ${JSON.stringify(url)}`;
+                  styleUrls.push({
+                    url,
+                    start: nodeStartWithLeadingWhitespace(node),
+                    end: node.sourceCodeLocation.endOffset
+                  });
+                  js += importExpression;
+                } else {
+                  const isNoInlineLink = node.nodeName === "link" && attr.attributes.rel && parseRelAttr(attr.attributes.rel).some(
+                    (v) => noInlineLinkRels.has(v)
+                  );
+                  const shouldInline = isNoInlineLink ? false : void 0;
+                  assetUrlsPromises.push(
+                    (async () => {
+                      const processedUrl = await processAssetUrl(
+                        url,
+                        shouldInline
+                      );
+                      if (processedUrl !== url) {
+                        overwriteAttrValue(
+                          s,
+                          attr.location,
+                          partialEncodeURIPath(processedUrl)
+                        );
+                      }
+                    })()
+                  );
                 }
               }
             }
@@ -37868,12 +37654,6 @@ function serializeAttrs(attrs) {
 function incrementIndent(indent = "") {
   return `${indent}${indent[0] === "	" ? "	" : "  "}`;
 }
-function getAttrKey(attr) {
-  return attr.prefix === void 0 ? attr.name : `${attr.prefix}:${attr.name}`;
-}
-function getAttrSourceCodeLocation(node, attrKey) {
-  return node.sourceCodeLocation.attrs[attrKey];
-}
 
 const debugCache = createDebugger("vite:cache");
 const knownIgnoreList = /* @__PURE__ */ new Set(["/", "/favicon.ico"]);
@@ -38156,7 +37936,7 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
   let proxyModulePath;
   let proxyModuleUrl;
   const trailingSlash = htmlPath.endsWith("/");
-  if (!trailingSlash && getFsUtils(config).existsSync(filename)) {
+  if (!trailingSlash && fs__default.existsSync(filename)) {
     proxyModulePath = htmlPath;
     proxyModuleUrl = proxyModulePath;
   } else {
@@ -38210,7 +37990,8 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
       } else if (src) {
         const processedUrl = processNodeUrl(
           src.value,
-          getAttrKey(src) === "srcset",
+          /* useSrcSetReplacer */
+          false,
           config,
           htmlPath,
           originalUrl,
@@ -38259,34 +38040,20 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
         code: children.value
       });
     }
-    const assetAttrs = assetAttrsConfig[node.nodeName];
-    if (assetAttrs) {
-      const nodeAttrs = {};
-      for (const attr of node.attrs) {
-        nodeAttrs[getAttrKey(attr)] = attr.value;
-      }
-      const shouldIgnore = node.nodeName === "link" && "vite-ignore" in nodeAttrs;
-      if (shouldIgnore) {
-        removeViteIgnoreAttr(s, node.sourceCodeLocation);
+    const assetAttributes = getNodeAssetAttributes(node);
+    for (const attr of assetAttributes) {
+      if (attr.type === "remove") {
+        s.remove(attr.location.startOffset, attr.location.endOffset);
       } else {
-        for (const attrKey in nodeAttrs) {
-          const attrValue = nodeAttrs[attrKey];
-          if (attrValue && assetAttrs.includes(attrKey)) {
-            const processedUrl = processNodeUrl(
-              attrValue,
-              attrKey === "srcset",
-              config,
-              htmlPath,
-              originalUrl
-            );
-            if (processedUrl !== attrValue) {
-              overwriteAttrValue(
-                s,
-                node.sourceCodeLocation.attrs[attrKey],
-                processedUrl
-              );
-            }
-          }
+        const processedUrl = processNodeUrl(
+          attr.value,
+          attr.type === "srcset",
+          config,
+          htmlPath,
+          originalUrl
+        );
+        if (processedUrl !== attr.value) {
+          overwriteAttrValue(s, attr.location, processedUrl);
         }
       }
     }
@@ -38351,7 +38118,6 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
 };
 function indexHtmlMiddleware(root, server) {
   const isDev = isDevServer(server);
-  const fsUtils = getFsUtils(server.config);
   return async function viteIndexHtmlMiddleware(req, res, next) {
     if (res.writableEnded) {
       return next();
@@ -38364,7 +38130,7 @@ function indexHtmlMiddleware(root, server) {
       } else {
         filePath = path.join(root, decodeURIComponent(url));
       }
-      if (fsUtils.existsSync(filePath)) {
+      if (fs__default.existsSync(filePath)) {
         const headers = isDev ? server.config.server.headers : server.config.preview.headers;
         try {
           let html = await fsp.readFile(filePath, "utf-8");
@@ -39044,7 +38810,8 @@ async function _createServer(inlineConfig = {}, options) {
   }
   const watcher = chokidar.watch(
     // config file dependencies and env file might be outside of root
-    [
+    // eslint-disable-next-line eqeqeq -- null means disabled
+    serverConfig.watch === null ? [] : [
       root,
       ...config.configFileDependencies,
       ...getEnvFilesForMode(config.mode, config.envDir),
@@ -39058,6 +38825,7 @@ async function _createServer(inlineConfig = {}, options) {
     watcher.add = function() {
       return this;
     };
+    await watcher.close();
   }
   const environments = {};
   for (const [name, environmentOptions] of Object.entries(
@@ -39315,7 +39083,6 @@ async function _createServer(inlineConfig = {}, options) {
     }
     await onHMRUpdate("update", file);
   });
-  getFsUtils(config).initWatcher?.(watcher);
   watcher.on("add", (file) => {
     onFileAddUnlink(file, false);
   });
@@ -39362,13 +39129,7 @@ async function _createServer(inlineConfig = {}, options) {
   middlewares.use(serveRawFsMiddleware(server));
   middlewares.use(serveStaticMiddleware(server));
   if (config.appType === "spa" || config.appType === "mpa") {
-    middlewares.use(
-      htmlFallbackMiddleware(
-        root,
-        config.appType === "spa",
-        getFsUtils(config)
-      )
-    );
+    middlewares.use(htmlFallbackMiddleware(root, config.appType === "spa"));
   }
   postHooks.forEach((fn) => fn && fn());
   if (config.appType === "spa" || config.appType === "mpa") {
@@ -39501,8 +39262,7 @@ function resolveServerOptions(root, raw, logger) {
   server.fs = {
     strict: server.fs?.strict ?? true,
     allow: allowDirs,
-    deny,
-    cachedChecks: server.fs?.cachedChecks
+    deny
   };
   if (server.origin?.endsWith("/")) {
     server.origin = server.origin.slice(0, -1);
@@ -40236,6 +39996,7 @@ function definePlugin(config) {
     importMetaFallbackKeys["import.meta.env"] = `undefined`;
   }
   function generatePattern(environment) {
+    const keepProcessEnv = environment.config.keepProcessEnv;
     const userDefine = {};
     const userDefineEnv = {};
     for (const key in environment.config.define) {
@@ -40244,9 +40005,8 @@ function definePlugin(config) {
         userDefineEnv[key.slice(16)] = environment.config.define[key];
       }
     }
-    const replaceProcessEnv = environment.config.webCompatible;
     const define = {
-      ...replaceProcessEnv ? processEnv : {},
+      ...keepProcessEnv ? {} : processEnv,
       ...importMetaKeys,
       ...userDefine,
       ...importMetaFallbackKeys
@@ -40264,7 +40024,7 @@ function definePlugin(config) {
       ...userDefineEnv
     });
     const patternKeys = Object.keys(userDefine);
-    if (replaceProcessEnv && Object.keys(processEnv).length) {
+    if (!keepProcessEnv && Object.keys(processEnv).length) {
       patternKeys.push("process.env");
     }
     if (Object.keys(importMetaKeys).length) {
@@ -40743,7 +40503,6 @@ function isSameContent(a, b) {
 function preAliasPlugin(config) {
   const findPatterns = getAliasPatterns(config.resolve.alias);
   const isBuild = config.command === "build";
-  const fsUtils = getFsUtils(config);
   return {
     name: "vite:pre-alias",
     async resolveId(id, importer, options) {
@@ -40770,7 +40529,7 @@ function preAliasPlugin(config) {
             const optimizeDeps = depsOptimizer.options;
             const resolvedId = cleanUrl(resolved.id);
             const isVirtual = resolvedId === id || resolvedId.includes("\0");
-            if (!isVirtual && fsUtils.existsSync(resolvedId) && !moduleListContains(optimizeDeps.exclude, id) && path.isAbsolute(resolvedId) && (isInNodeModules$1(resolvedId) || optimizeDeps.include?.includes(id)) && isOptimizable(resolvedId, optimizeDeps) && !(isBuild && ssr && isConfiguredAsExternal(environment, id, importer)) && (!ssr || optimizeAliasReplacementForSSR(resolvedId, optimizeDeps))) {
+            if (!isVirtual && fs__default.existsSync(resolvedId) && !moduleListContains(optimizeDeps.exclude, id) && path.isAbsolute(resolvedId) && (isInNodeModules$1(resolvedId) || optimizeDeps.include?.includes(id)) && isOptimizable(resolvedId, optimizeDeps) && !(isBuild && ssr && isConfiguredAsExternal(environment, id, importer)) && (!ssr || optimizeAliasReplacementForSSR(resolvedId, optimizeDeps))) {
               const optimizedInfo = depsOptimizer.registerMissingImport(
                 id,
                 resolvedId
@@ -40831,13 +40590,12 @@ function isExplicitImportRequired(url) {
 function normalizeResolvedIdToUrl(environment, url, resolved) {
   const root = environment.config.root;
   const depsOptimizer = environment.depsOptimizer;
-  const fsUtils = getFsUtils(environment.getTopLevelConfig());
   if (resolved.id.startsWith(withTrailingSlash(root))) {
     url = resolved.id.slice(root.length);
   } else if (depsOptimizer?.isOptimizedDepFile(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.isAbsolute(resolved.id) && fsUtils.existsSync(cleanUrl(resolved.id))) {
+  resolved.id !== "/@react-refresh" && path.isAbsolute(resolved.id) && fs__default.existsSync(cleanUrl(resolved.id))) {
     url = path.posix.join(FS_PREFIX, resolved.id);
   } else {
     url = resolved.id;
@@ -41768,7 +41526,7 @@ function assetImportMetaUrlPlugin(config) {
             const templateLiteral = ast.body[0].expression;
             if (templateLiteral.expressions.length) {
               const pattern = buildGlobPattern(templateLiteral);
-              if (pattern.startsWith("**")) {
+              if (pattern.startsWith("*")) {
                 continue;
               }
               const globOptions = {
@@ -41843,19 +41601,17 @@ ${rawExp} doesn't exist at build time, it will remain unchanged to be resolved a
 }
 function buildGlobPattern(ast) {
   let pattern = "";
-  let lastElementIndex = -1;
-  for (const exp of ast.expressions) {
-    for (let i = lastElementIndex + 1; i < ast.quasis.length; i++) {
-      const el = ast.quasis[i];
-      if (el.end < exp.start) {
-        pattern += el.value.raw;
-        lastElementIndex = i;
-      }
+  let lastIsGlob = false;
+  for (let i = 0; i < ast.quasis.length; i++) {
+    const str = ast.quasis[i].value.raw;
+    if (str) {
+      pattern += str;
+      lastIsGlob = false;
+    }
+    if (ast.expressions[i] && !lastIsGlob) {
+      pattern += "*";
+      lastIsGlob = true;
     }
-    pattern += "**";
-  }
-  for (let i = lastElementIndex + 1; i < ast.quasis.length; i++) {
-    pattern += ast.quasis[i].value.raw;
   }
   return pattern;
 }
@@ -42213,7 +41969,6 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
         isBuild,
         packageCache: config.packageCache,
         asSrc: true,
-        fsUtils: getFsUtils(config),
         optimizeDeps: true,
         externalize: true
       },
@@ -43010,7 +42765,6 @@ function createIdResolver(config, options) {
             preferRelative: false,
             tryIndex: true,
             ...options,
-            fsUtils: getFsUtils(config),
             // Ignore sideEffects and other computations as we only need the id
             idOnly: true
           })
@@ -43195,7 +42949,6 @@ function cssPostPlugin(config) {
   let pureCssChunks;
   let hasEmitted = false;
   let chunkCSSMap;
-  let cssBundleName;
   const rollupOptionsOutput = config.build.rollupOptions.output;
   const assetFileNames = (Array.isArray(rollupOptionsOutput) ? rollupOptionsOutput[0] : rollupOptionsOutput)?.assetFileNames;
   const getCssAssetDirname = (cssAssetName) => {
@@ -43217,6 +42970,17 @@ function cssPostPlugin(config) {
       );
     }
   };
+  function getCssBundleName() {
+    const cached = cssBundleNameCache.get(config);
+    if (cached) return cached;
+    const cssBundleName = config.build.lib ? resolveLibCssFilename(
+      config.build.lib,
+      config.root,
+      config.packageCache
+    ) : defaultCssBundleName;
+    cssBundleNameCache.set(config, cssBundleName);
+    return cssBundleName;
+  }
   return {
     name: "vite:css-post",
     renderStart() {
@@ -43224,12 +42988,6 @@ function cssPostPlugin(config) {
       hasEmitted = false;
       chunkCSSMap = /* @__PURE__ */ new Map();
       codeSplitEmitQueue = createSerialPromiseQueue();
-      cssBundleName = config.build.lib ? resolveLibCssFilename(
-        config.build.lib,
-        config.root,
-        config.packageCache
-      ) : defaultCssBundleName;
-      cssBundleNameCache.set(config, cssBundleName);
     },
     async transform(css, id) {
       if (!isCSSRequest(id) || commonjsProxyRE.test(id) || SPECIAL_QUERY_RE.test(id)) {
@@ -43495,7 +43253,7 @@ function cssPostPlugin(config) {
             s.appendRight(injectionPoint, injectCode);
           }
         } else {
-          chunkCSS = resolveAssetUrlsInCss(chunkCSS, cssBundleName);
+          chunkCSS = resolveAssetUrlsInCss(chunkCSS, getCssBundleName());
           chunkCSSMap.set(chunk.fileName, chunkCSS);
         }
       }
@@ -43524,7 +43282,7 @@ function cssPostPlugin(config) {
       if (opts.__vite_skip_asset_emit__) {
         return;
       }
-      if (!config.build.cssCodeSplit && !hasEmitted) {
+      if (!this.environment.config.build.cssCodeSplit && !hasEmitted) {
         let collect2 = function(chunk) {
           if (!chunk || chunk.type !== "chunk" || collected.has(chunk)) return;
           collected.add(chunk);
@@ -43549,7 +43307,7 @@ function cssPostPlugin(config) {
           hasEmitted = true;
           extractedCss = await finalizeCss(extractedCss, true, config);
           this.emitFile({
-            name: cssBundleName,
+            name: getCssBundleName(),
             type: "asset",
             source: extractedCss
           });
@@ -43669,7 +43427,7 @@ function createCSSResolvers(config) {
       return cssResolve ??= createBackCompatIdResolver(config, {
         extensions: [".css"],
         mainFields: ["style"],
-        conditions: ["style"],
+        conditions: ["style", DEV_PROD_CONDITION],
         tryIndex: false,
         preferRelative: true
       });
@@ -43679,7 +43437,7 @@ function createCSSResolvers(config) {
         const resolver = createBackCompatIdResolver(config, {
           extensions: [".scss", ".sass", ".css"],
           mainFields: ["sass", "style"],
-          conditions: ["sass", "style"],
+          conditions: ["sass", "style", DEV_PROD_CONDITION],
           tryIndex: true,
           tryPrefix: "_",
           preferRelative: true
@@ -43697,7 +43455,7 @@ function createCSSResolvers(config) {
       return lessResolve ??= createBackCompatIdResolver(config, {
         extensions: [".less", ".css"],
         mainFields: ["less", "style"],
-        conditions: ["less", "style"],
+        conditions: ["less", "style", DEV_PROD_CONDITION],
         tryIndex: false,
         preferRelative: true
       });
@@ -43989,8 +43747,8 @@ function createCachedImport(imp) {
     return cached;
   };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-C35rJP-t.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-BLM335V-.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-DUn1iy3F.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-qU9-vqRp.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 const preprocessorWorkerControllerCache = /* @__PURE__ */ new WeakMap();
 let alwaysFakeWorkerWorkerControllerCache;
@@ -44082,9 +43840,9 @@ ${stack}`;
   postcssConfigCache.set(config, result);
   return result;
 }
-const cssUrlRE = /(?<=^|[^\w\-\u0080-\uffff])url\((\s*('[^']+'|"[^"]+")\s*|[^'")]+)\)/;
+const cssUrlRE = /(?<!@import\s+)(?<=^|[^\w\-\u0080-\uffff])url\((\s*('[^']+'|"[^"]+")\s*|[^'")]+)\)/;
 const cssDataUriRE = /(?<=^|[^\w\-\u0080-\uffff])data-uri\((\s*('[^']+'|"[^"]+")\s*|[^'")]+)\)/;
-const importCssRE = /@import ('[^']+\.css'|"[^"]+\.css"|[^'")]+\.css)/;
+const importCssRE = /@import\s+(?:url\()?('[^']+\.css'|"[^"]+\.css"|[^'"\s)]+\.css)/;
 const cssImageSetRE = /(?<=image-set\()((?:[\w-]{1,256}\([^)]*\)|[^)])*)(?=\))/;
 const UrlRewritePostcssPlugin = (opts) => {
   if (!opts) {
@@ -44193,7 +43951,8 @@ async function doImportCSSReplace(rawUrl, matched, replacer) {
   if (isExternalUrl(rawUrl) || isDataUrl(rawUrl) || rawUrl[0] === "#") {
     return matched;
   }
-  return `@import ${wrap}${await replacer(rawUrl)}${wrap}`;
+  const prefix = matched.includes("url(") ? "url(" : "";
+  return `@import ${prefix}${wrap}${await replacer(rawUrl)}${wrap}`;
 }
 async function minifyCSS(css, config, inlined) {
   if (config.build.cssMinify === "lightningcss") {
@@ -44631,6 +44390,11 @@ const scssProcessor = (maxWorkers) => {
         e.message = `[sass] ${e.message}`;
         e.id = e.file;
         e.frame = e.formatted;
+        if (e.span?.start) {
+          e.line = e.span.start.line + 1;
+          e.column = e.span.start.column + 1;
+          e.frame = e.message;
+        }
         return { code: "", error: e, deps: [] };
       }
     }
@@ -45780,7 +45544,7 @@ function completeSystemWrapPlugin() {
   };
 }
 
-function resolveBuildEnvironmentOptions(raw, logger, consumer) {
+function resolveBuildEnvironmentOptions(raw, logger, consumer, isSsrTargetWebworkerEnvironment) {
   const deprecatedPolyfillModulePreload = raw?.polyfillModulePreload;
   const { polyfillModulePreload, ...rest } = raw;
   raw = rest;
@@ -45854,6 +45618,17 @@ function resolveBuildEnvironmentOptions(raw, logger, consumer) {
   if (resolved.cssMinify == null) {
     resolved.cssMinify = consumer === "server" ? "esbuild" : !!resolved.minify;
   }
+  if (isSsrTargetWebworkerEnvironment) {
+    resolved.rollupOptions ??= {};
+    resolved.rollupOptions.output ??= {};
+    const output = resolved.rollupOptions.output;
+    for (const out of arraify(output)) {
+      out.entryFileNames ??= `[name].js`;
+      out.chunkFileNames ??= `[name]-[hash].js`;
+      const input = resolved.rollupOptions.input;
+      out.inlineDynamicImports ??= !input || typeof input === "string" || Object.keys(input).length === 1;
+    }
+  }
   return resolved;
 }
 async function resolveBuildPlugins(config) {
@@ -46022,7 +45797,7 @@ ${stackOnly}`;
         );
       }
       const format = output.format || "es";
-      const jsExt = !environment.config.webCompatible || libOptions ? resolveOutputJsExtension(
+      const jsExt = environment.config.consumer === "server" || libOptions ? resolveOutputJsExtension(
         format,
         findNearestPackageData(root, packageCache)?.data.type
       ) : "js";
@@ -46048,7 +45823,7 @@ ${stackOnly}`;
         ) : path.posix.join(options.assetsDir, `[name]-[hash].${jsExt}`),
         chunkFileNames: libOptions ? `[name]-[hash].${jsExt}` : path.posix.join(options.assetsDir, `[name]-[hash].${jsExt}`),
         assetFileNames: libOptions ? `[name].[ext]` : path.posix.join(options.assetsDir, `[name]-[hash].[ext]`),
-        inlineDynamicImports: output.format === "umd" || output.format === "iife" || environment.config.consumer === "server" && environment.config.webCompatible && (typeof input === "string" || Object.keys(input).length === 1),
+        inlineDynamicImports: output.format === "umd" || output.format === "iife",
         ...output
       };
     };
@@ -46659,19 +46434,17 @@ async function fetchModule(environment, url, importer, options = {}) {
     const { externalConditions, dedupe, preserveSymlinks } = environment.config.resolve;
     const resolved = tryNodeResolve(url, importer, {
       mainFields: ["main"],
-      conditions: [],
+      conditions: externalConditions,
       externalConditions,
       external: [],
       noExternal: [],
-      overrideConditions: [...externalConditions, "production", "development"],
       extensions: [".js", ".cjs", ".json"],
       dedupe,
       preserveSymlinks,
       isBuild: false,
       isProduction,
       root,
-      packageCache: environment.config.packageCache,
-      webCompatible: environment.config.webCompatible
+      packageCache: environment.config.packageCache
     });
     if (!resolved) {
       const err = new Error(
@@ -48324,20 +48097,23 @@ function resolveDevEnvironmentOptions(dev, environmentName, consumer, skipSsrTra
     moduleRunnerTransform: dev?.moduleRunnerTransform ?? (skipSsrTransform !== void 0 && consumer === "server" ? skipSsrTransform : consumer === "server")
   };
 }
-function resolveEnvironmentOptions(options, alias, preserveSymlinks, logger, environmentName, skipSsrTransform) {
+function resolveEnvironmentOptions(options, alias, preserveSymlinks, logger, environmentName, skipSsrTransform, ssrTargetWebworker) {
+  const isClientEnvironment = environmentName === "client";
+  const consumer = options.consumer ?? (isClientEnvironment ? "client" : "server");
+  const isSsrTargetWebworkerEnvironment = ssrTargetWebworker && environmentName === "ssr";
   const resolve = resolveEnvironmentResolveOptions(
     options.resolve,
     alias,
     preserveSymlinks,
-    logger
+    logger,
+    consumer,
+    isSsrTargetWebworkerEnvironment
   );
-  const isClientEnvironment = environmentName === "client";
-  const consumer = options.consumer ?? (isClientEnvironment ? "client" : "server");
   return {
     define: options.define,
     resolve,
+    keepProcessEnv: options.keepProcessEnv ?? (isSsrTargetWebworkerEnvironment ? false : consumer === "server"),
     consumer,
-    webCompatible: options.webCompatible ?? consumer === "client",
     optimizeDeps: resolveDepOptimizationOptions(
       options.optimizeDeps,
       resolve.preserveSymlinks,
@@ -48352,14 +48128,20 @@ function resolveEnvironmentOptions(options, alias, preserveSymlinks, logger, env
     build: resolveBuildEnvironmentOptions(
       options.build ?? {},
       logger,
-      consumer
+      consumer,
+      isSsrTargetWebworkerEnvironment
     )
   };
 }
 function getDefaultEnvironmentOptions(config) {
   return {
     define: config.define,
-    resolve: config.resolve,
+    resolve: {
+      ...config.resolve,
+      // mainFields and conditions are not inherited
+      mainFields: void 0,
+      conditions: void 0
+    },
     dev: config.dev,
     build: config.build
   };
@@ -48394,12 +48176,14 @@ const clientAlias = [
     replacement: path.posix.join(FS_PREFIX, normalizePath$1(CLIENT_ENTRY))
   }
 ];
-function resolveEnvironmentResolveOptions(resolve, alias, preserveSymlinks, logger) {
+function resolveEnvironmentResolveOptions(resolve, alias, preserveSymlinks, logger, consumer, isSsrTargetWebworkerEnvironment) {
+  let conditions = resolve?.conditions;
+  conditions ??= consumer === "client" || isSsrTargetWebworkerEnvironment ? DEFAULT_CONDITIONS.filter((c) => c !== "node") : DEFAULT_CONDITIONS.filter((c) => c !== "browser");
   const resolvedResolve = {
     mainFields: resolve?.mainFields ?? DEFAULT_MAIN_FIELDS,
-    conditions: resolve?.conditions ?? [],
-    externalConditions: resolve?.externalConditions ?? [],
-    external: resolve?.external ?? [],
+    conditions,
+    externalConditions: resolve?.externalConditions ?? DEFAULT_EXTERNAL_CONDITIONS,
+    external: resolve?.external ?? (consumer === "server" && !isSsrTargetWebworkerEnvironment ? builtinModules : []),
     noExternal: resolve?.noExternal ?? [],
     extensions: resolve?.extensions ?? DEFAULT_EXTENSIONS,
     dedupe: resolve?.dedupe ?? [],
@@ -48425,7 +48209,8 @@ function resolveResolveOptions(resolve, logger) {
     resolve,
     alias,
     preserveSymlinks,
-    logger
+    logger,
+    void 0
   );
 }
 function resolveDepOptimizationOptions(optimizeDeps, preserveSymlinks, consumer) {
@@ -48532,9 +48317,6 @@ async function resolveConfig(inlineConfig, command, defaultMode = "development",
     configEnvironmentsSsr.resolve.externalConditions ??= config.ssr?.resolve?.externalConditions;
     configEnvironmentsSsr.resolve.external ??= config.ssr?.external;
     configEnvironmentsSsr.resolve.noExternal ??= config.ssr?.noExternal;
-    if (config.ssr?.target === "webworker") {
-      configEnvironmentsSsr.webCompatible = true;
-    }
   }
   if (config.build?.ssrEmitAssets !== void 0) {
     configEnvironmentsSsr ??= {};
@@ -48549,13 +48331,16 @@ async function resolveConfig(inlineConfig, command, defaultMode = "development",
   const defaultEnvironmentOptions = getDefaultEnvironmentOptions(config);
   const defaultClientEnvironmentOptions = {
     ...defaultEnvironmentOptions,
+    resolve: config.resolve,
+    // inherit everything including mainFields and conditions
     optimizeDeps: config.optimizeDeps
   };
   const defaultNonClientEnvironmentOptions = {
     ...defaultEnvironmentOptions,
     dev: {
       ...defaultEnvironmentOptions.dev,
-      createEnvironment: void 0
+      createEnvironment: void 0,
+      warmup: void 0
     },
     build: {
       ...defaultEnvironmentOptions.build,
@@ -48578,7 +48363,8 @@ async function resolveConfig(inlineConfig, command, defaultMode = "development",
       resolvedDefaultResolve.preserveSymlinks,
       logger,
       environmentName,
-      config.experimental?.skipSsrTransform
+      config.experimental?.skipSsrTransform,
+      config.ssr?.target === "webworker"
     );
   }
   const backwardCompatibleOptimizeDeps = resolvedEnvironments.client.optimizeDeps;
@@ -48980,17 +48766,15 @@ async function bundleConfigFile(fileName, isESM) {
               preferRelative: false,
               tryIndex: true,
               mainFields: [],
-              conditions: [],
+              conditions: ["node"],
               externalConditions: [],
               external: [],
               noExternal: [],
-              overrideConditions: ["node"],
               dedupe: [],
               extensions: DEFAULT_EXTENSIONS,
               preserveSymlinks: false,
               packageCache,
-              isRequire,
-              webCompatible: false
+              isRequire
             })?.id;
           };
           build2.onResolve(
@@ -49066,14 +48850,22 @@ async function bundleConfigFile(fileName, isESM) {
 const _require = createRequire(import.meta.url);
 async function loadConfigFromBundledFile(fileName, bundledCode, isESM) {
   if (isESM) {
-    const fileBase = `${fileName}.timestamp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    const fileNameTmp = `${fileBase}.mjs`;
-    const fileUrl = `${pathToFileURL(fileBase)}.mjs`;
-    await fsp.writeFile(fileNameTmp, bundledCode);
+    const nodeModulesDir = findNearestNodeModules(path.dirname(fileName));
+    if (nodeModulesDir) {
+      await fsp.mkdir(path.resolve(nodeModulesDir, ".vite-temp/"), {
+        recursive: true
+      });
+    }
+    const hash = `timestamp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const tempFileName = nodeModulesDir ? path.resolve(
+      nodeModulesDir,
+      `.vite-temp/${path.basename(fileName)}.${hash}.mjs`
+    ) : `${fileName}.${hash}.mjs`;
+    await fsp.writeFile(tempFileName, bundledCode);
     try {
-      return (await import(fileUrl)).default;
+      return (await import(pathToFileURL(tempFileName).href)).default;
     } finally {
-      fs__default.unlink(fileNameTmp, () => {
+      fs__default.unlink(tempFileName, () => {
       });
     }
   } else {