vite 6.0.10 → 6.1.0-beta.0

package/dist/node/chunks/{dep-DP_yvx5y.js → dep-B8FkPgo5.js}

@@ -1,14 +1,14 @@
 import * as fs$8 from 'node:fs';
 import fs__default, { promises as promises$1, existsSync as existsSync$1, readFileSync as readFileSync$1 } from 'node:fs';
-import fsp, { constants as constants$9 } from 'node:fs/promises';
 import path$d, { posix as posix$1, isAbsolute as isAbsolute$1, join as join$1, resolve as resolve$4, normalize, dirname as dirname$2, relative as relative$2, basename as basename$2, extname as extname$1 } from 'node:path';
+import fsp, { constants as constants$9 } from 'node:fs/promises';
 import require$$1$1, { fileURLToPath as fileURLToPath$1, URL as URL$3, pathToFileURL as pathToFileURL$1 } from 'node:url';
 import { promisify as promisify$4, format as format$2, inspect, stripVTControlCharacters } from 'node:util';
 import { performance } from 'node:perf_hooks';
 import require$$0$6, { createRequire as createRequire$1, builtinModules } from 'node:module';
 import crypto$2 from 'node:crypto';
 import esbuild, { transform as transform$1, formatMessages, build as build$b } from 'esbuild';
-import { CLIENT_ENTRY, OPTIMIZABLE_ENTRY_RE, wildcardHosts, loopbackHosts, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, DEFAULT_ASSETS_INLINE_LIMIT, ENV_ENTRY, DEP_VERSION_RE, SPECIAL_QUERY_RE, DEV_PROD_CONDITION, JS_TYPES_RE, KNOWN_ASSET_TYPES, CSS_LANGS_RE, METADATA_FILENAME, ESBUILD_MODULES_TARGET, ERR_OPTIMIZE_DEPS_PROCESSING_ERROR, ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR, VITE_PACKAGE_DIR, DEFAULT_DEV_PORT, CLIENT_DIR, VERSION, ROLLUP_HOOKS, DEFAULT_PREVIEW_PORT, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES, DEFAULT_CLIENT_MAIN_FIELDS, DEFAULT_SERVER_MAIN_FIELDS, DEFAULT_CLIENT_CONDITIONS, DEFAULT_SERVER_CONDITIONS } 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, DEP_VERSION_RE, SPECIAL_QUERY_RE, DEV_PROD_CONDITION, JS_TYPES_RE, KNOWN_ASSET_TYPES, CSS_LANGS_RE, METADATA_FILENAME, ESBUILD_MODULES_TARGET, ERR_OPTIMIZE_DEPS_PROCESSING_ERROR, ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR, VITE_PACKAGE_DIR, DEFAULT_DEV_PORT, defaultAllowedOrigins, CLIENT_DIR, VERSION, ROLLUP_HOOKS, DEFAULT_PREVIEW_PORT, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES, DEFAULT_CLIENT_MAIN_FIELDS, DEFAULT_SERVER_MAIN_FIELDS, DEFAULT_CLIENT_CONDITIONS, DEFAULT_SERVER_CONDITIONS } from '../constants.js';
 import require$$0$2, { posix, win32, isAbsolute, resolve as resolve$3, relative as relative$1, basename as basename$1, extname, dirname as dirname$1, join, sep } from 'path';
 import require$$0$3, { existsSync, readFileSync, statSync, readdirSync } from 'fs';
 import childProcess$2, { exec, execFile, execSync } from 'node:child_process';
@@ -9619,10 +9619,32 @@ const NODE_BUILTIN_NAMESPACE = "node:";
 const NPM_BUILTIN_NAMESPACE = "npm:";
 const BUN_BUILTIN_NAMESPACE = "bun:";
 const nodeBuiltins = builtinModules.filter((id) => !id.includes(":"));
