vite 5.0.8 → 5.0.9

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

@@ -40076,8 +40076,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-Y5q53UKR.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-WV5u8Hxr.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-rzQTjkv_.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-riInLuGl.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 /**
  * @experimental
@@ -58778,6 +58778,8 @@ function htmlFallbackMiddleware(root, spaFallback, fsUtils = commonFsUtils) {
         if (
         // Only accept GET or HEAD
         (req.method !== 'GET' && req.method !== 'HEAD') ||
+            // Exclude default favicon requests
+            req.url === '/favicon.ico' ||
             // Require Accept: text/html or */*
             !(req.headers.accept === undefined || // equivalent to `Accept: */*`
                 req.headers.accept === '' || // equivalent to `Accept: */*`
@@ -58885,6 +58887,11 @@ const debugCache = createDebugger('vite:cache');
 const knownIgnoreList = new Set(['/', '/favicon.ico']);
 function transformMiddleware(server) {
     // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
+    // check if public dir is inside root dir
+    const { root } = server.config;
+    const publicDir = normalizePath$3(server.config.publicDir);
+    const publicDirInRoot = publicDir.startsWith(withTrailingSlash(root));
+    const publicPath = `${publicDir.slice(root.length)}/`;
     return async function viteTransformMiddleware(req, res, next) {
         if (req.method !== 'GET' || knownIgnoreList.has(req.url)) {
             return next();
@@ -58946,35 +58953,8 @@ function transformMiddleware(server) {
                     }
                 }
             }
-            // check if public dir is inside root dir
-            const publicDir = normalizePath$3(server.config.publicDir);
-            const rootDir = normalizePath$3(server.config.root);
-            if (publicDir.startsWith(withTrailingSlash(rootDir))) {
-                const publicPath = `${publicDir.slice(rootDir.length)}/`;
-                // warn explicit public paths
-                if (url.startsWith(withTrailingSlash(publicPath))) {
-                    let warning;
-                    if (isImportRequest(url)) {
-                        const rawUrl = removeImportQuery(url);
-                        if (urlRE.test(url)) {
-                            warning =
-                                `Assets in the public directory are served at the root path.\n` +
-                                    `Instead of ${colors$1.cyan(rawUrl)}, use ${colors$1.cyan(rawUrl.replace(publicPath, '/'))}.`;
-                        }
-                        else {
-                            warning =
-                                'Assets in public directory cannot be imported from JavaScript.\n' +
-                                    `If you intend to import that asset, put the file in the src directory, and use ${colors$1.cyan(rawUrl.replace(publicPath, '/src/'))} instead of ${colors$1.cyan(rawUrl)}.\n` +
-                                    `If you intend to use the URL of that asset, use ${colors$1.cyan(injectQuery(rawUrl.replace(publicPath, '/'), 'url'))}.`;
-                        }
-                    }
-                    else {
-                        warning =
-                            `Files in the public directory are served at the root path.\n` +
-                                `Instead of ${colors$1.cyan(url)}, use ${colors$1.cyan(url.replace(publicPath, '/'))}.`;
-                    }
-                    server.config.logger.warn(colors$1.yellow(warning));
-                }
+            if (publicDirInRoot && url.startsWith(publicPath)) {
+                warnAboutExplicitPublicPathInUrl(url);
             }
             if (isJSRequest(url) ||
                 isImportRequest(url) ||
@@ -59069,6 +59049,29 @@ function transformMiddleware(server) {
         }
         next();
     };
+    function warnAboutExplicitPublicPathInUrl(url) {
+        let warning;
+        if (isImportRequest(url)) {
+            const rawUrl = removeImportQuery(url);
+            if (urlRE.test(url)) {
+                warning =
+                    `Assets in the public directory are served at the root path.\n` +
+                        `Instead of ${colors$1.cyan(rawUrl)}, use ${colors$1.cyan(rawUrl.replace(publicPath, '/'))}.`;
+            }
+            else {
+                warning =
+                    'Assets in public directory cannot be imported from JavaScript.\n' +
+                        `If you intend to import that asset, put the file in the src directory, and use ${colors$1.cyan(rawUrl.replace(publicPath, '/src/'))} instead of ${colors$1.cyan(rawUrl)}.\n` +
+                        `If you intend to use the URL of that asset, use ${colors$1.cyan(injectQuery(rawUrl.replace(publicPath, '/'), 'url'))}.`;
+            }
+        }
+        else {
+            warning =
+                `Files in the public directory are served at the root path.\n` +
+                    `Instead of ${colors$1.cyan(url)}, use ${colors$1.cyan(url.replace(publicPath, '/'))}.`;
+        }
+        server.config.logger.warn(colors$1.yellow(warning));
+    }
 }
 
 function createDevHtmlTransformFn(config) {
@@ -59986,7 +59989,7 @@ async function _createServer(inlineConfig = {}, options) {
     const watcher = watchEnabled
         ? chokidar.watch(
         // config file dependencies and env file might be outside of root
-        [root, ...config.configFileDependencies, config.envDir], resolvedWatchOptions)
+        [...new Set([root, ...config.configFileDependencies, config.envDir])], resolvedWatchOptions)
         : createNoopWatcher(resolvedWatchOptions);
     const moduleGraph = new ModuleGraph((url, ssr) => container.resolveId(url, undefined, { ssr }));
     const container = await createPluginContainer(config, moduleGraph, watcher);
@@ -61241,10 +61244,21 @@ async function workerFileToUrl(config, id, query) {
 function webWorkerPostPlugin() {
     return {
         name: 'vite:worker-post',
-        resolveImportMeta(property, { chunkId, format }) {
+        resolveImportMeta(property, { format }) {
             // document is undefined in the worker, so we need to avoid it in iife
-            if (property === 'url' && format === 'iife') {
-                return 'self.location.href';
+            if (format === 'iife') {
+                // compiling import.meta
+                if (!property) {
+                    // rollup only supports `url` property. we only support `url` property as well.
+                    // https://github.com/rollup/rollup/blob/62b648e1cc6a1f00260bb85aa2050097bb4afd2b/src/ast/nodes/MetaProperty.ts#L164-L173
+                    return `{
+            url: self.location.href
+          }`;
+                }
+                // compiling import.meta.url
+                if (property === 'url') {
+                    return 'self.location.href';
+                }
             }
             return null;
         },
@@ -61674,7 +61688,11 @@ function importAnalysisPlugin(config) {
                     url = resolved.id.slice(root.length);
                 }
                 else if (depsOptimizer?.isOptimizedDepFile(resolved.id) ||
-                    (path$o.isAbsolute(cleanUrl(resolved.id)) &&
+                    // vite-plugin-react isn't following the leading \0 virtual module convention.
+                    // This is a temporary hack to avoid expensive fs checks for React apps.
+                    // We'll remove this as soon we're able to fix the react plugins.
+                    (resolved.id !== '/@react-refresh' &&
+                        path$o.isAbsolute(resolved.id) &&
                         fsUtils.existsSync(cleanUrl(resolved.id)))) {
                     // an optimized deps may not yet exists in the filesystem, or
                     // a regular file exists but is out of root: rewrite to absolute /@fs/ paths
@@ -64143,16 +64161,6 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                         external: doExternalize(path),
                     };
                 });
-                // onResolve is not called for glob imports.
-                // we need to add that here as well until esbuild calls onResolve for glob imports.
-                // https://github.com/evanw/esbuild/issues/3317
-                build.onLoad({ filter, namespace: 'file' }, () => {
-                    const externalOnLoadResult = {
-                        loader: 'js',
-                        contents: 'export default {}',
-                    };
-                    return externalOnLoadResult;
-                });
             };
             // css
             setupExternalize(CSS_LANGS_RE, isUnlessEntry);
@@ -64212,6 +64220,15 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                     contents,
                 };
             });
+            // onResolve is not called for glob imports.
+            // we need to add that here as well until esbuild calls onResolve for glob imports.
+            // https://github.com/evanw/esbuild/issues/3317
+            build.onLoad({ filter: /.*/, namespace: 'file' }, () => {
+                return {
+                    loader: 'js',
+                    contents: 'export default {}',
+                };
+            });
         },
     };
 }
@@ -65055,9 +65072,11 @@ async function optimizeServerSsrDeps(config) {
     return result.metadata;
 }
 function initDepsOptimizerMetadata(config, ssr, timestamp) {
-    const hash = getDepHash(config, ssr);
+    const { lockfileHash, configHash, hash } = getDepHash(config, ssr);
     return {
         hash,
+        lockfileHash,
+        configHash,
         browserHash: getOptimizedBrowserHash(hash, {}, timestamp),
         optimized: {},
         chunks: {},
@@ -65091,11 +65110,19 @@ async function loadCachedDepOptimizationMetadata(config, ssr, force = config.opt
         }
         catch (e) { }
         // hash is consistent, no need to re-bundle
-        if (cachedMetadata && cachedMetadata.hash === getDepHash(config, ssr)) {
-            log?.('Hash is consistent. Skipping. Use --force to override.');
-            // Nothing to commit or cancel as we are using the cache, we only
-            // need to resolve the processing promise so requests can move on
-            return cachedMetadata;
+        if (cachedMetadata) {
+            if (cachedMetadata.lockfileHash !== getLockfileHash(config)) {
+                config.logger.info('Re-optimizing dependencies because lockfile has changed');
+            }
+            else if (cachedMetadata.configHash !== getConfigHash(config, ssr)) {
+                config.logger.info('Re-optimizing dependencies because vite config has changed');
+            }
+            else {
+                log?.('Hash is consistent. Skipping. Use --force to override.');
+                // Nothing to commit or cancel as we are using the cache, we only
+                // need to resolve the processing promise so requests can move on
+                return cachedMetadata;
+            }
         }
     }
     else {
@@ -65125,7 +65152,7 @@ function discoverProjectDependencies(config) {
     };
 }
 function toDiscoveredDependencies(config, deps, ssr, timestamp) {
-    const browserHash = getOptimizedBrowserHash(getDepHash(config, ssr), deps, timestamp);
+    const browserHash = getOptimizedBrowserHash(getDepHash(config, ssr).hash, deps, timestamp);
     const discovered = {};
     for (const id in deps) {
         const src = deps[id];
@@ -65155,7 +65182,7 @@ function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.command
     };
     const depsCacheDir = getDepsCacheDir(resolvedConfig, ssr);
     const processingCacheDir = getProcessingDepsCacheDir(resolvedConfig, ssr);
-    // Create a temporal directory so we don't need to delete optimized deps
+    // Create a temporary directory so we don't need to delete optimized deps
     // until they have been processed. This also avoids leaving the deps cache
     // directory in a corrupted state if there is an error
     fs$l.mkdirSync(processingCacheDir, { recursive: true });
@@ -65195,40 +65222,40 @@ function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.command
             // we finish commiting the new deps cache files to the deps folder
             committed = true;
             // Write metadata file, then commit the processing folder to the global deps cache
-            // Rewire the file paths from the temporal processing dir to the final deps cache dir
+            // Rewire the file paths from the temporary processing dir to the final deps cache dir
             const dataPath = path$o.join(processingCacheDir, '_metadata.json');
             debug$1?.(colors$1.green(`creating _metadata.json in ${processingCacheDir}`));
             fs$l.writeFileSync(dataPath, stringifyDepsOptimizerMetadata(metadata, depsCacheDir));
             // In order to minimize the time where the deps folder isn't in a consistent state,
-            // we first rename the old depsCacheDir to a temporal path, then we rename the
+            // we first rename the old depsCacheDir to a temporary path, then we rename the
             // new processing cache dir to the depsCacheDir. In systems where doing so in sync
             // is safe, we do an atomic operation (at least for this thread). For Windows, we
             // found there are cases where the rename operation may finish before it's done
             // so we do a graceful rename checking that the folder has been properly renamed.
             // We found that the rename-rename (then delete the old folder in the background)
             // is safer than a delete-rename operation.
-            const temporalPath = depsCacheDir + getTempSuffix();
+            const temporaryPath = depsCacheDir + getTempSuffix();
             const depsCacheDirPresent = fs$l.existsSync(depsCacheDir);
             if (isWindows$4) {
                 if (depsCacheDirPresent) {
-                    debug$1?.(colors$1.green(`renaming ${depsCacheDir} to ${temporalPath}`));
-                    await safeRename(depsCacheDir, temporalPath);
+                    debug$1?.(colors$1.green(`renaming ${depsCacheDir} to ${temporaryPath}`));
+                    await safeRename(depsCacheDir, temporaryPath);
                 }
                 debug$1?.(colors$1.green(`renaming ${processingCacheDir} to ${depsCacheDir}`));
                 await safeRename(processingCacheDir, depsCacheDir);
             }
             else {
                 if (depsCacheDirPresent) {
-                    debug$1?.(colors$1.green(`renaming ${depsCacheDir} to ${temporalPath}`));
-                    fs$l.renameSync(depsCacheDir, temporalPath);
+                    debug$1?.(colors$1.green(`renaming ${depsCacheDir} to ${temporaryPath}`));
+                    fs$l.renameSync(depsCacheDir, temporaryPath);
                 }
                 debug$1?.(colors$1.green(`renaming ${processingCacheDir} to ${depsCacheDir}`));
                 fs$l.renameSync(processingCacheDir, depsCacheDir);
             }
-            // Delete temporal path in the background
+            // Delete temporary path in the background
             if (depsCacheDirPresent) {
-                debug$1?.(colors$1.green(`removing cache temp dir ${temporalPath}`));
-                fsp.rm(temporalPath, { recursive: true, force: true });
+                debug$1?.(colors$1.green(`removing cache temp dir ${temporaryPath}`));
+                fsp.rm(temporaryPath, { recursive: true, force: true });
             }
         },
     };
@@ -65527,7 +65554,7 @@ function createIsOptimizedDepUrl(config) {
     };
 }
 function parseDepsOptimizerMetadata(jsonMetadata, depsCacheDir) {
-    const { hash, browserHash, optimized, chunks } = JSON.parse(jsonMetadata, (key, value) => {
+    const { hash, lockfileHash, configHash, browserHash, optimized, chunks } = JSON.parse(jsonMetadata, (key, value) => {
         // Paths can be absolute or relative to the deps cache dir where
         // the _metadata.json is located
         if (key === 'file' || key === 'src') {
@@ -65542,6 +65569,8 @@ function parseDepsOptimizerMetadata(jsonMetadata, depsCacheDir) {
     }
     const metadata = {
         hash,
+        lockfileHash,
+        configHash,
         browserHash,
         optimized: {},
         discovered: {},
@@ -65572,9 +65601,11 @@ function parseDepsOptimizerMetadata(jsonMetadata, depsCacheDir) {
  * browserHash to allow long term caching
  */
 function stringifyDepsOptimizerMetadata(metadata, depsCacheDir) {
-    const { hash, browserHash, optimized, chunks } = metadata;
+    const { hash, configHash, lockfileHash, browserHash, optimized, chunks } = metadata;
     return JSON.stringify({
         hash,
+        configHash,
+        lockfileHash,
         browserHash,
         optimized: Object.fromEntries(Object.values(optimized).map(({ id, src, file, fileHash, needsInterop }) => [
             id,
@@ -65688,25 +65719,11 @@ const lockfileFormats = [
     return process.env.npm_config_user_agent?.startsWith(manager) ? 1 : -1;
 });
 const lockfileNames = lockfileFormats.map((l) => l.name);
-function getDepHash(config, ssr) {
-    const lockfilePath = lookupFile(config.root, lockfileNames);
-    let content = lockfilePath ? fs$l.readFileSync(lockfilePath, 'utf-8') : '';
-    if (lockfilePath) {
-        const lockfileName = path$o.basename(lockfilePath);
-        const { checkPatches } = lockfileFormats.find((f) => f.name === lockfileName);
-        if (checkPatches) {
-            // Default of https://github.com/ds300/patch-package
-            const fullPath = path$o.join(path$o.dirname(lockfilePath), 'patches');
-            const stat = tryStatSync(fullPath);
-            if (stat?.isDirectory()) {
-                content += stat.mtimeMs.toString();
-            }
-        }
-    }
-    // also take config into account
+function getConfigHash(config, ssr) {
+    // Take config into account
     // only a subset of config options that can affect dep optimization
     const optimizeDeps = getDepOptimizationConfig(config, ssr);
-    content += JSON.stringify({
+    const content = JSON.stringify({
         mode: process.env.NODE_ENV || config.mode,
         root: config.root,
         resolve: config.resolve,
@@ -65714,8 +65731,12 @@ function getDepHash(config, ssr) {
         assetsInclude: config.assetsInclude,
         plugins: config.plugins.map((p) => p.name),
         optimizeDeps: {
-            include: optimizeDeps?.include,
-            exclude: optimizeDeps?.exclude,
+            include: optimizeDeps?.include
+                ? Array.from(new Set(optimizeDeps.include)).sort()
+                : undefined,
+            exclude: optimizeDeps?.exclude
+                ? Array.from(new Set(optimizeDeps.exclude)).sort()
+                : undefined,
             esbuildOptions: {
                 ...optimizeDeps?.esbuildOptions,
                 plugins: optimizeDeps?.esbuildOptions?.plugins?.map((p) => p.name),
@@ -65729,6 +65750,33 @@ function getDepHash(config, ssr) {
     });
     return getHash(content);
 }
+function getLockfileHash(config, ssr) {
+    const lockfilePath = lookupFile(config.root, lockfileNames);
+    let content = lockfilePath ? fs$l.readFileSync(lockfilePath, 'utf-8') : '';
+    if (lockfilePath) {
+        const lockfileName = path$o.basename(lockfilePath);
+        const { checkPatches } = lockfileFormats.find((f) => f.name === lockfileName);
+        if (checkPatches) {
+            // Default of https://github.com/ds300/patch-package
+            const fullPath = path$o.join(path$o.dirname(lockfilePath), 'patches');
+            const stat = tryStatSync(fullPath);
+            if (stat?.isDirectory()) {
+                content += stat.mtimeMs.toString();
+            }
+        }
+    }
+    return getHash(content);
+}
+function getDepHash(config, ssr) {
+    const lockfileHash = getLockfileHash(config);
+    const configHash = getConfigHash(config, ssr);
+    const hash = getHash(lockfileHash + configHash);
+    return {
+        hash,
+        lockfileHash,
+        configHash,
+    };
+}
 function getOptimizedBrowserHash(hash, deps, timestamp = '') {
     return getHash(hash + JSON.stringify(deps) + timestamp);
 }
@@ -65823,7 +65871,6 @@ var index = {
 	depsLogString: depsLogString,
 	discoverProjectDependencies: discoverProjectDependencies,
 	extractExportsData: extractExportsData,
-	getDepHash: getDepHash,
 	getDepsCacheDir: getDepsCacheDir,
 	getDepsOptimizer: getDepsOptimizer,
 	getOptimizedDepPath: getOptimizedDepPath,

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

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

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

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

package/dist/node/cli.js

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

package/dist/node/index.d.ts

@@ -2570,6 +2570,16 @@ interface DepOptimizationMetadata {
      * This is checked on server startup to avoid unnecessary re-bundles.
      */
     hash: string;
+    /**
+     * This hash is determined by dependency lockfiles.
+     * This is checked on server startup to avoid unnecessary re-bundles.
+     */
+    lockfileHash: string;
+    /**
+     * This hash is determined by user config.
+     * This is checked on server startup to avoid unnecessary re-bundles.
+     */
+    configHash: string;
     /**
      * The browser hash is determined by the main hash plus additional dependencies
      * discovered at runtime. This is used to invalidate browser requests to

package/dist/node/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "5.0.8",
+  "version": "5.0.9",
   "type": "module",
   "license": "MIT",
   "author": "Evan You",