-function isBuiltin(id) {
-  if (process.versions.deno && id.startsWith(NPM_BUILTIN_NAMESPACE)) return true;
-  if (process.versions.bun && id.startsWith(BUN_BUILTIN_NAMESPACE)) return true;
-  return isNodeBuiltin(id);
+const isBuiltinCache = /* @__PURE__ */ new WeakMap();
+function isBuiltin(builtins, id) {
+  let isBuiltin2 = isBuiltinCache.get(builtins);
+  if (!isBuiltin2) {
+    isBuiltin2 = createIsBuiltin(builtins);
+    isBuiltinCache.set(builtins, isBuiltin2);
+  }
+  return isBuiltin2(id);
+}
+function createIsBuiltin(builtins) {
+  const plainBuiltinsSet = new Set(
+    builtins.filter((builtin) => typeof builtin === "string")
+  );
+  const regexBuiltins = builtins.filter(
+    (builtin) => typeof builtin !== "string"
+  );
+  return (id) => plainBuiltinsSet.has(id) || regexBuiltins.some((regexp) => regexp.test(id));
+}
+const nodeLikeBuiltins = [
+  ...nodeBuiltins,
+  new RegExp(`^${NODE_BUILTIN_NAMESPACE}`),
+  new RegExp(`^${NPM_BUILTIN_NAMESPACE}`),
+  new RegExp(`^${BUN_BUILTIN_NAMESPACE}`)
+];
+function isNodeLikeBuiltin(id) {
+  return isBuiltin(nodeLikeBuiltins, id);
 }
 function isNodeBuiltin(id) {
   if (id.startsWith(NODE_BUILTIN_NAMESPACE)) return true;
@@ -9729,8 +9751,6 @@ const isJSRequest = (url) => {
   }
   return false;
 };
-const knownTsRE = /\.(?:ts|mts|cts|tsx)(?:$|\?)/;
-const isTsRequest = (url) => knownTsRE.test(url);
 const importQueryRE = /(\?|&)import=?(?:&|$)/;
 const directRequestRE$1 = /(\?|&)direct=?(?:&|$)/;
 const internalPrefixes = [
@@ -10285,7 +10305,7 @@ function deepClone(value) {
     return value;
   }
   if (value instanceof RegExp) {
-    return structuredClone(value);
+    return new RegExp(value);
   }
   if (typeof value === "object" && value != null) {
     throw new Error("Cannot deep clone non-plain object");
@@ -10713,7 +10733,7 @@ const groups = [
   { name: "CSS", color: colors$1.magenta },
   { name: "JS", color: colors$1.cyan }
 ];
-const COMPRESSIBLE_ASSETS_RE = /\.(?:html|json|svg|txt|xml|xhtml)$/;
+const COMPRESSIBLE_ASSETS_RE = /\.(?:html|json|svg|txt|xml|xhtml|wasm)$/;
 function buildReporterPlugin(config) {
   const compress = promisify$4(gzip);
   const numberFormatter = new Intl.NumberFormat("en", {
@@ -13388,6 +13408,7 @@ function registerCustomMime() {
   mimes["cur"] = "image/x-icon";
   mimes["flac"] = "audio/flac";
   mimes["eot"] = "application/vnd.ms-fontobject";
+  mimes["jxl"] = "image/jxl";
 }
 function renderAssetUrlInJS(pluginContext, chunk, opts, code) {
   const { environment } = pluginContext;
@@ -15970,7 +15991,7 @@ function createIsExternal(environment) {
     }
     let isExternal = false;
     if (id[0] !== "." && !path$d.isAbsolute(id)) {
-      isExternal = isBuiltin(id) || isConfiguredAsExternal2(id, importer);
+      isExternal = isBuiltin(environment.config.resolve.builtins, id) || isConfiguredAsExternal2(id, importer);
     }
     processedIds.set(id, isExternal);
     return isExternal;
@@ -16021,14 +16042,6 @@ function resolvePlugin(resolveOptions) {
           return normalizePath$3(path$d.join(root, id));
         }
       }
-      if (importer) {
-        if (isTsRequest(importer) || resolveOpts.custom?.depScan?.loader?.startsWith("ts")) {
-          options.isFromTsImporter = true;
-        } else {
-          const moduleLang = this.getModuleInfo(importer)?.meta.vite?.lang;
-          options.isFromTsImporter = moduleLang && isTsRequest(`.${moduleLang}`);
-        }
-      }
       let res;
       if (asSrc && depsOptimizer?.isOptimizedDepUrl(id)) {
         const optimizedPath = id.startsWith(FS_PREFIX) ? fsPathFromId(id) : normalizePath$3(path$d.resolve(root, id.slice(1)));
@@ -16127,34 +16140,45 @@ function resolvePlugin(resolveOptions) {
         if (res = tryNodeResolve(id, importer, options, depsOptimizer, external)) {
           return res;
         }
-        if (isBuiltin(id)) {
-          if (currentEnvironmentOptions.consumer === "server") {
-            if (options.enableBuiltinNoExternalCheck && 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}"`;
-              if (importer) {
-                message += ` imported from "${path$d.relative(
-                  process.cwd(),
-                  importer
-                )}"`;
-              }
-              message += `. Consider disabling environments.${this.environment.name}.noExternal or remove the built-in dependency.`;
-              this.error(message);
+        if (currentEnvironmentOptions.consumer === "server" && isBuiltin(options.builtins, id)) {
+          return options.idOnly ? id : { id, external: true, moduleSideEffects: false };
+        } else if (currentEnvironmentOptions.consumer === "server" && isNodeLikeBuiltin(id)) {
+          if (!(options.external === true || options.external.includes(id))) {
+            let message = `Automatically externalized node built-in module "${id}"`;
+            if (importer) {
+              message += ` imported from "${path$d.relative(
+                process.cwd(),
+                importer
+              )}"`;
             }
-            return options.idOnly ? id : { id, external: true, moduleSideEffects: false };
-          } else {
-            if (!asSrc) {
-              debug$e?.(
-                `externalized node built-in "${id}" to empty module. (imported by: ${colors$1.white(colors$1.dim(importer))})`
-              );
-            } else if (isProduction) {
-              this.warn(
-                `Module "${id}" has been externalized for browser compatibility, imported by "${importer}". See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`
-              );
+            message += `. Consider adding it to environments.${this.environment.name}.external if it is intended.`;
+            this.error(message);
+          }
+          return options.idOnly ? id : { id, external: true, moduleSideEffects: false };
+        } else if (currentEnvironmentOptions.consumer === "client" && isNodeLikeBuiltin(id)) {
+          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 built-in module "${id}"`;
+            if (importer) {
+              message += ` imported from "${path$d.relative(
+                process.cwd(),
+                importer
+              )}"`;
             }
-            return isProduction ? browserExternalId : `${browserExternalId}:${id}`;
+            message += `. Consider disabling environments.${this.environment.name}.noExternal or remove the built-in dependency.`;
+            this.error(message);
           }
+          if (!asSrc) {
+            debug$e?.(
+              `externalized node built-in "${id}" to empty module. (imported by: ${colors$1.white(colors$1.dim(importer))})`
+            );
+          } else if (isProduction) {
+            this.warn(
+              `Module "${id}" has been externalized for browser compatibility, imported by "${importer}". See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`
+            );
+          }
+          return isProduction ? browserExternalId : `${browserExternalId}:${id}`;
         }
       }
       debug$e?.(`[fallthrough] ${colors$1.dim(id)}`);
@@ -16237,7 +16261,7 @@ function tryCleanFsResolve(file, options, tryIndex = true, skipPackageJson = fal
   const fileResult = tryResolveRealFileOrType(file, options.preserveSymlinks);
   if (fileResult?.path) return fileResult.path;
   let res;
-  const possibleJsToTs = options.isFromTsImporter && isPossibleTsOutput(file);
+  const possibleJsToTs = isPossibleTsOutput(file);
   if (possibleJsToTs || options.extensions.length || tryPrefix) {
     const dirPath = path$d.dirname(file);
     if (isDirectory(dirPath)) {
@@ -16316,15 +16340,16 @@ function tryNodeResolve(id, importer, options, depsOptimizer, externalize) {
   } else {
     basedir = root;
   }
+  const isModuleBuiltin = (id2) => isBuiltin(options.builtins, id2);
   let selfPkg = null;
-  if (!isBuiltin(id) && !id.includes("\0") && bareImportRE.test(id)) {
+  if (!isModuleBuiltin(id) && !id.includes("\0") && bareImportRE.test(id)) {
     const selfPackageData = findNearestPackageData(basedir, packageCache);
     selfPkg = selfPackageData?.data.exports && selfPackageData.data.name === pkgId ? selfPackageData : null;
   }
   const pkg = selfPkg || resolvePackageData(pkgId, basedir, preserveSymlinks, packageCache);
   if (!pkg) {
     if (basedir !== root && // root has no peer dep
-    !isBuiltin(id) && !id.includes("\0") && bareImportRE.test(id)) {
+    !isModuleBuiltin(id) && !id.includes("\0") && bareImportRE.test(id)) {
       const mainPkg = findNearestMainPackageData(basedir, packageCache)?.data;
       if (mainPkg) {
         const pkgName = getNpmPackageName(id);
@@ -16720,7 +16745,7 @@ function esbuildDepPlugin(environment, qualified, external) {
         namespace: "optional-peer-dep"
       };
     }
-    if (environment.config.consumer === "server" && isBuiltin(resolved)) {
+    if (isBuiltin(environment.config.resolve.builtins, resolved)) {
       return;
     }
     if (isExternalUrl(resolved)) {
@@ -18184,22 +18209,19 @@ const svelteScriptModuleRE = /\bcontext\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+)
 const svelteModuleRE = /\smodule\b/i;
 function esbuildScanPlugin(environment, depImports, missing, entries) {
   const seen = /* @__PURE__ */ new Map();
-  async function resolveId(id, importer, options) {
+  async function resolveId(id, importer) {
     return environment.pluginContainer.resolveId(
       id,
       importer && normalizePath$3(importer),
-      {
-        ...options,
-        scan: true
-      }
+      { scan: true }
     );
   }
-  const resolve = async (id, importer, options) => {
+  const resolve = async (id, importer) => {
     const key = id + (importer && path$d.dirname(importer));
     if (seen.has(key)) {
       return seen.get(key);
     }
-    const resolved = await resolveId(id, importer, options);
+    const resolved = await resolveId(id, importer);
     const res = resolved?.id;
     seen.set(key, res);
     return res;
@@ -18357,18 +18379,14 @@ function esbuildScanPlugin(environment, depImports, missing, entries) {
           // avoid matching windows volume
           filter: /^[\w@][^:]/
         },
-        async ({ path: id, importer, pluginData }) => {
+        async ({ path: id, importer }) => {
           if (moduleListContains(exclude, id)) {
             return externalUnlessEntry({ path: id });
           }
           if (depImports[id]) {
             return externalUnlessEntry({ path: id });
           }
-          const resolved = await resolve(id, importer, {
-            custom: {
-              depScan: { loader: pluginData?.htmlType?.loader }
-            }
-          });
+          const resolved = await resolve(id, importer);
           if (resolved) {
             if (shouldExternalizeDep(resolved, id)) {
               return externalUnlessEntry({ path: id });
@@ -18411,12 +18429,8 @@ function esbuildScanPlugin(environment, depImports, missing, entries) {
         {
           filter: /.*/
         },
-        async ({ path: id, importer, pluginData }) => {
-          const resolved = await resolve(id, importer, {
-            custom: {
-              depScan: { loader: pluginData?.htmlType?.loader }
-            }
-          });
+        async ({ path: id, importer }) => {
+          const resolved = await resolve(id, importer);
           if (resolved) {
             if (shouldExternalizeDep(resolved, id) || !isScannable(resolved, optimizeDepsOptions.extensions)) {
               return externalUnlessEntry({ path: id });
@@ -18689,21 +18703,33 @@ async function loadCachedDepOptimizationMetadata(environment, force = environmen
     if (cachedMetadata) {
       if (cachedMetadata.lockfileHash !== getLockfileHash(environment)) {
         environment.logger.info(
-          "Re-optimizing dependencies because lockfile has changed"
+          "Re-optimizing dependencies because lockfile has changed",
+          {
+            timestamp: true
+          }
         );
       } else if (cachedMetadata.configHash !== getConfigHash(environment)) {
         environment.logger.info(
-          "Re-optimizing dependencies because vite config has changed"
+          "Re-optimizing dependencies because vite config has changed",
+          {
+            timestamp: true
+          }
         );
       } else {
-        log?.("Hash is consistent. Skipping. Use --force to override.");
+        log?.(
+          `(${environment.name}) Hash is consistent. Skipping. Use --force to override.`
+        );
         return cachedMetadata;
       }
     }
   } else {
-    environment.logger.info("Forced re-optimization of dependencies");
+    environment.logger.info("Forced re-optimization of dependencies", {
+      timestamp: true
+    });
   }
-  debug$c?.(colors$1.green(`removing old cache dir ${depsCacheDir}`));
+  debug$c?.(
+    `(${environment.name}) ${colors$1.green(`removing old cache dir ${depsCacheDir}`)}`
+  );
   await fsp.rm(depsCacheDir, { recursive: true, force: true });
 }
 function discoverProjectDependencies(environment) {
@@ -19293,7 +19319,11 @@ const lockfileFormats = [
     manager: "pnpm"
   },
   {
-    name: "bun.lockb",
+    path: "bun.lock",
+    checkPatchesDir: "patches",
+    manager: "bun"
+  },
+  {
     path: "bun.lockb",
     checkPatchesDir: "patches",
     manager: "bun"
@@ -31371,14 +31401,19 @@ Object.defineProperty(${ssrModuleExportsKey}, "default", { enumerable: true, con
       }
     }
   });
-  let map = s.generateMap({ hires: "boundary" });
-  map.sources = [path$d.basename(url)];
-  map.sourcesContent = [originalCode];
-  if (inMap && inMap.mappings && "sources" in inMap && inMap.sources.length > 0) {
-    map = combineSourcemaps(url, [
-      map,
-      inMap
-    ]);
+  let map;
+  if (inMap?.mappings === "") {
+    map = inMap;
+  } else {
+    map = s.generateMap({ hires: "boundary" });
+    map.sources = [path$d.basename(url)];
+    map.sourcesContent = [originalCode];
+    if (inMap && inMap.mappings && "sources" in inMap && inMap.sources.length > 0) {
+      map = combineSourcemaps(url, [
+        map,
+        inMap
+      ]);
+    }
   }
   return {
     code: s.toString(),
@@ -37670,7 +37705,8 @@ function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
 
 var WebSocketServerRaw_ = /*@__PURE__*/getDefaultExportFromCjs(websocketServer);
 
-const allowedHostsCache = /* @__PURE__ */ new WeakMap();
+const allowedHostsServerCache = /* @__PURE__ */ new WeakMap();
+const allowedHostsPreviewCache = /* @__PURE__ */ new WeakMap();
 const isFileOrExtensionProtocolRE = /^(?:file|.+-extension):/i;
 function getAdditionalAllowedHosts(resolvedServerOptions, resolvedPreviewOptions) {
   const list = [];
@@ -37727,39 +37763,42 @@ function isHostAllowedWithoutCache(allowedHosts, additionalAllowedHosts, host) {
   }
   return false;
 }
-function isHostAllowed(config, host) {
-  if (config.server.allowedHosts === true) {
+function isHostAllowed(config, isPreview, host) {
+  const allowedHosts = isPreview ? config.preview.allowedHosts : config.server.allowedHosts;
+  if (allowedHosts === true) {
     return true;
   }
-  if (!allowedHostsCache.has(config)) {
-    allowedHostsCache.set(config, /* @__PURE__ */ new Set());
+  const cache = isPreview ? allowedHostsPreviewCache : allowedHostsServerCache;
+  if (!cache.has(config)) {
+    cache.set(config, /* @__PURE__ */ new Set());
   }
-  const allowedHosts = allowedHostsCache.get(config);
-  if (allowedHosts.has(host)) {
+  const cachedAllowedHosts = cache.get(config);
+  if (cachedAllowedHosts.has(host)) {
     return true;
   }
   const result = isHostAllowedWithoutCache(
-    config.server.allowedHosts,
+    allowedHosts,
     config.additionalAllowedHosts,
     host
   );
   if (result) {
-    allowedHosts.add(host);
+    cachedAllowedHosts.add(host);
   }
   return result;
 }
-function hostCheckMiddleware(config) {
+function hostCheckMiddleware(config, isPreview) {
   return function viteHostCheckMiddleware(req, res, next) {
     const hostHeader = req.headers.host;
-    if (!hostHeader || !isHostAllowed(config, hostHeader)) {
+    if (!hostHeader || !isHostAllowed(config, isPreview, hostHeader)) {
       const hostname = hostHeader?.replace(/:\d+$/, "");
       const hostnameWithQuotes = JSON.stringify(hostname);
+      const optionName = `${isPreview ? "preview" : "server"}.allowedHosts`;
       res.writeHead(403, {
         "Content-Type": "text/plain"
       });
       res.end(
         `Blocked request. This host (${hostnameWithQuotes}) is not allowed.
-To allow this host, add ${hostnameWithQuotes} to \`server.allowedHosts\` in vite.config.js.`
+To allow this host, add ${hostnameWithQuotes} to \`${optionName}\` in vite.config.js.`
       );
       return;
     }
@@ -37780,7 +37819,7 @@ const wsServerEvents = [
   "listening",
   "message"
 ];
-function noop$3() {
+function noop$2() {
 }
 function hasValidToken(config, url) {
   const token = url.searchParams.get("token");
@@ -37804,9 +37843,9 @@ function createWebSocketServer(server, config, httpsOptions) {
       },
       async close() {
       },
-      on: noop$3,
-      off: noop$3,
-      setInvokeHandler: noop$3,
+      on: noop$2,
+      off: noop$2,
+      setInvokeHandler: noop$2,
       handleInvoke: async () => ({
         error: {
           name: "TransportError",
@@ -37814,8 +37853,8 @@ function createWebSocketServer(server, config, httpsOptions) {
           stack: new Error().stack
         }
       }),
-      listen: noop$3,
-      send: noop$3
+      listen: noop$2,
+      send: noop$2
     };
   }
   let wsHttpServer = undefined;
@@ -37833,7 +37872,7 @@ function createWebSocketServer(server, config, httpsOptions) {
     const protocol = req.headers["sec-websocket-protocol"];
     if (protocol === "vite-ping") return true;
     const hostHeader = req.headers.host;
-    if (!hostHeader || !isHostAllowed(config, hostHeader)) {
+    if (!hostHeader || !isHostAllowed(config, false, hostHeader)) {
       return false;
     }
     if (config.legacy?.skipWebSocketTokenCheck) {
@@ -38977,7 +39016,7 @@ var WriteAfterEndError = createErrorType(
 );
 
 // istanbul ignore next
-var destroy = Writable.prototype.destroy || noop$2;
+var destroy = Writable.prototype.destroy || noop$1;
 
 // An HTTP(S) request that can be redirected
 function RedirectableRequest(options, responseCallback) {
@@ -39461,7 +39500,7 @@ function wrap(protocols) {
   return exports;
 }
 
-function noop$2() { /* empty */ }
+function noop$1() { /* empty */ }
 
 function parseUrl(input) {
   var parsed;
@@ -39557,7 +39596,7 @@ function destroyRequest(request, error) {
   for (var event of events) {
     request.removeListener(event, eventHandlers[event]);
   }
-  request.on("error", noop$2);
+  request.on("error", noop$1);
   request.destroy(error);
 }
 
@@ -40307,21 +40346,34 @@ ${err.stack}`,
     proxies[context] = [proxy, { ...opts }];
   });
   if (httpServer) {
-    httpServer.on("upgrade", (req, socket, head) => {
+    httpServer.on("upgrade", async (req, socket, head) => {
       const url = req.url;
       for (const context in proxies) {
         if (doesProxyContextMatchUrl(context, url)) {
           const [proxy, opts] = proxies[context];
           if (opts.ws || opts.target?.toString().startsWith("ws:") || opts.target?.toString().startsWith("wss:")) {
             if (opts.bypass) {
-              const bypassResult = opts.bypass(req, undefined, opts);
-              if (typeof bypassResult === "string") {
-                req.url = bypassResult;
-                debug$5?.(`bypass: ${req.url} -> ${bypassResult}`);
-                return;
-              } else if (bypassResult === false) {
-                debug$5?.(`bypass: ${req.url} -> 404`);
-                socket.end("HTTP/1.1 404 Not Found\r\n\r\n", "");
+              try {
+                const bypassResult = await opts.bypass(req, undefined, opts);
+                if (typeof bypassResult === "string") {
+                  debug$5?.(`bypass: ${req.url} -> ${bypassResult}`);
+                  req.url = bypassResult;
+                  return;
+                }
+                if (bypassResult === false) {
+                  debug$5?.(`bypass: ${req.url} -> 404`);
+                  socket.end("HTTP/1.1 404 Not Found\r\n\r\n", "");
+                  return;
+                }
+              } catch (err) {
+                config.logger.error(
+                  `${colors$1.red(`ws proxy bypass error:`)}
+${err.stack}`,
+                  {
+                    timestamp: true,
+                    error: err
+                  }
+                );
                 return;
               }
             }
@@ -40336,22 +40388,28 @@ ${err.stack}`,
       }
     });
   }
-  return function viteProxyMiddleware(req, res, next) {
+  return async function viteProxyMiddleware(req, res, next) {
     const url = req.url;
     for (const context in proxies) {
       if (doesProxyContextMatchUrl(context, url)) {
         const [proxy, opts] = proxies[context];
         const options2 = {};
         if (opts.bypass) {
-          const bypassResult = opts.bypass(req, res, opts);
-          if (typeof bypassResult === "string") {
-            req.url = bypassResult;
-            debug$5?.(`bypass: ${req.url} -> ${bypassResult}`);
-            return next();
-          } else if (bypassResult === false) {
-            debug$5?.(`bypass: ${req.url} -> 404`);
-            res.statusCode = 404;
-            return res.end();
+          try {
+            const bypassResult = await opts.bypass(req, res, opts);
+            if (typeof bypassResult === "string") {
+              debug$5?.(`bypass: ${req.url} -> ${bypassResult}`);
+              req.url = bypassResult;
+              return next();
+            }
+            if (bypassResult === false) {
+              debug$5?.(`bypass: ${req.url} -> 404`);
+              res.statusCode = 404;
+              return res.end();
+            }
+          } catch (e) {
+            debug$5?.(`bypass: ${req.url} -> ${e}`);
+            return next(e);
           }
         }
         debug$5?.(`${req.url} -> ${opts.target || opts.forward}`);
@@ -40659,7 +40717,7 @@ function parse(req) {
 	return req._parsedUrl = { pathname, search, query, raw };
 }
 
-const noop$1 = () => {};
+const noop = () => {};
 
 function isMatch(uri, arr) {
 	for (let i=0; i < arr.length; i++) {
@@ -40775,7 +40833,7 @@ function sirv (dir, opts={}) {
 	dir = resolve$4(dir || '.');
 
 	let isNotFound = opts.onNoMatch || is404;
-	let setHeaders = opts.setHeaders || noop$1;
+	let setHeaders = opts.setHeaders || noop;
 
 	let extensions = opts.extensions || ['html', 'htm'];
 	let gzips = opts.gzip && extensions.map(x => `${x}.gz`).concat('gz');
@@ -44033,7 +44091,7 @@ async function _createServer(inlineConfig = {}, options) {
   }
   const { allowedHosts } = serverConfig;
   if (allowedHosts !== true && !serverConfig.https) {
-    middlewares.use(hostCheckMiddleware(config));
+    middlewares.use(hostCheckMiddleware(config, false));
   }
   middlewares.use(cachedTransformMiddleware(server));
   const { proxy } = serverConfig;
@@ -44159,7 +44217,7 @@ const serverConfigDefaults = Object.freeze({
   https: undefined,
   open: false,
   proxy: undefined,
-  cors: false,
+  cors: { origin: defaultAllowedOrigins },
   headers: {},
   // hmr
   // ws
@@ -44237,9 +44295,7 @@ async function restartServer(server) {
   let inlineConfig = server.config.inlineConfig;
   if (server._forceOptimizeOnRestart) {
     inlineConfig = mergeConfig(inlineConfig, {
-      optimizeDeps: {
-        force: true
-      }
+      forceOptimizeDeps: true
     });
   }
   {
@@ -44782,7 +44838,9 @@ function propagateUpdate(node, traversedModules, boundaries, currentChain = [nod
     if (!node.importers.size) {
       return true;
     }
-    if (!isCSSRequest(node.url) && [...node.importers].every((i) => isCSSRequest(i.url))) {
+    if (!isCSSRequest(node.url) && // we assume .svg is never an entrypoint and does not need a full reload
+    // to avoid frequent full reloads when an SVG file is referenced in CSS files (#18979)
+    !node.file?.endsWith(".svg") && [...node.importers].every((i) => isCSSRequest(i.url))) {
       return true;
     }
   }
@@ -45246,8 +45304,8 @@ async function bundleWorkerEntry(config, id) {
     plugins: workerEnvironment.plugins.map(
       (p) => injectEnvironmentToHooks(workerEnvironment, p)
     ),
-    onwarn(warning, warn) {
-      onRollupWarning(warning, warn, workerEnvironment);
+    onLog(level, log) {
+      onRollupLog(level, log, workerEnvironment);
     },
     preserveEntrySignatures: false
   });
@@ -45807,7 +45865,7 @@ function importAnalysisPlugin(config) {
         });
         if (!resolved || resolved.meta?.["vite:alias"]?.noResolved) {
           if (ssr) {
-            return [url, url];
+            return [url, null];
           }
           importerModule.isSelfAccepting = false;
           moduleGraph._hasResolveFailedErrorModules.add(importerModule);
@@ -45833,21 +45891,21 @@ function importAnalysisPlugin(config) {
               url = injectQuery(url, versionMatch[1]);
             }
           }
-          try {
-            const depModule = await moduleGraph._ensureEntryFromUrl(
-              unwrapId$1(url),
-              canSkipImportAnalysis(url) || forceSkipImportAnalysis,
-              resolved
-            );
-            if (depModule.lastHMRTimestamp > 0) {
-              url = injectQuery(url, `t=${depModule.lastHMRTimestamp}`);
-            }
-          } catch (e) {
-            e.pos = pos;
-            throw e;
+        }
+        try {
+          const depModule = await moduleGraph._ensureEntryFromUrl(
+            unwrapId$1(url),
+            canSkipImportAnalysis(url) || forceSkipImportAnalysis,
+            resolved
+          );
+          if (environment.config.consumer === "client" && depModule.lastHMRTimestamp > 0) {
+            url = injectQuery(url, `t=${depModule.lastHMRTimestamp}`);
           }
-          if (!ssr) url = joinUrlSegments(base, url);
+        } catch (e) {
+          e.pos = pos;
+          throw e;
         }
+        if (!ssr) url = joinUrlSegments(base, url);
         return [url, resolved.id];
       };
       const orderedImportedUrls = new Array(imports.length);
@@ -45915,7 +45973,7 @@ function importAnalysisPlugin(config) {
               if (shouldExternalize(environment, specifier, importer)) {
                 return;
               }
-              if (isBuiltin(specifier)) {
+              if (isBuiltin(environment.config.resolve.builtins, specifier)) {
                 return;
               }
             }
@@ -45930,7 +45988,8 @@ function importAnalysisPlugin(config) {
                 )} instead.`
               );
             }
-            const [url, resolvedId] = await normalizeUrl(specifier, start);
+            let [url, resolvedId] = await normalizeUrl(specifier, start);
+            resolvedId = resolvedId || url;
             config.safeModulePaths.add(fsPathFromUrl(stripBase(url, base)));
             if (url !== specifier) {
               let rewriteDone = false;
@@ -46065,9 +46124,37 @@ See ${colors$1.blue(
       }
       const normalizedAcceptedUrls = /* @__PURE__ */ new Set();
       for (const { url, start, end } of acceptedUrls) {
-        const [normalized] = await moduleGraph.resolveUrl(toAbsoluteUrl(url));
+        let [normalized, resolvedId] = await normalizeUrl(url, start).catch(
+          () => []
+        );
+        if (resolvedId) {
+          const mod = moduleGraph.getModuleById(resolvedId);
+          if (!mod) {
+            this.error(
+              `module was not found for ${JSON.stringify(resolvedId)}`,
+              start
+            );
+            return;
+          }
+          normalized = mod.url;
+        } else {
+          try {
+            const [resolved] = await moduleGraph.resolveUrl(toAbsoluteUrl(url));
+            normalized = resolved;
+            if (resolved) {
+              this.warn({
+                message: `Failed to resolve ${JSON.stringify(url)} from ${importer}. An id should be written. Did you pass a URL?`,
+                pos: start
+              });
+            }
+          } catch {
+            this.error(`Failed to resolve ${JSON.stringify(url)}`, start);
+            return;
+          }
+        }
         normalizedAcceptedUrls.add(normalized);
-        str().overwrite(start, end, JSON.stringify(normalized), {
+        const hmrAccept = normalizeHmrUrl(normalized);
+        str().overwrite(start, end, JSON.stringify(hmrAccept), {
           contentOnly: true
         });
       }
@@ -46427,13 +46514,62 @@ function err(e, pos) {
   error.pos = pos;
   return error;
 }
-function parseWorkerOptions(rawOpts, optsStartIndex) {
+function findClosingParen(input, fromIndex) {
+  let count = 1;
+  for (let i = fromIndex + 1; i < input.length; i++) {
+    if (input[i] === "(") count++;
+    if (input[i] === ")") count--;
+    if (count === 0) return i;
+  }
+  return -1;
+}
+function extractWorkerTypeFromAst(expression, optsStartIndex) {
+  if (expression.type !== "ObjectExpression") {
+    return;
+  }
+  let lastSpreadElementIndex = -1;
+  let typeProperty = null;
+  let typePropertyIndex = -1;
+  for (let i = 0; i < expression.properties.length; i++) {
+    const property = expression.properties[i];
+    if (property.type === "SpreadElement") {
+      lastSpreadElementIndex = i;
+      continue;
+    }
+    if (property.type === "Property" && (property.key.type === "Identifier" && property.key.name === "type" || property.key.type === "Literal" && property.key.value === "type")) {
+      typeProperty = property;
+      typePropertyIndex = i;
+    }
+  }
+  if (typePropertyIndex === -1 && lastSpreadElementIndex === -1) {
+    return "classic";
+  }
+  if (typePropertyIndex < lastSpreadElementIndex) {
+    throw err(
+      "Expected object spread to be used before the definition of the type property. Vite needs a static value for the type property to correctly infer it.",
+      optsStartIndex
+    );
+  }
+  if (typeProperty?.value.type !== "Literal") {
+    throw err(
+      "Expected worker options type property to be a literal value.",
+      optsStartIndex
+    );
+  }
+  return typeProperty?.value.value === "module" ? "module" : "classic";
+}
+async function parseWorkerOptions(rawOpts, optsStartIndex) {
   let opts = {};
   try {
     opts = evalValue(rawOpts);
   } catch {
+    const optsNode = (await parseAstAsync(`(${rawOpts})`)).body[0].expression;
+    const type = extractWorkerTypeFromAst(optsNode, optsStartIndex);
+    if (type) {
+      return { type };
+    }
     throw err(
-      "Vite is unable to parse the worker options as the value is not static.To ignore this error, please use /* @vite-ignore */ in the worker options.",
+      "Vite is unable to parse the worker options as the value is not static. To ignore this error, please use /* @vite-ignore */ in the worker options.",
       optsStartIndex
     );
   }
@@ -46448,12 +46584,12 @@ function parseWorkerOptions(rawOpts, optsStartIndex) {
   }
   return opts;
 }
-function getWorkerType(raw, clean, i) {
+async function getWorkerType(raw, clean, i) {
   const commaIndex = clean.indexOf(",", i);
   if (commaIndex === -1) {
     return "classic";
   }
-  const endIndex = clean.indexOf(")", i);
+  const endIndex = findClosingParen(clean, i);
   if (commaIndex > endIndex) {
     return "classic";
   }
@@ -46466,7 +46602,7 @@ function getWorkerType(raw, clean, i) {
   if (!cleanWorkerOptString.length) {
     return "classic";
   }
-  const workerOpts = parseWorkerOptions(workerOptString, commaIndex + 1);
+  const workerOpts = await parseWorkerOptions(workerOptString, commaIndex + 1);
   if (workerOpts.type && (workerOpts.type === "module" || workerOpts.type === "classic")) {
     return workerOpts.type;
   }
@@ -46512,12 +46648,12 @@ function workerImportMetaUrlPlugin(config) {
             );
           }
           s ||= new MagicString(code);
-          const workerType = getWorkerType(code, cleanString, endIndex);
+          const workerType = await getWorkerType(code, cleanString, endIndex);
           const url = rawUrl.slice(1, -1);
           let file;
           if (url[0] === ".") {
             file = path$d.resolve(path$d.dirname(id), url);
-            file = tryFsResolve(file, fsResolveOptions) ?? file;
+            file = slash$1(tryFsResolve(file, fsResolveOptions) ?? file);
           } else {
             workerResolver ??= createBackCompatIdResolver(config, {
               extensions: [],
@@ -47109,8 +47245,6 @@ const viteAliasCustomResolver = async function(id, importer, options) {
   return resolved || { id, meta: { "vite:alias": { noResolved: true } } };
 };
 
-const noop = () => {
-};
 const EMPTY_OBJECT = Object.freeze({});
 const debugSourcemapCombineFilter = process.env.DEBUG_VITE_SOURCEMAP_COMBINE_FILTER;
 const debugSourcemapCombine = createDebugger("vite:sourcemap-combine", {
@@ -47123,6 +47257,9 @@ const debugPluginResolve = createDebugger("vite:plugin-resolve", {
 const debugPluginTransform = createDebugger("vite:plugin-transform", {
   onlyWhenFocused: "vite:plugin"
 });
+const debugPluginContainerContext = createDebugger(
+  "vite:plugin-container-context"
+);
 const ERR_CLOSED_SERVER = "ERR_CLOSED_SERVER";
 function throwClosedServerError() {
   const err = new Error(
@@ -47148,18 +47285,10 @@ class EnvironmentPluginContainer {
     this.environment = environment;
     this.plugins = plugins;
     this.watcher = watcher;
-    this.minimalContext = {
-      meta: {
-        rollupVersion,
-        watchMode: true
-      },
-      debug: noop,
-      info: noop,
-      warn: noop,
-      // @ts-expect-error noop
-      error: noop,
+    this.minimalContext = new MinimalPluginContext(
+      { rollupVersion, watchMode: true },
       environment
-    };
+    );
     const utils = createPluginHookUtils(plugins);
     this.getSortedPlugins = utils.getSortedPlugins;
     this.getSortedPluginHooks = utils.getSortedPluginHooks;
@@ -47450,12 +47579,44 @@ class EnvironmentPluginContainer {
     );
   }
 }
-class PluginContext {
+class MinimalPluginContext {
+  constructor(meta, environment) {
+    this.meta = meta;
+    this.environment = environment;
+  }
+  debug(rawLog) {
+    const log = this._normalizeRawLog(rawLog);
+    const msg = buildErrorMessage(log, [`debug: ${log.message}`], false);
+    debugPluginContainerContext?.(msg);
+  }
+  info(rawLog) {
+    const log = this._normalizeRawLog(rawLog);
+    const msg = buildErrorMessage(log, [`info: ${log.message}`], false);
+    this.environment.logger.info(msg, { clear: true, timestamp: true });
+  }
+  warn(rawLog) {
+    const log = this._normalizeRawLog(rawLog);
+    const msg = buildErrorMessage(
+      log,
+      [colors$1.yellow(`warning: ${log.message}`)],
+      false
+    );
+    this.environment.logger.warn(msg, { clear: true, timestamp: true });
+  }
+  error(e) {
+    const err = typeof e === "string" ? new Error(e) : e;
+    throw err;
+  }
+  _normalizeRawLog(rawLog) {
+    const logValue = typeof rawLog === "function" ? rawLog() : rawLog;
+    return typeof logValue === "string" ? new Error(logValue) : logValue;
+  }
+}
+class PluginContext extends MinimalPluginContext {
   constructor(_plugin, _container) {
+    super(_container.minimalContext.meta, _container.environment);
     this._plugin = _plugin;
     this._container = _container;
-    this.environment = this._container.environment;
-    this.meta = this._container.minimalContext.meta;
   }
   ssr = false;
   _scan = false;
@@ -47463,8 +47624,6 @@ class PluginContext {
   _activeCode = null;
   _resolveSkips;
   _resolveSkipCalls;
-  meta;
-  environment;
   parse(code, opts) {
     return parseAst(code, opts);
   }
@@ -47549,24 +47708,25 @@ class PluginContext {
     this._warnIncompatibleMethod(`getFileName`);
     return "";
   }
-  warn(e, position) {
-    const err = this._formatError(typeof e === "function" ? e() : e, position);
-    const msg = buildErrorMessage(
-      err,
-      [colors$1.yellow(`warning: ${err.message}`)],
-      false
+  debug(log) {
+    const err = this._formatLog(typeof log === "function" ? log() : log);
+    super.debug(err);
+  }
+  info(log) {
+    const err = this._formatLog(typeof log === "function" ? log() : log);
+    super.info(err);
+  }
+  warn(log, position) {
+    const err = this._formatLog(
+      typeof log === "function" ? log() : log,
+      position
     );
-    this.environment.logger.warn(msg, {
-      clear: true,
-      timestamp: true
-    });
+    super.warn(err);
   }
   error(e, position) {
-    throw this._formatError(e, position);
+    throw this._formatLog(e, position);
   }
-  debug = noop;
-  info = noop;
-  _formatError(e, position) {
+  _formatLog(e, position) {
     const err = typeof e === "string" ? new Error(e) : e;
     if (err.pluginCode) {
       return err;
@@ -47995,20 +48155,20 @@ function cssPlugin(config) {
         return;
       }
       const resolveUrl = (url, importer) => idResolver(environment, url, importer);
-      const urlReplacer = async (url, importer) => {
+      const urlResolver = async (url, importer) => {
         const decodedUrl = decodeURI(url);
         if (checkPublicFile(decodedUrl, config)) {
           if (encodePublicUrlsInCSS(config)) {
-            return publicFileToBuiltUrl(decodedUrl, config);
+            return [publicFileToBuiltUrl(decodedUrl, config), undefined];
           } else {
-            return joinUrlSegments(config.base, decodedUrl);
+            return [joinUrlSegments(config.base, decodedUrl), undefined];
           }
         }
         const [id2, fragment] = decodedUrl.split("#");
         let resolved = await resolveUrl(id2, importer);
         if (resolved) {
           if (fragment) resolved += "#" + fragment;
-          return fileToUrl$1(this, resolved);
+          return [await fileToUrl$1(this, resolved), resolved];
         }
         if (config.command === "build") {
           const isExternal = config.build.rollupOptions.external ? resolveUserExternal(
@@ -48025,7 +48185,7 @@ ${decodedUrl} referenced in ${id2} didn't resolve at build time, it will remain
             );
           }
         }
-        return url;
+        return [url, undefined];
       };
       const {
         code: css,
@@ -48037,7 +48197,7 @@ ${decodedUrl} referenced in ${id2} didn't resolve at build time, it will remain
         id,
         raw,
         preprocessorWorkerController,
-        urlReplacer
+        urlResolver
       );
       if (modules) {
         moduleCache.set(id, modules);
@@ -48493,16 +48653,21 @@ function cssAnalysisPlugin(config) {
         if (pluginImports) {
           const depModules = /* @__PURE__ */ new Set();
           for (const file of pluginImports) {
-            depModules.add(
-              isCSSRequest(file) ? moduleGraph.createFileOnlyEntry(file) : await moduleGraph.ensureEntryFromUrl(
-                await fileToDevUrl(
-                  this.environment,
-                  file,
-                  /* skipBase */
-                  true
-                )
-              )
-            );
+            if (isCSSRequest(file)) {
+              depModules.add(moduleGraph.createFileOnlyEntry(file));
+            } else {
+              const url = await fileToDevUrl(
+                this.environment,
+                file,
+                /* skipBase */
+                true
+              );
+              if (url.startsWith("data:")) {
+                depModules.add(moduleGraph.createFileOnlyEntry(file));
+              } else {
+                depModules.add(await moduleGraph.ensureEntryFromUrl(url));
+              }
+            }
           }
           moduleGraph.updateModuleInfo(
             thisModule,
@@ -48645,23 +48810,12 @@ function getAtImportResolvers(config) {
   }
   return atImportResolvers;
 }
-async function compileCSS(environment, id, code, workerController, urlReplacer) {
+async function compileCSS(environment, id, code, workerController, urlResolver) {
   const { config } = environment;
   if (config.css.transformer === "lightningcss") {
-    return compileLightningCSS(id, code, environment, urlReplacer);
+    return compileLightningCSS(id, code, environment, urlResolver);
   }
-  const { modules: modulesOptions, devSourcemap } = config.css;
-  const isModule = modulesOptions !== false && cssModuleRE.test(id);
-  const needInlineImport = code.includes("@import");
-  const hasUrl = cssUrlRE.test(code) || cssImageSetRE.test(code);
   const lang = CSS_LANGS_RE.exec(id)?.[1];
-  const postcssConfig = await resolvePostcssConfig(
-    environment.getTopLevelConfig()
-  );
-  if (lang === "css" && !postcssConfig && !isModule && !needInlineImport && !hasUrl) {
-    return { code, map: null };
-  }
-  let modules;
   const deps = /* @__PURE__ */ new Set();
   let preprocessorMap;
   if (isPreProcessor(lang)) {
@@ -48676,10 +48830,19 @@ async function compileCSS(environment, id, code, workerController, urlReplacer)
     preprocessorMap = preprocessorResult.map;
     preprocessorResult.deps?.forEach((dep) => deps.add(dep));
   }
+  const { modules: modulesOptions, devSourcemap } = config.css;
+  const isModule = modulesOptions !== false && cssModuleRE.test(id);
+  const needInlineImport = code.includes("@import");
+  const hasUrl = cssUrlRE.test(code) || cssImageSetRE.test(code);
+  const postcssConfig = await resolvePostcssConfig(
+    environment.getTopLevelConfig()
+  );
+  if (lang !== "sss" && !postcssConfig && !isModule && !needInlineImport && !hasUrl) {
+    return { code, map: preprocessorMap ?? null, deps };
+  }
   const atImportResolvers = getAtImportResolvers(
     environment.getTopLevelConfig()
   );
-  const postcssOptions = postcssConfig?.options ?? {};
   const postcssPlugins = postcssConfig?.plugins.slice() ?? [];
   if (needInlineImport) {
     postcssPlugins.unshift(
@@ -48731,14 +48894,19 @@ async function compileCSS(environment, id, code, workerController, urlReplacer)
       })
     );
   }
-  if (urlReplacer) {
+  if (urlResolver && // if there's an @import, we need to add this plugin
+  // regradless of whether it contains url() or image-set(),
+  // because we don't know the content referenced by @import
+  (needInlineImport || hasUrl)) {
     postcssPlugins.push(
       UrlRewritePostcssPlugin({
-        replacer: urlReplacer,
+        resolver: urlResolver,
+        deps,
         logger: environment.logger
       })
     );
   }
+  let modules;
   if (isModule) {
     postcssPlugins.unshift(
       (await importPostcssModules()).default({
@@ -48766,7 +48934,9 @@ async function compileCSS(environment, id, code, workerController, urlReplacer)
       })
     );
   }
-  if (!postcssPlugins.length) {
+  const postcssOptions = postcssConfig?.options ?? {};
+  const postcssParser = lang === "sss" ? loadSss(config.root) : postcssOptions.parser;
+  if (!postcssPlugins.length && !postcssParser) {
     return {
       code,
       map: preprocessorMap,
@@ -48779,7 +48949,7 @@ async function compileCSS(environment, id, code, workerController, urlReplacer)
     const postcss = await importPostcss();
     postcssResult = await postcss.default(postcssPlugins).process(code, {
       ...postcssOptions,
-      parser: lang === "sss" ? loadSss(config.root) : postcssOptions.parser,
+      parser: postcssParser,
       to: source,
       from: source,
       ...devSourcemap ? {
@@ -48841,7 +49011,6 @@ ${generateCodeFrame(
   }
   if (!devSourcemap) {
     return {
-      ast: postcssResult,
       code: postcssResult.css,
       map: { mappings: "" },
       modules,
@@ -48856,7 +49025,6 @@ ${generateCodeFrame(
     cleanUrl(id)
   );
   return {
-    ast: postcssResult,
     code: postcssResult.css,
     map: combineSourcemapsIfExists(cleanUrl(id), postcssMap, preprocessorMap),
     modules,
@@ -48875,8 +49043,8 @@ function createCachedImport(imp) {
     return cached;
   };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-a6F3bn0a.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-BgKqB7IO.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-BADA5W91.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-7ffYZsA7.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 const preprocessorWorkerControllerCache = /* @__PURE__ */ new WeakMap();
 let alwaysFakeWorkerWorkerControllerCache;
@@ -48994,8 +49162,12 @@ const UrlRewritePostcssPlugin = (opts) => {
         const isCssUrl = cssUrlRE.test(declaration.value);
         const isCssImageSet = cssImageSetRE.test(declaration.value);
         if (isCssUrl || isCssImageSet) {
-          const replacerForDeclaration = (rawUrl) => {
-            return opts.replacer(rawUrl, importer);
+          const replacerForDeclaration = async (rawUrl) => {
+            const [newUrl, resolvedId] = await opts.resolver(rawUrl, importer);
+            if (newUrl.startsWith("data:") && resolvedId) {
+              opts.deps.add(resolvedId);
+            }
+            return newUrl;
           };
           if (isCssUrl && isCssImageSet) {
             promises.push(
@@ -49927,7 +50099,7 @@ function isPreProcessor(lang) {
   return lang && preprocessorSet.has(lang);
 }
 const importLightningCSS = createCachedImport(() => import('lightningcss'));
-async function compileLightningCSS(id, src, environment, urlReplacer) {
+async function compileLightningCSS(id, src, environment, urlResolver) {
   const { config } = environment;
   const deps = /* @__PURE__ */ new Set();
   const filename = id.replace("\0", NULL_BYTE_PLACEHOLDER);
@@ -49983,6 +50155,16 @@ async function compileLightningCSS(id, src, environment, urlReplacer) {
         column: e.loc.column - 1
         // 1-based
       };
+      try {
+        const code = fs__default.readFileSync(e.fileName, "utf-8");
+        const commonIeMessage = ", which was used in the past to support old Internet Explorer versions. This is not a valid CSS syntax and will be ignored by modern browsers. \nWhile this is not supported by LightningCSS, you can set `css.lightningcss.errorRecovery: true` to strip these codes.";
+        if (/[\s;{]\*[a-zA-Z-][\w-]+\s*:/.test(code)) {
+          e.message += ".\nThis file contains star property hack (e.g. `*zoom`)" + commonIeMessage;
+        } else if (/min-width:\s*0\\0/.test(code)) {
+          e.message += ".\nThis file contains @media zero hack (e.g. `@media (min-width: 0\\0)`)" + commonIeMessage;
+        }
+      } catch {
+      }
     }
     throw e;
   }
@@ -50003,11 +50185,15 @@ ${generateCodeFrame(src, {
         let replaceUrl;
         if (skipUrlReplacer(dep.url)) {
           replaceUrl = dep.url;
-        } else if (urlReplacer) {
-          replaceUrl = await urlReplacer(
+        } else if (urlResolver) {
+          const [newUrl, resolvedId] = await urlResolver(
             dep.url,
             dep.loc.filePath.replace(NULL_BYTE_PLACEHOLDER, "\0")
           );
+          if (newUrl.startsWith("data:") && resolvedId) {
+            deps.add(resolvedId);
+          }
+          replaceUrl = newUrl;
         } else {
           replaceUrl = dep.url;
         }
@@ -50910,8 +51096,8 @@ async function buildEnvironment(environment) {
     input,
     plugins,
     external: options.rollupOptions.external,
-    onwarn(warning, warn) {
-      onRollupWarning(warning, warn, environment);
+    onLog(level, log) {
+      onRollupLog(level, log, environment);
     }
   };
   function extractStack(e) {
@@ -50935,7 +51121,12 @@ ${trimmedPadding}
   const enhanceRollupError = (e) => {
     const stackOnly = extractStack(e);
     let msg = colors$1.red((e.plugin ? `[${e.plugin}] ` : "") + e.message);
-    if (e.id) {
+    if (e.loc && e.loc.file && e.loc.file !== e.id) {
+      msg += `
+file: ${colors$1.cyan(
+        `${e.loc.file}:${e.loc.line}:${e.loc.column}` + (e.id ? ` (${e.id})` : "")
+      )}`;
+    } else if (e.id) {
       msg += `
 file: ${colors$1.cyan(
         e.id + (e.loc ? `:${e.loc.line}:${e.loc.column}` : "")
@@ -51200,54 +51391,80 @@ function clearLine() {
     process.stdout.cursorTo(0);
   }
 }
-function onRollupWarning(warning, warn, environment) {
-  const viteWarn = (warnLog) => {
-    let warning2;
-    if (typeof warnLog === "function") {
-      warning2 = warnLog();
-    } else {
-      warning2 = warnLog;
-    }
-    if (typeof warning2 === "object") {
-      if (warning2.code === "UNRESOLVED_IMPORT") {
-        const id = warning2.id;
-        const exporter = warning2.exporter;
-        if (!id || !id.endsWith("?commonjs-external")) {
-          throw new Error(
-            `[vite]: Rollup failed to resolve import "${exporter}" from "${id}".
+function onRollupLog(level, log, environment) {
+  const debugLogger = createDebugger("vite:build");
+  const viteLog = (logLeveling, rawLogging) => {
+    const logging = typeof rawLogging === "object" ? rawLogging : { message: rawLogging };
+    if (logging.code === "UNRESOLVED_IMPORT") {
+      const id = logging.id;
+      const exporter = logging.exporter;
+      if (!id || !id.endsWith("?commonjs-external")) {
+        throw new Error(
+          `[vite]: Rollup failed to resolve import "${exporter}" from "${id}".
 This is most likely unintended because it can break your application at runtime.
 If you do want to externalize this module explicitly add it to
 \`build.rollupOptions.external\``
-          );
-        }
+        );
       }
-      if (warning2.plugin === "rollup-plugin-dynamic-import-variables" && dynamicImportWarningIgnoreList.some(
-        (msg) => warning2.message.includes(msg)
+    }
+    if (logLeveling === "warn") {
+      if (logging.plugin === "rollup-plugin-dynamic-import-variables" && dynamicImportWarningIgnoreList.some(
+        (msg) => logging.message.includes(msg)
       )) {
         return;
       }
-      if (warningIgnoreList.includes(warning2.code)) {
+      if (warningIgnoreList.includes(logging.code)) {
         return;
       }
-      if (warning2.code === "PLUGIN_WARNING") {
-        environment.logger.warn(
-          `${colors$1.bold(
-            colors$1.yellow(`[plugin:${warning2.plugin}]`)
-          )} ${colors$1.yellow(warning2.message)}`
-        );
+    }
+    switch (logLeveling) {
+      case "info":
+        environment.logger.info(logging.message);
+        return;
+      case "warn":
+        environment.logger.warn(colors$1.yellow(logging.message));
+        return;
+      case "error":
+        environment.logger.error(colors$1.red(logging.message));
+        return;
+      case "debug":
+        debugLogger?.(logging.message);
+        return;
+      default:
+        environment.logger.info(logging.message);
         return;
-      }
     }
-    warn(warnLog);
   };
   clearLine();
-  const userOnWarn = environment.config.build.rollupOptions.onwarn;
-  if (userOnWarn) {
-    userOnWarn(warning, viteWarn);
+  const userOnLog = environment.config.build.rollupOptions?.onLog;
+  const userOnWarn = environment.config.build.rollupOptions?.onwarn;
+  if (userOnLog) {
+    if (userOnWarn) {
+      const normalizedUserOnWarn = normalizeUserOnWarn(userOnWarn, viteLog);
+      userOnLog(level, log, normalizedUserOnWarn);
+    } else {
+      userOnLog(level, log, viteLog);
+    }
+  } else if (userOnWarn) {
+    const normalizedUserOnWarn = normalizeUserOnWarn(userOnWarn, viteLog);
+    normalizedUserOnWarn(level, log);
   } else {
-    viteWarn(warning);
+    viteLog(level, log);
   }
 }
+function normalizeUserOnWarn(userOnWarn, defaultHandler) {
+  return (logLevel, logging) => {
+    if (logLevel === "warn") {
+      userOnWarn(
+        normalizeLog(logging),
+        (log) => defaultHandler("warn", typeof log === "function" ? log() : log)
+      );
+    } else {
+      defaultHandler(logLevel, logging);
+    }
+  };
+}
+const normalizeLog = (log) => typeof log === "string" ? { message: log } : log;
 function resolveUserExternal(user, id, parentId, isResolved) {
   if (typeof user === "function") {
     return user(id, parentId, isResolved);
@@ -51595,7 +51812,7 @@ var build$1 = {
 	createBuilder: createBuilder,
 	createToImportMetaURLBasedRelativeRuntime: createToImportMetaURLBasedRelativeRuntime,
 	injectEnvironmentToHooks: injectEnvironmentToHooks,
-	onRollupWarning: onRollupWarning,
+	onRollupLog: onRollupLog,
 	resolveBuildEnvironmentOptions: resolveBuildEnvironmentOptions,
 	resolveBuildOutputs: resolveBuildOutputs,
 	resolveBuildPlugins: resolveBuildPlugins,
@@ -51609,7 +51826,7 @@ var build$1 = {
 };
 
 async function fetchModule(environment, url, importer, options = {}) {
-  if (url.startsWith("data:") || isBuiltin(url)) {
+  if (url.startsWith("data:") || isBuiltin(environment.config.resolve.builtins, url)) {
     return { externalize: url, type: "builtin" };
   }
   const isFileUrl = url.startsWith("file://");
@@ -51631,7 +51848,8 @@ async function fetchModule(environment, url, importer, options = {}) {
       isBuild: false,
       isProduction,
       root,
-      packageCache: environment.config.packageCache
+      packageCache: environment.config.packageCache,
+      builtins: environment.config.resolve.builtins
     });
     if (!resolved) {
       const err = new Error(
@@ -53102,7 +53320,7 @@ async function preview(inlineConfig = {}) {
   }
   const { allowedHosts } = config.preview;
   if (allowedHosts !== true && !config.preview.https) {
-    app.use(hostCheckMiddleware(config));
+    app.use(hostCheckMiddleware(config, true));
   }
   const { proxy } = config.preview;
   if (proxy) {
@@ -53180,6 +53398,61 @@ function resolveSSROptions(ssr, preserveSymlinks) {
   return mergeWithDefaults(defaults, ssr);
 }
 
+async function runnerImport(moduleId, inlineConfig) {
+  const isModuleSyncConditionEnabled = (await import('#module-sync-enabled')).default;
+  const config = await resolveConfig(
+    mergeConfig(inlineConfig || {}, {
+      configFile: false,
+      envFile: false,
+      cacheDir: process.cwd(),
+      environments: {
+        inline: {
+          consumer: "server",
+          dev: {
+            moduleRunnerTransform: true
+          },
+          resolve: {
+            external: true,
+            mainFields: [],
+            conditions: [
+              "node",
+              ...isModuleSyncConditionEnabled ? ["module-sync"] : []
+            ]
+          }
+        }
+      }
+    }),
+    "serve"
+  );
+  const environment = createRunnableDevEnvironment("inline", config, {
+    runnerOptions: {
+      hmr: {
+        logger: false
+      }
+    },
+    hot: false
+  });
+  await environment.init();
+  try {
+    const module = await environment.runner.import(moduleId);
+    const modules = [
+      ...environment.runner.evaluatedModules.urlToIdModuleMap.values()
+    ];
+    const dependencies = modules.filter((m) => {
+      if (!m.meta || "externalize" in m.meta) {
+        return false;
+      }
+      return m.exports !== module;
+    }).map((m) => m.file);
+    return {
+      module,
+      dependencies
+    };
+  } finally {
+    await environment.close();
+  }
+}
+
 const debug = createDebugger("vite:config", { depth: 10 });
 const promisifiedRealpath = promisify$4(fs__default.realpath);
 function defineConfig(config) {
@@ -53314,7 +53587,7 @@ function resolveDevEnvironmentOptions(dev, environmentName, consumer, skipSsrTra
     sourcemapIgnoreList: resolved.sourcemapIgnoreList === false ? () => false : resolved.sourcemapIgnoreList
   };
 }
-function resolveEnvironmentOptions(options, alias, preserveSymlinks, logger, environmentName, skipSsrTransform, isSsrTargetWebworkerSet) {
+function resolveEnvironmentOptions(options, alias, preserveSymlinks, forceOptimizeDeps, logger, environmentName, skipSsrTransform, isSsrTargetWebworkerSet) {
   const isClientEnvironment = environmentName === "client";
   const consumer = options.consumer ?? (isClientEnvironment ? "client" : "server");
   const isSsrTargetWebworkerEnvironment = isSsrTargetWebworkerSet && environmentName === "ssr";
@@ -53334,6 +53607,7 @@ function resolveEnvironmentOptions(options, alias, preserveSymlinks, logger, env
     optimizeDeps: resolveDepOptimizationOptions(
       options.optimizeDeps,
       resolve.preserveSymlinks,
+      forceOptimizeDeps,
       consumer
     ),
     dev: resolveDevEnvironmentOptions(
@@ -53398,7 +53672,7 @@ function resolveEnvironmentResolveOptions(resolve, alias, preserveSymlinks, logg
       ...configDefaults.resolve,
       mainFields: consumer === undefined || consumer === "client" || isSsrTargetWebworkerEnvironment ? DEFAULT_CLIENT_MAIN_FIELDS : DEFAULT_SERVER_MAIN_FIELDS,
       conditions: consumer === undefined || consumer === "client" || isSsrTargetWebworkerEnvironment ? DEFAULT_CLIENT_CONDITIONS : DEFAULT_SERVER_CONDITIONS.filter((c) => c !== "browser"),
-      enableBuiltinNoExternalCheck: !!isSsrTargetWebworkerEnvironment
+      builtins: resolve?.builtins ?? (consumer === "server" && !isSsrTargetWebworkerEnvironment ? nodeLikeBuiltins : [])
     },
     resolve ?? {}
   );
@@ -53436,7 +53710,7 @@ function resolveResolveOptions(resolve, logger) {
     undefined
   );
 }
-function resolveDepOptimizationOptions(optimizeDeps, preserveSymlinks, consumer) {
+function resolveDepOptimizationOptions(optimizeDeps, preserveSymlinks, forceOptimizeDeps, consumer) {
   return mergeWithDefaults(
     {
       ...configDefaults.optimizeDeps,
@@ -53445,7 +53719,8 @@ function resolveDepOptimizationOptions(optimizeDeps, preserveSymlinks, consumer)
       noDiscovery: consumer !== "client",
       esbuildOptions: {
         preserveSymlinks
-      }
+      },
+      force: forceOptimizeDeps ?? configDefaults.optimizeDeps.force
     },
     optimizeDeps ?? {}
   );
@@ -53472,7 +53747,8 @@ async function resolveConfig(inlineConfig, command, defaultMode = "development",
       configFile,
       config.root,
       config.logLevel,
-      config.customLogger
+      config.customLogger,
+      config.configLoader
     );
     if (loadResult) {
       config = mergeConfig(loadResult.config, config);
@@ -53595,6 +53871,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = "development",
       config.environments[environmentName],
       resolvedDefaultResolve.alias,
       resolvedDefaultResolve.preserveSymlinks,
+      inlineConfig.forceOptimizeDeps,
       logger,
       environmentName,
       config.experimental?.skipSsrTransform,
@@ -53931,7 +54208,12 @@ function sortUserPlugins(plugins) {
   }
   return [prePlugins, normalPlugins, postPlugins];
 }
-async function loadConfigFromFile(configEnv, configFile, configRoot = process.cwd(), logLevel, customLogger) {
+async function loadConfigFromFile(configEnv, configFile, configRoot = process.cwd(), logLevel, customLogger, configLoader = "bundle") {
+  if (configLoader !== "bundle" && configLoader !== "runner") {
+    throw new Error(
+      `Unsupported configLoader: ${configLoader}. Accepted values are 'bundle' and 'runner'.`
+    );
+  }
   const start = performance.now();
   const getTime = () => `${(performance.now() - start).toFixed(2)}ms`;
   let resolvedPath;
@@ -53949,23 +54231,18 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
     debug?.("no config file found.");
     return null;
   }
-  const isESM = typeof process.versions.deno === "string" || isFilePathESM(resolvedPath);
   try {
-    const bundled = await bundleConfigFile(resolvedPath, isESM);
-    const userConfig = await loadConfigFromBundledFile(
-      resolvedPath,
-      bundled.code,
-      isESM
-    );
-    debug?.(`bundled config file loaded in ${getTime()}`);
-    const config = await (typeof userConfig === "function" ? userConfig(configEnv) : userConfig);
+    const resolver = configLoader === "bundle" ? bundleAndLoadConfigFile : importConfigFile;
+    const { configExport, dependencies } = await resolver(resolvedPath);
+    debug?.(`config file loaded in ${getTime()}`);
+    const config = await (typeof configExport === "function" ? configExport(configEnv) : configExport);
     if (!isObject$2(config)) {
       throw new Error(`config must export or return an object.`);
     }
     return {
       path: normalizePath$3(resolvedPath),
       config,
-      dependencies: bundled.dependencies
+      dependencies
     };
   } catch (e) {
     createLogger(logLevel, { customLogger }).error(
@@ -53977,6 +54254,26 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
     throw e;
   }
 }
+async function importConfigFile(resolvedPath) {
+  const { module, dependencies } = await runnerImport(resolvedPath);
+  return {
+    configExport: module.default,
+    dependencies
+  };
+}
+async function bundleAndLoadConfigFile(resolvedPath) {
+  const isESM = typeof process.versions.deno === "string" || isFilePathESM(resolvedPath);
+  const bundled = await bundleConfigFile(resolvedPath, isESM);
+  const userConfig = await loadConfigFromBundledFile(
+    resolvedPath,
+    bundled.code,
+    isESM
+  );
+  return {
+    configExport: userConfig,
+    dependencies: bundled.dependencies
+  };
+}
 async function bundleConfigFile(fileName, isESM) {
   const isModuleSyncConditionEnabled = (await import('#module-sync-enabled')).default;
   const dirnameVarName = "__vite_injected_original_dirname";
@@ -54026,7 +54323,8 @@ async function bundleConfigFile(fileName, isESM) {
               extensions: configDefaults.resolve.extensions,
               preserveSymlinks: false,
               packageCache,
-              isRequire
+              isRequire,
+              builtins: nodeLikeBuiltins
             })?.id;
           };
           build2.onResolve(
@@ -54035,7 +54333,7 @@ async function bundleConfigFile(fileName, isESM) {
               if (kind === "entry-point" || path$d.isAbsolute(id) || isNodeBuiltin(id)) {
                 return;
               }
-              if (isBuiltin(id)) {
+              if (isNodeLikeBuiltin(id)) {
                 return { external: true };
               }
               const isImport = isESM || kind === "dynamic-import";
@@ -54203,4 +54501,4 @@ function optimizeDepsDisabledBackwardCompatibility(resolved, optimizeDeps, optim
   }
 }
 
-export { mergeAlias as A, BuildEnvironment as B, createFilter as C, DevEnvironment as D, rollupVersion as E, send$1 as F, createLogger as G, searchForWorkspaceRoot as H, isFileServingAllowed as I, isFileLoadingAllowed as J, loadEnv as K, resolveEnvPrefix as L, colors$1 as M, getDefaultExportFromCjs as N, commonjsGlobal as O, index$1 as P, index as Q, build$1 as R, preview$1 as S, arraify as a, perEnvironmentState as b, createServer as c, defineConfig as d, preview as e, build as f, createBuilder as g, createIdResolver as h, isInNodeModules$1 as i, formatPostcssSourceMap as j, preprocessCSS as k, loadConfigFromFile as l, buildErrorMessage as m, createRunnableDevEnvironment as n, optimizeDeps as o, perEnvironmentPlugin as p, isRunnableDevEnvironment as q, resolveConfig as r, sortUserPlugins as s, transformWithEsbuild as t, fetchModule as u, createServerModuleRunner as v, createServerHotChannel as w, ssrTransform as x, normalizePath$3 as y, mergeConfig as z };
+export { normalizePath$3 as A, BuildEnvironment as B, mergeConfig as C, DevEnvironment as D, mergeAlias as E, createFilter as F, rollupVersion as G, send$1 as H, createLogger as I, searchForWorkspaceRoot as J, isFileServingAllowed as K, isFileLoadingAllowed as L, loadEnv as M, resolveEnvPrefix as N, colors$1 as O, getDefaultExportFromCjs as P, commonjsGlobal as Q, index$1 as R, index as S, build$1 as T, preview$1 as U, arraify as a, perEnvironmentState as b, createServer as c, defineConfig as d, preview as e, build as f, createBuilder as g, createIdResolver as h, isInNodeModules$1 as i, formatPostcssSourceMap as j, preprocessCSS as k, loadConfigFromFile as l, buildErrorMessage as m, createRunnableDevEnvironment as n, optimizeDeps as o, perEnvironmentPlugin as p, isRunnableDevEnvironment as q, resolveConfig as r, sortUserPlugins as s, transformWithEsbuild as t, runnerImport as u, fetchModule as v, createServerModuleRunner as w, createServerModuleRunnerTransport as x, createServerHotChannel as y, ssrTransform as z };