vite 4.0.0-alpha.0 → 4.0.0-alpha.2

package/dist/node/chunks/{dep-cb778398.js → dep-2a67faac.js}

@@ -1,5 +1,5 @@
 import require$$0$1 from 'postcss';
-import { A as commonjsGlobal } from './dep-f991744a.js';
+import { A as commonjsGlobal } from './dep-b8ca7cde.js';
 import require$$0 from 'path';
 import require$$5 from 'crypto';
 import require$$0__default from 'fs';

package/dist/node/chunks/{dep-f991744a.js → dep-b8ca7cde.js}

@@ -11974,16 +11974,10 @@ function writeFile(filename, content) {
     }
     fs$l.writeFileSync(filename, content);
 }
-/**
- * Use fs.statSync(filename) instead of fs.existsSync(filename)
- * #2051 if we don't have read permission on a directory, existsSync() still
- * works and will result in massively slow subsequent checks (which are
- * unnecessary in the first place)
- */
 function isFileReadable(filename) {
     try {
-        const stat = fs$l.statSync(filename, { throwIfNoEntry: false });
-        return !!stat;
+        fs$l.accessSync(filename, fs$l.constants.R_OK);
+        return true;
     }
     catch {
         return false;
@@ -12232,7 +12226,7 @@ async function resolveServerUrls(server, options, config) {
     const hostname = await resolveHostname(options.host);
     const protocol = options.https ? 'https' : 'http';
     const port = address.port;
-    const base = config.base === './' || config.base === '' ? '/' : config.base;
+    const base = config.rawBase === './' || config.rawBase === '' ? '/' : config.rawBase;
     if (hostname.host && loopbackHosts.has(hostname.host)) {
         let hostnameName = hostname.name;
         if (hostnameName === '::1' ||
@@ -12299,12 +12293,15 @@ function getHash(text) {
     return createHash$2('sha256').update(text).digest('hex').substring(0, 8);
 }
 const requireResolveFromRootWithFallback = (root, id) => {
+    const paths = _require$4.resolve.paths?.(id) || [];
     // Search in the root directory first, and fallback to the default require paths.
-    const fallbackPaths = _require$4.resolve.paths?.(id) || [];
-    const path = _require$4.resolve(id, {
-        paths: [root, ...fallbackPaths]
-    });
-    return path;
+    paths.unshift(root);
+    // Use `resolve` package to check existence first, so if the package is not found,
+    // it won't be cached by nodejs, since there isn't a way to invalidate them:
+    // https://github.com/nodejs/node/issues/44663
+    resolve$5.sync(id, { basedir: root, paths });
+    // Use `require.resolve` again as the `resolve` package doesn't support the `exports` field
+    return _require$4.resolve(id, { paths });
 };
 // Based on node-graceful-fs
 // The ISC License
@@ -12484,6 +12481,41 @@ const isNonDriveRelativeAbsolutePath = (p) => {
         return p.startsWith('/');
     return windowsDrivePathPrefixRE.test(p);
 };
+/**
+ * Determine if a file is being requested with the correct case, to ensure
+ * consistent behaviour between dev and prod and across operating systems.
+ */
+function shouldServe(url, assetsDir) {
+    try {
+        // viteTestUrl is set to something like http://localhost:4173/ and then many tests make calls
+        // like `await page.goto(viteTestUrl + '/example')` giving us URLs beginning with a double slash
+        const pathname = decodeURI(new URL$3(url.startsWith('//') ? url.substring(1) : url, 'http://example.com').pathname);
+        const file = path$o.join(assetsDir, pathname);
+        if (!fs$l.existsSync(file) ||
+            (isCaseInsensitiveFS && // can skip case check on Linux
+                !fs$l.statSync(file).isDirectory() &&
+                !hasCorrectCase(file, assetsDir))) {
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+/**
+ * Note that we can't use realpath here, because we don't want to follow
+ * symlinks.
+ */
+function hasCorrectCase(file, assets) {
+    if (file === assets)
+        return true;
+    const parent = path$o.dirname(file);
+    if (fs$l.readdirSync(parent).includes(path$o.basename(file))) {
+        return hasCorrectCase(parent, assets);
+    }
+    return false;
+}
 function joinUrlSegments(a, b) {
     if (!a || !b) {
         return a || b || '';
@@ -12496,6 +12528,13 @@ function joinUrlSegments(a, b) {
     }
     return a + b;
 }
+function stripBase(path, base) {
+    if (path === base) {
+        return '/';
+    }
+    const devBase = base.endsWith('/') ? base : base + '/';
+    return path.replace(RegExp('^' + devBase), '/');
+}
 function arrayEqual(a, b) {
     if (a === b)
         return true;
@@ -13412,6 +13451,7 @@ function esbuildPlugin(options = {}) {
     // and for build as the final optimization is in `buildEsbuildPlugin`
     const transformOptions = {
         target: 'esnext',
+        charset: 'utf8',
         ...options,
         minify: false,
         minifyIdentifiers: false,
@@ -13518,6 +13558,7 @@ function resolveEsbuildTranspileOptions(config, format) {
     const isEsLibBuild = config.build.lib && format === 'es';
     const esbuildOptions = config.esbuild || {};
     const options = {
+        charset: 'utf8',
         ...esbuildOptions,
         target: target || undefined,
         format: rollupToEsbuildFormatMap[format],
@@ -32282,14 +32323,13 @@ function lookup(extn) {
 	return mimes$1[!~idx ? tmp : tmp.substring(++idx)];
 }
 
-const assetUrlRE = /__VITE_ASSET__([a-z\d]{8})__(?:\$_(.*?)__)?/g;
-const duplicateAssets = new WeakMap();
+const assetUrlRE = /__VITE_ASSET__([a-z\d]+)__(?:\$_(.*?)__)?/g;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
 const assetCache = new WeakMap();
-const assetHashToFilenameMap = new WeakMap();
-// save hashes of the files that has been emitted in build watch
-const emittedHashMap = new WeakMap();
+// chunk.name is the basename for the asset ignoring the directory structure
+// For the manifest, we need to preserve the original file path
+const generatedAssets = new WeakMap();
 // add own dictionary entry by directly assigning mrmime
 function registerCustomMime() {
     // https://github.com/lukeed/mrmime/issues/3
@@ -32312,10 +32352,8 @@ function renderAssetUrlInJS(ctx, config, chunk, opts, code) {
     // In both cases, the wrapping should already be fine
     while ((match = assetUrlRE.exec(code))) {
         s || (s = new MagicString(code));
-        const [full, hash, postfix = ''] = match;
-        // some internal plugins may still need to emit chunks (e.g. worker) so
-        // fallback to this.getFileName for that. TODO: remove, not needed
-        const file = getAssetFilename(hash, config) || ctx.getFileName(hash);
+        const [full, referenceId, postfix = ''] = match;
+        const file = ctx.getFileName(referenceId);
         chunk.viteMetadata.importedAssets.add(cleanUrl(file));
         const filename = file + postfix;
         const replacement = toOutputFilePathInJS(filename, 'asset', chunk.fileName, 'js', config, toRelativeRuntime);
@@ -32342,15 +32380,12 @@ function renderAssetUrlInJS(ctx, config, chunk, opts, code) {
  * Also supports loading plain strings with import text from './foo.txt?raw'
  */
 function assetPlugin(config) {
-    // assetHashToFilenameMap initialization in buildStart causes getAssetFilename to return undefined
-    assetHashToFilenameMap.set(config, new Map());
     registerCustomMime();
     return {
         name: 'vite:asset',
         buildStart() {
             assetCache.set(config, new Map());
-            emittedHashMap.set(config, new Set());
-            duplicateAssets.set(config, new Map());
+            generatedAssets.set(config, new Map());
         },
         resolveId(id) {
             if (!config.assetsInclude(cleanUrl(id))) {
@@ -32442,14 +32477,11 @@ function fileToDevUrl(id, config) {
     else {
         // outside of project root, use absolute fs path
         // (this is special handled by the serve static middleware
-        rtn = path$o.posix.join(FS_PREFIX + id);
+        rtn = path$o.posix.join(FS_PREFIX, id);
     }
     const base = joinUrlSegments(config.server?.origin ?? '', config.base);
     return joinUrlSegments(base, rtn.replace(/^\//, ''));
 }
-function getAssetFilename(hash, config) {
-    return assetHashToFilenameMap.get(config)?.get(hash);
-}
 function getPublicAssetFilename(hash, config) {
     return publicAssetUrlCache.get(config)?.get(hash);
 }
@@ -32594,41 +32626,17 @@ async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false
     }
     else {
         // emit as asset
-        // rollup supports `import.meta.ROLLUP_FILE_URL_*`, but it generates code
-        // that uses runtime url sniffing and it can be verbose when targeting
-        // non-module format. It also fails to cascade the asset content change
-        // into the chunk's hash, so we have to do our own content hashing here.
-        // https://bundlers.tooling.report/hashing/asset-cascade/
-        // https://github.com/rollup/rollup/issues/3415
-        const map = assetHashToFilenameMap.get(config);
-        const contentHash = getHash(content);
         const { search, hash } = parse$j(id);
         const postfix = (search || '') + (hash || '');
-        const fileName = assetFileNamesToFileName(resolveAssetFileNames(config), file, contentHash, content);
-        if (!map.has(contentHash)) {
-            map.set(contentHash, fileName);
-        }
-        const emittedSet = emittedHashMap.get(config);
-        const duplicates = duplicateAssets.get(config);
-        const name = normalizePath$3(path$o.relative(config.root, file));
-        if (!emittedSet.has(contentHash)) {
-            pluginContext.emitFile({
-                name,
-                fileName,
-                type: 'asset',
-                source: content
-            });
-            emittedSet.add(contentHash);
-        }
-        else {
-            duplicates.set(name, {
-                name,
-                fileName: map.get(contentHash),
-                type: 'asset',
-                source: content
-            });
-        }
-        url = `__VITE_ASSET__${contentHash}__${postfix ? `$_${postfix}__` : ``}`; // TODO_BASE
+        const referenceId = pluginContext.emitFile({
+            // Ignore directory structure for asset file names
+            name: path$o.basename(file),
+            type: 'asset',
+            source: content
+        });
+        const originalName = normalizePath$3(path$o.relative(config.root, file));
+        generatedAssets.get(config).set(referenceId, { originalName });
+        url = `__VITE_ASSET__${referenceId}__${postfix ? `$_${postfix}__` : ``}`; // TODO_BASE
     }
     cache.set(id, url);
     return url;
@@ -33704,9 +33712,6 @@ function tryFsResolve(fsPath, options, tryIndex = true, targetWeb = true) {
     }
 }
 function tryResolveFile(file, postfix, options, tryIndex, targetWeb, tryPrefix, skipPackageJson) {
-    // #2051 if we don't have read permission on a directory, existsSync() still
-    // works and will result in massively slow subsequent checks (which are
-    // unnecessary in the first place)
     if (isFileReadable(file)) {
         if (!fs$l.statSync(file).isDirectory()) {
             return getRealPath(file, options.preserveSymlinks) + postfix;
@@ -34298,7 +34303,7 @@ const externalTypes = [
     'tsx',
     ...KNOWN_ASSET_TYPES
 ];
-function esbuildDepPlugin(qualified, exportsData, external, config, ssr) {
+function esbuildDepPlugin(qualified, external, config, ssr) {
     const { extensions } = getDepOptimizationConfig(config, ssr);
     // remove optimizable extensions from `externalTypes` list
     const allExternalTypes = extensions
@@ -35458,9 +35463,8 @@ function updateModules(file, modules, timestamp, { config, ws }) {
         debugHmr(picocolors.exports.yellow(`no update happened `) + picocolors.exports.dim(file));
         return;
     }
-    config.logger.info(updates
-        .map(({ path }) => picocolors.exports.green(`hmr update `) + picocolors.exports.dim(path))
-        .join('\n'), { clear: true, timestamp: true });
+    config.logger.info(picocolors.exports.green(`hmr update `) +
+        picocolors.exports.dim([...new Set(updates.map((u) => u.path))].join(', ')), { clear: true, timestamp: true });
     ws.send({
         type: 'update',
         updates
@@ -36329,7 +36333,10 @@ function servePublicMiddleware(dir, headers) {
         if (isImportRequest(req.url) || isInternalRequest(req.url)) {
             return next();
         }
-        serve(req, res, next);
+        if (shouldServe(req.url, dir)) {
+            return serve(req, res, next);
+        }
+        next();
     };
 }
 function serveStaticMiddleware(dir, server) {
@@ -36458,6 +36465,8 @@ function renderRestrictedErrorHTML(msg) {
   `;
 }
 
+const ERR_LOAD_URL = 'ERR_LOAD_URL';
+const ERR_LOAD_PUBLIC_URL = 'ERR_LOAD_PUBLIC_URL';
 const debugLoad = createDebugger('vite:load');
 const debugTransform = createDebugger('vite:transform');
 const debugCache$1 = createDebugger('vite:cache');
@@ -36603,15 +36612,15 @@ async function loadAndTransform(id, url, server, options, timestamp) {
         }
     }
     if (code == null) {
-        if (checkPublicFile(url, config)) {
-            throw new Error(`Failed to load url ${url} (resolved id: ${id}). ` +
-                `This file is in /public and will be copied as-is during build without ` +
+        const isPublicFile = checkPublicFile(url, config);
+        const msg = isPublicFile
+            ? `This file is in /public and will be copied as-is during build without ` +
                 `going through the plugin transforms, and therefore should not be ` +
-                `imported from source code. It can only be referenced via HTML tags.`);
-        }
-        else {
-            return null;
-        }
+                `imported from source code. It can only be referenced via HTML tags.`
+            : `Does the file exist?`;
+        const err = new Error(`Failed to load url ${url} (resolved id: ${id}). ${msg}`);
+        err.code = isPublicFile ? ERR_LOAD_PUBLIC_URL : ERR_LOAD_URL;
+        throw err;
     }
     // ensure module in graph after successful load
     const mod = await moduleGraph.ensureEntryFromUrl(url, ssr);
@@ -36813,9 +36822,7 @@ function importAnalysisPlugin(config) {
                 : null;
             const toAbsoluteUrl = (url) => path$o.posix.resolve(path$o.posix.dirname(importerModule.url), url);
             const normalizeUrl = async (url, pos) => {
-                if (base !== '/' && url.startsWith(base)) {
-                    url = url.replace(base, '/');
-                }
+                url = stripBase(url, base);
                 let importerFile = importer;
                 const optimizeDeps = getDepOptimizationConfig(config, ssr);
                 if (moduleListContains(optimizeDeps?.exclude, url)) {
@@ -36856,7 +36863,7 @@ function importAnalysisPlugin(config) {
                     fs$l.existsSync(cleanUrl(resolved.id))) {
                     // an optimized deps may not yet exists in the filesystem, or
                     // a regular file exists but is out of root: rewrite to absolute /@fs/ paths
-                    url = path$o.posix.join(FS_PREFIX + resolved.id);
+                    url = path$o.posix.join(FS_PREFIX, resolved.id);
                 }
                 else {
                     url = resolved.id;
@@ -36903,8 +36910,8 @@ function importAnalysisPlugin(config) {
                         e.pos = pos;
                         throw e;
                     }
-                    // prepend base (dev base is guaranteed to have ending slash)
-                    url = base + url.replace(/^\//, '');
+                    // prepend base
+                    url = joinUrlSegments(base, url);
                 }
                 return [url, resolved.id];
             };
@@ -37021,7 +37028,7 @@ function importAnalysisPlugin(config) {
                     }
                     // record for HMR import chain analysis
                     // make sure to unwrap and normalize away base
-                    const hmrUrl = unwrapId(url.replace(base, '/'));
+                    const hmrUrl = unwrapId(stripBase(url, base));
                     importedUrls.add(hmrUrl);
                     if (enablePartialAccept && importedBindings) {
                         extractImportedBindings(resolvedId, source, imports[index], importedBindings);
@@ -37134,7 +37141,7 @@ function importAnalysisPlugin(config) {
             // These requests will also be registered in transformRequest to be awaited
             // by the deps optimizer
             if (config.server.preTransformRequests && staticImportedUrls.size) {
-                staticImportedUrls.forEach(({ url, id }) => {
+                staticImportedUrls.forEach(({ url }) => {
                     url = removeImportQuery(url);
                     transformRequest(url, server, { ssr }).catch((e) => {
                         if (e?.code === ERR_OUTDATED_OPTIMIZED_DEP) {
@@ -41463,7 +41470,6 @@ async function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.co
     //    path.
     const flatIdDeps = {};
     const idToExports = {};
-    const flatIdToExports = {};
     const optimizeDeps = getDepOptimizationConfig(config, ssr);
     const { plugins: pluginsFromConfig = [], ...esbuildOptions } = optimizeDeps?.esbuildOptions ?? {};
     for (const id in depsInfo) {
@@ -41481,7 +41487,6 @@ async function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.co
         const flatId = flattenId(id);
         flatIdDeps[flatId] = src;
         idToExports[id] = exportsData;
-        flatIdToExports[flatId] = exportsData;
     }
     // esbuild automatically replaces process.env.NODE_ENV for platform 'browser'
     // In lib mode, we need to keep process.env.NODE_ENV untouched, so to at build
@@ -41513,7 +41518,7 @@ async function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.co
     if (external.length) {
         plugins.push(esbuildCjsExternalPlugin(external));
     }
-    plugins.push(esbuildDepPlugin(flatIdDeps, flatIdToExports, external, config, ssr));
+    plugins.push(esbuildDepPlugin(flatIdDeps, external, config, ssr));
     const start = performance.now();
     const result = await build$3({
         absWorkingDir: process.cwd(),
@@ -41540,6 +41545,7 @@ async function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.co
         ignoreAnnotations: !isBuild,
         metafile: true,
         plugins,
+        charset: 'utf8',
         ...esbuildOptions,
         supported: {
             'dynamic-import': true,
@@ -43014,7 +43020,7 @@ function buildHtmlPlugin(config) {
                 });
                 // resolve asset url references
                 result = result.replace(assetUrlRE, (_, fileHash, postfix = '') => {
-                    return (toOutputAssetFilePath(getAssetFilename(fileHash, config)) + postfix);
+                    return toOutputAssetFilePath(this.getFileName(fileHash)) + postfix;
                 });
                 result = result.replace(publicAssetUrlRE, (_, fileHash) => {
                     return normalizePath$3(toOutputPublicAssetFilePath(getPublicAssetFilename(fileHash, config)));
@@ -43341,7 +43347,7 @@ function cssPlugin(config) {
                         for (const file of deps) {
                             depModules.add(isCSSRequest(file)
                                 ? moduleGraph.createFileOnlyEntry(file)
-                                : await moduleGraph.ensureEntryFromUrl((await fileToUrl(file, config, this)).replace((config.server?.origin ?? '') + devBase, '/'), ssr));
+                                : await moduleGraph.ensureEntryFromUrl(stripBase(await fileToUrl(file, config, this), (config.server?.origin ?? '') + devBase), ssr));
                         }
                         moduleGraph.updateModuleInfo(thisModule, depModules, null, 
                         // The root CSS proxy module is self-accepting and should not
@@ -43510,7 +43516,7 @@ function cssPostPlugin(config) {
             const cssEntryFiles = cssEntryFilesCache.get(config);
             const publicAssetUrlMap = publicAssetUrlCache.get(config);
             // resolve asset URL placeholders to their built file URLs
-            function resolveAssetUrlsInCss(chunkCSS, cssAssetName) {
+            const resolveAssetUrlsInCss = (chunkCSS, cssAssetName) => {
                 const encodedPublicUrls = encodePublicUrlsInCSS(config);
                 const relative = config.base === './' || config.base === '';
                 const cssAssetDirname = encodedPublicUrls || relative
@@ -43525,7 +43531,7 @@ function cssPostPlugin(config) {
                 };
                 // replace asset url references with resolved url.
                 chunkCSS = chunkCSS.replace(assetUrlRE, (_, fileHash, postfix = '') => {
-                    const filename = getAssetFilename(fileHash, config) + postfix;
+                    const filename = this.getFileName(fileHash) + postfix;
                     chunk.viteMetadata.importedAssets.add(cleanUrl(filename));
                     return toOutputFilePathInCss(filename, 'asset', cssAssetName, 'css', config, toRelative);
                 });
@@ -43538,7 +43544,7 @@ function cssPostPlugin(config) {
                     });
                 }
                 return chunkCSS;
-            }
+            };
             function ensureFileExt(name, ext) {
                 return normalizePath$3(path$o.format({ ...path$o.parse(name), base: undefined, ext }));
             }
@@ -43808,10 +43814,9 @@ async function compileCSS(id, code, config, urlReplacer) {
         }));
     }
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-cb778398.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-2a67faac.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
-            // TODO: convert null to undefined (`null` should be removed from `CSSModulesOptions.localsConvention`)
-            localsConvention: modulesOptions?.localsConvention ?? undefined,
+            localsConvention: modulesOptions?.localsConvention,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
                 if (modulesOptions && typeof modulesOptions.getJSON === 'function') {
@@ -44575,28 +44580,43 @@ function manifestPlugin(config) {
                 }
                 return manifestChunk;
             }
-            function createAsset(chunk) {
+            function createAsset(chunk, src) {
                 const manifestChunk = {
                     file: chunk.fileName,
-                    src: chunk.name
+                    src
                 };
                 if (cssEntryFiles.has(chunk.name))
                     manifestChunk.isEntry = true;
                 return manifestChunk;
             }
             const cssEntryFiles = cssEntryFilesCache.get(config);
+            const fileNameToAssetMeta = new Map();
+            generatedAssets.get(config).forEach((asset, referenceId) => {
+                const fileName = this.getFileName(referenceId);
+                fileNameToAssetMeta.set(fileName, asset);
+            });
+            const fileNameToAsset = new Map();
             for (const file in bundle) {
                 const chunk = bundle[file];
                 if (chunk.type === 'chunk') {
                     manifest[getChunkName(chunk)] = createChunk(chunk);
                 }
                 else if (chunk.type === 'asset' && typeof chunk.name === 'string') {
-                    manifest[chunk.name] = createAsset(chunk);
+                    // Add every unique asset to the manifest, keyed by its original name
+                    const src = fileNameToAssetMeta.get(chunk.fileName)?.originalName ?? chunk.name;
+                    const asset = createAsset(chunk, src);
+                    manifest[src] = asset;
+                    fileNameToAsset.set(chunk.fileName, asset);
+                }
+            }
+            // Add duplicate assets to the manifest
+            fileNameToAssetMeta.forEach(({ originalName }, fileName) => {
+                if (!manifest[originalName]) {
+                    const asset = fileNameToAsset.get(fileName);
+                    if (asset) {
+                        manifest[originalName] = asset;
+                    }
                 }
-            }
-            duplicateAssets.get(config).forEach((asset) => {
-                const chunk = createAsset(asset);
-                manifest[asset.name] = chunk;
             });
             outputCount++;
             const output = config.build.rollupOptions?.output;
@@ -45096,10 +45116,16 @@ function loadEnv(mode, envDir, prefixes = 'VITE_') {
         }));
     }));
     // let environment variables use each other
-    main({
-        parsed,
+    const expandParsed = main({
+        parsed: {
+            ...process.env,
+            ...parsed
+        },
         // prevent process.env mutation
         ignoreProcessEnv: true
+    }).parsed;
+    Object.keys(parsed).forEach((key) => {
+        parsed[key] = expandParsed[key];
     });
     // only keys that start with prefix are exposed to client
     for (const [key, value] of Object.entries(parsed)) {
@@ -45509,29 +45535,30 @@ function resolveLibFilename(libOptions, format, entryName, root, extension) {
 }
 function resolveBuildOutputs(outputs, libOptions, logger) {
     if (libOptions) {
-        const hasMultipleEntries = typeof libOptions.entry !== 'string' &&
+        const libHasMultipleEntries = typeof libOptions.entry !== 'string' &&
             Object.values(libOptions.entry).length > 1;
-        const formats = libOptions.formats || (hasMultipleEntries ? ['es', 'cjs'] : ['es', 'umd']);
-        if (formats.includes('umd') || formats.includes('iife')) {
-            if (hasMultipleEntries) {
-                throw new Error(`Multiple entry points are not supported when output formats include "umd" or "iife".`);
-            }
-            if (!libOptions.name) {
-                throw new Error(`Option "build.lib.name" is required when output formats ` +
-                    `include "umd" or "iife".`);
+        const libFormats = libOptions.formats ||
+            (libHasMultipleEntries ? ['es', 'cjs'] : ['es', 'umd']);
+        if (!Array.isArray(outputs)) {
+            if (libFormats.includes('umd') || libFormats.includes('iife')) {
+                if (libHasMultipleEntries) {
+                    throw new Error('Multiple entry points are not supported when output formats include "umd" or "iife".');
+                }
+                if (!libOptions.name) {
+                    throw new Error('Option "build.lib.name" is required when output formats include "umd" or "iife".');
+                }
             }
+            return libFormats.map((format) => ({ ...outputs, format }));
         }
-        if (!outputs) {
-            return formats.map((format) => ({ format }));
-        }
-        else if (!Array.isArray(outputs)) {
-            return formats.map((format) => ({ ...outputs, format }));
-        }
-        else if (libOptions.formats) {
-            // user explicitly specifying own output array
-            logger.warn(picocolors.exports.yellow(`"build.lib.formats" will be ignored because ` +
-                `"build.rollupOptions.output" is already an array format`));
+        // By this point, we know "outputs" is an Array.
+        if (libOptions.formats) {
+            logger.warn(picocolors.exports.yellow('"build.lib.formats" will be ignored because "build.rollupOptions.output" is already an array format.'));
         }
+        outputs.forEach((output) => {
+            if (['umd', 'iife'].includes(output.format) && !output.name) {
+                throw new Error('Entries in "build.rollupOptions.output" must specify "name" when the format is "umd" or "iife".');
+            }
+        });
     }
     return outputs;
 }
@@ -45762,7 +45789,7 @@ function toOutputFilePathWithoutRuntime(filename, type, hostId, hostType, config
         return toRelative(filename, hostId);
     }
     else {
-        return config.base + filename;
+        return joinUrlSegments(config.base, filename);
     }
 }
 const toOutputFilePathInCss = toOutputFilePathWithoutRuntime;
@@ -55288,7 +55315,7 @@ const EventTarget = {
    * Register an event listener.
    *
    * @param {String} type A string representing the event type to listen for
-   * @param {Function} listener The listener to add
+   * @param {(Function|Object)} handler The listener to add
    * @param {Object} [options] An options object specifies characteristics about
    *     the event listener
    * @param {Boolean} [options.once=false] A `Boolean` indicating that the
@@ -55296,7 +55323,17 @@ const EventTarget = {
    *     the listener would be automatically removed when invoked.
    * @public
    */
-  addEventListener(type, listener, options = {}) {
+  addEventListener(type, handler, options = {}) {
+    for (const listener of this.listeners(type)) {
+      if (
+        !options[kForOnEventAttribute$1] &&
+        listener[kListener$1] === handler &&
+        !listener[kForOnEventAttribute$1]
+      ) {
+        return;
+      }
+    }
+
     let wrapper;
 
     if (type === 'message') {
@@ -55306,7 +55343,7 @@ const EventTarget = {
         });
 
         event[kTarget] = this;
-        listener.call(this, event);
+        callListener(handler, this, event);
       };
     } else if (type === 'close') {
       wrapper = function onClose(code, message) {
@@ -55317,7 +55354,7 @@ const EventTarget = {
         });
 
         event[kTarget] = this;
-        listener.call(this, event);
+        callListener(handler, this, event);
       };
     } else if (type === 'error') {
       wrapper = function onError(error) {
@@ -55327,21 +55364,21 @@ const EventTarget = {
         });
 
         event[kTarget] = this;
-        listener.call(this, event);
+        callListener(handler, this, event);
       };
     } else if (type === 'open') {
       wrapper = function onOpen() {
         const event = new Event('open');
 
         event[kTarget] = this;
-        listener.call(this, event);
+        callListener(handler, this, event);
       };
     } else {
       return;
     }
 
     wrapper[kForOnEventAttribute$1] = !!options[kForOnEventAttribute$1];
-    wrapper[kListener$1] = listener;
+    wrapper[kListener$1] = handler;
 
     if (options.once) {
       this.once(type, wrapper);
@@ -55354,7 +55391,7 @@ const EventTarget = {
    * Remove an event listener.
    *
    * @param {String} type A string representing the event type to remove
-   * @param {Function} handler The listener to remove
+   * @param {(Function|Object)} handler The listener to remove
    * @public
    */
   removeEventListener(type, handler) {
@@ -55375,6 +55412,22 @@ var eventTarget = {
   MessageEvent
 };
 
+/**
+ * Call an event listener
+ *
+ * @param {(Function|Object)} listener The listener to call
+ * @param {*} thisArg The value to use as `this`` when calling the listener
+ * @param {Event} event The event to pass to the listener
+ * @private
+ */
+function callListener(listener, thisArg, event) {
+  if (typeof listener === 'object' && listener.handleEvent) {
+    listener.handleEvent.call(listener, event);
+  } else {
+    listener.call(thisArg, event);
+  }
+}
+
 const { tokenChars: tokenChars$1 } = validation.exports;
 
 /**
@@ -57668,18 +57721,18 @@ function createWebSocketServer(server, config, httpsOptions) {
     };
 }
 
-// this middleware is only active when (config.base !== '/')
+// this middleware is only active when (base !== '/')
 function baseMiddleware({ config }) {
-    const devBase = config.base.endsWith('/') ? config.base : config.base + '/';
     // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
     return function viteBaseMiddleware(req, res, next) {
         const url = req.url;
         const parsed = new URL(url, 'http://vitejs.dev');
         const path = parsed.pathname || '/';
-        if (path.startsWith(devBase)) {
+        const base = config.rawBase;
+        if (path.startsWith(base)) {
             // rewrite url to remove base. this ensures that other middleware does
             // not need to consider base being prepended or not
-            req.url = url.replace(devBase, '/');
+            req.url = stripBase(url, base);
             return next();
         }
         // skip redirect and error fallback on middleware mode, #4057
@@ -57689,18 +57742,18 @@ function baseMiddleware({ config }) {
         if (path === '/' || path === '/index.html') {
             // redirect root visit to based url with search and hash
             res.writeHead(302, {
-                Location: config.base + (parsed.search || '') + (parsed.hash || '')
+                Location: base + (parsed.search || '') + (parsed.hash || '')
             });
             res.end();
             return;
         }
         else if (req.headers.accept?.includes('text/html')) {
             // non-based page visit
-            const redirectPath = joinUrlSegments(config.base, url);
+            const redirectPath = url + '/' !== base ? joinUrlSegments(base, url) : base;
             res.writeHead(404, {
                 'Content-Type': 'text/html'
             });
-            res.end(`The server is configured with a public base URL of ${config.base} - ` +
+            res.end(`The server is configured with a public base URL of ${base} - ` +
                 `did you mean to visit <a href="${redirectPath}">${redirectPath}</a> instead?`);
             return;
         }
@@ -60145,6 +60198,10 @@ function transformMiddleware(server) {
                 // error but a normal part of the missing deps discovery flow
                 return;
             }
+            if (e?.code === ERR_LOAD_URL) {
+                // Let other middleware handle if we can't load the url via transformRequest
+                return next();
+            }
             return next(e);
         }
         next();
@@ -61936,28 +61993,12 @@ async function startServer(server, inlinePort, isRestart = false) {
     const port = inlinePort ?? options.port ?? 5173;
     const hostname = await resolveHostname(options.host);
     const protocol = options.https ? 'https' : 'http';
-    const info = server.config.logger.info;
     const serverPort = await httpServerStart(httpServer, {
         port,
         strictPort: options.strictPort,
         host: hostname.host,
         logger: server.config.logger
     });
-    // @ts-ignore
-    const profileSession = global.__vite_profile_session;
-    if (profileSession) {
-        profileSession.post('Profiler.stop', (err, { profile }) => {
-            // Write profile to disk, upload, etc.
-            if (!err) {
-                const outPath = path$o.resolve('./vite-profile.cpuprofile');
-                fs$l.writeFileSync(outPath, JSON.stringify(profile));
-                info(picocolors.exports.yellow(`  CPU profile written to ${picocolors.exports.white(picocolors.exports.dim(outPath))}\n`));
-            }
-            else {
-                throw err;
-            }
-        });
-    }
     if (options.open && !isRestart) {
         const path = typeof options.open === 'string' ? options.open : server.config.base;
         openBrowser(path.startsWith('http')
@@ -62252,7 +62293,7 @@ async function preview(inlineConfig = {}) {
     // static assets
     const distDir = path$o.resolve(config.root, config.build.outDir);
     const headers = config.preview.headers;
-    app.use(previewBase, sirv(distDir, {
+    const assetServer = sirv(distDir, {
         etag: true,
         dev: true,
         single: config.appType === 'spa',
@@ -62263,7 +62304,13 @@ async function preview(inlineConfig = {}) {
                 }
             }
         }
-    }));
+    });
+    app.use(previewBase, async (req, res, next) => {
+        if (shouldServe(req.url, distDir)) {
+            return assetServer(req, res, next);
+        }
+        next();
+    });
     // apply post server hooks from plugins
     postHooks.forEach((fn) => fn && fn());
     const options = config.preview;
@@ -62367,11 +62414,6 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
             configFileDependencies = loadResult.dependencies;
         }
     }
-    // Define logger
-    const logger = createLogger(config.logLevel, {
-        allowClearScreen: config.clearScreen,
-        customLogger: config.customLogger
-    });
     // user config may provide an alternative mode. But --mode has a higher priority
     mode = inlineConfig.mode || config.mode || mode;
     configEnv.mode = mode;
@@ -62407,6 +62449,11 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
         config.build ?? (config.build = {});
         config.build.commonjsOptions = { include: [] };
     }
+    // Define logger
+    const logger = createLogger(config.logLevel, {
+        allowClearScreen: config.clearScreen,
+        customLogger: config.customLogger
+    });
     // resolve root
     const resolvedRoot = normalizePath$3(config.root ? path$o.resolve(config.root) : process.cwd());
     const clientAlias = [
@@ -62537,7 +62584,8 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
         configFileDependencies: configFileDependencies.map((name) => normalizePath$3(path$o.resolve(name))),
         inlineConfig,
         root: resolvedRoot,
-        base: resolvedBase,
+        base: resolvedBase.endsWith('/') ? resolvedBase : resolvedBase + '/',
+        rawBase: resolvedBase,
         resolve: resolveOptions,
         publicDir: resolvedPublicDir,
         cacheDir,
@@ -62659,28 +62707,22 @@ function resolveBaseUrl(base = '/', isBuild, logger) {
     if (base.startsWith('.')) {
         logger.warn(picocolors.exports.yellow(picocolors.exports.bold(`(!) invalid "base" option: ${base}. The value can only be an absolute ` +
             `URL, ./, or an empty string.`)));
-        base = '/';
+        return '/';
     }
-    // external URL
-    if (isExternalUrl(base)) {
-        if (!isBuild) {
-            // get base from full url during dev
-            const parsed = parse$j(base);
-            base = parsed.pathname || '/';
-        }
+    // external URL flag
+    const isExternal = isExternalUrl(base);
+    // no leading slash warn
+    if (!isExternal && !base.startsWith('/')) {
+        logger.warn(picocolors.exports.yellow(picocolors.exports.bold(`(!) "base" option should start with a slash.`)));
     }
-    else {
+    // parse base when command is serve or base is not External URL
+    if (!isBuild || !isExternal) {
+        base = new URL(base, 'http://vitejs.dev').pathname;
         // ensure leading slash
         if (!base.startsWith('/')) {
-            logger.warn(picocolors.exports.yellow(picocolors.exports.bold(`(!) "base" option should start with a slash.`)));
             base = '/' + base;
         }
     }
-    // ensure ending slash
-    if (!base.endsWith('/')) {
-        logger.warn(picocolors.exports.yellow(picocolors.exports.bold(`(!) "base" option should end with a slash.`)));
-        base += '/';
-    }
     return base;
 }
 function sortUserPlugins(plugins) {

package/dist/node/cli.js

@@ -1,9 +1,9 @@
+import path from 'node:path';
+import fs from 'node:fs';
 import { performance } from 'node:perf_hooks';
 import { EventEmitter } from 'events';
-import { z as picocolors, v as createLogger, g as resolveConfig } from './chunks/dep-f991744a.js';
+import { z as picocolors, v as createLogger, g as resolveConfig } from './chunks/dep-b8ca7cde.js';
 import { VERSION } from './constants.js';
-import 'node:fs';
-import 'node:path';
 import 'node:url';
 import 'node:module';
 import 'tty';
@@ -651,6 +651,23 @@ class CAC extends EventEmitter {
 const cac = (name = "") => new CAC(name);
 
 const cli = cac('vite');
+const stopProfiler = (log) => {
+    // @ts-ignore
+    const profileSession = global.__vite_profile_session;
+    if (profileSession) {
+        profileSession.post('Profiler.stop', (err, { profile }) => {
+            // Write profile to disk, upload, etc.
+            if (!err) {
+                const outPath = path.resolve('./vite-profile.cpuprofile');
+                fs.writeFileSync(outPath, JSON.stringify(profile));
+                log(picocolors.exports.yellow(`CPU profile written to ${picocolors.exports.white(picocolors.exports.dim(outPath))}`));
+            }
+            else {
+                throw err;
+            }
+        });
+    }
+};
 const filterDuplicateOptions = (options) => {
     for (const [key, value] of Object.entries(options)) {
         if (Array.isArray(value)) {
@@ -702,7 +719,7 @@ cli
     filterDuplicateOptions(options);
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await import('./chunks/dep-f991744a.js').then(function (n) { return n.D; });
+    const { createServer } = await import('./chunks/dep-b8ca7cde.js').then(function (n) { return n.D; });
     try {
         const server = await createServer({
             root,
@@ -726,9 +743,14 @@ cli
             : '';
         info(`\n  ${picocolors.exports.green(`${picocolors.exports.bold('VITE')} v${VERSION}`)}  ${startupDurationString}\n`, { clear: !server.config.logger.hasWarned });
         server.printUrls();
+        stopProfiler((message) => server.config.logger.info(`  ${message}`));
     }
     catch (e) {
-        createLogger(options.logLevel).error(picocolors.exports.red(`error when starting dev server:\n${e.stack}`), { error: e });
+        const logger = createLogger(options.logLevel);
+        logger.error(picocolors.exports.red(`error when starting dev server:\n${e.stack}`), {
+            error: e
+        });
+        stopProfiler(logger.info);
         process.exit(1);
     }
 });
@@ -750,7 +772,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-f991744a.js').then(function (n) { return n.C; });
+    const { build } = await import('./chunks/dep-b8ca7cde.js').then(function (n) { return n.C; });
     const buildOptions = cleanOptions(options);
     try {
         await build({
@@ -768,6 +790,9 @@ cli
         createLogger(options.logLevel).error(picocolors.exports.red(`error during build:\n${e.stack}`), { error: e });
         process.exit(1);
     }
+    finally {
+        stopProfiler((message) => createLogger(options.logLevel).info(message));
+    }
 });
 // optimize
 cli
@@ -775,7 +800,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-f991744a.js').then(function (n) { return n.B; });
+    const { optimizeDeps } = await import('./chunks/dep-b8ca7cde.js').then(function (n) { return n.B; });
     try {
         const config = await resolveConfig({
             root,
@@ -800,7 +825,7 @@ cli
     .option('--outDir <dir>', `[string] output directory (default: dist)`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { preview } = await import('./chunks/dep-f991744a.js').then(function (n) { return n.E; });
+    const { preview } = await import('./chunks/dep-b8ca7cde.js').then(function (n) { return n.E; });
     try {
         const server = await preview({
             root,
@@ -825,7 +850,12 @@ cli
         createLogger(options.logLevel).error(picocolors.exports.red(`error when starting preview server:\n${e.stack}`), { error: e });
         process.exit(1);
     }
+    finally {
+        stopProfiler((message) => createLogger(options.logLevel).info(message));
+    }
 });
 cli.help();
 cli.version(VERSION);
 cli.parse();
+
+export { stopProfiler };

package/dist/node/index.d.ts

@@ -498,9 +498,9 @@ export declare interface CSSModulesOptions {
     generateScopedName?: string | ((name: string, filename: string, css: string) => string);
     hashPrefix?: string;
     /**
-     * default: null
+     * default: undefined
      */
-    localsConvention?: 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly' | null;
+    localsConvention?: 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly';
 }
 
 export declare interface CSSOptions {
@@ -1626,6 +1626,7 @@ export declare type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'asse
     inlineConfig: InlineConfig;
     root: string;
     base: string;
+    /* Excluded from this release type: rawBase */
     publicDir: string;
     cacheDir: string;
     command: 'build' | 'serve';

package/dist/node/index.js

@@ -1,4 +1,4 @@
-export { b as build, q as createFilter, v as createLogger, c as createServer, e as defineConfig, f as formatPostcssSourceMap, i as getDepOptimizationConfig, j as isDepsOptimizerEnabled, l as loadConfigFromFile, x as loadEnv, k as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, a as preprocessCSS, p as preview, h as resolveBaseUrl, g as resolveConfig, y as resolveEnvPrefix, d as resolvePackageData, r as resolvePackageEntry, w as searchForWorkspaceRoot, u as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-f991744a.js';
+export { b as build, q as createFilter, v as createLogger, c as createServer, e as defineConfig, f as formatPostcssSourceMap, i as getDepOptimizationConfig, j as isDepsOptimizerEnabled, l as loadConfigFromFile, x as loadEnv, k as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, a as preprocessCSS, p as preview, h as resolveBaseUrl, g as resolveConfig, y as resolveEnvPrefix, d as resolvePackageData, r as resolvePackageEntry, w as searchForWorkspaceRoot, u as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-b8ca7cde.js';
 export { VERSION as version } from './constants.js';
 export { version as esbuildVersion } from 'esbuild';
 export { VERSION as rollupVersion } from 'rollup';

package/dist/node-cjs/publicUtils.cjs

@@ -3444,16 +3444,10 @@ function lookupFile(dir, formats, options) {
         return lookupFile(parentDir, formats, options);
     }
 }
-/**
- * Use fs.statSync(filename) instead of fs.existsSync(filename)
- * #2051 if we don't have read permission on a directory, existsSync() still
- * works and will result in massively slow subsequent checks (which are
- * unnecessary in the first place)
- */
 function isFileReadable(filename) {
     try {
-        const stat = fs$1.statSync(filename, { throwIfNoEntry: false });
-        return !!stat;
+        fs$1.accessSync(filename, fs$1.constants.R_OK);
+        return true;
     }
     catch {
         return false;
@@ -4179,10 +4173,16 @@ function loadEnv(mode, envDir, prefixes = 'VITE_') {
         }));
     }));
     // let environment variables use each other
-    main({
-        parsed,
+    const expandParsed = main({
+        parsed: {
+            ...process.env,
+            ...parsed
+        },
         // prevent process.env mutation
         ignoreProcessEnv: true
+    }).parsed;
+    Object.keys(parsed).forEach((key) => {
+        parsed[key] = expandParsed[key];
     });
     // only keys that start with prefix are exposed to client
     for (const [key, value] of Object.entries(parsed)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "4.0.0-alpha.0",
+  "version": "4.0.0-alpha.2",
   "type": "module",
   "license": "MIT",
   "author": "Evan You",
@@ -61,20 +61,20 @@
     "esbuild": "^0.15.9",
     "postcss": "^8.4.18",
     "resolve": "^1.22.1",
-    "rollup": "~3.2.3"
+    "rollup": "~3.3.0"
   },
   "optionalDependencies": {
     "fsevents": "~2.3.2"
   },
   "devDependencies": {
     "@ampproject/remapping": "^2.2.0",
-    "@babel/parser": "^7.20.0",
-    "@babel/types": "^7.20.0",
+    "@babel/parser": "^7.20.2",
+    "@babel/types": "^7.20.2",
     "@jridgewell/trace-mapping": "^0.3.17",
     "@rollup/plugin-alias": "^4.0.2",
     "@rollup/plugin-commonjs": "^23.0.2",
     "@rollup/plugin-dynamic-import-vars": "^2.0.1",
-    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-json": "^5.0.1",
     "@rollup/plugin-node-resolve": "14.1.0",
     "@rollup/plugin-typescript": "^8.5.0",
     "@rollup/pluginutils": "^4.2.1",
@@ -117,10 +117,10 @@
     "strip-ansi": "^7.0.1",
     "strip-literal": "^0.4.2",
     "tsconfck": "^2.0.1",
-    "tslib": "^2.4.0",
+    "tslib": "^2.4.1",
     "types": "link:./types",
     "ufo": "^0.8.6",
-    "ws": "^8.10.0"
+    "ws": "^8.11.0"
   },
   "peerDependencies": {
     "@types/node": ">= 14",

package/types/alias.d.ts

@@ -1,6 +0,0 @@
-export type {
-  Alias,
-  ResolverFunction,
-  ResolverObject,
-  AliasOptions
-} from '../dist/node'

package/types/anymatch.d.ts

@@ -1 +0,0 @@
-export type { AnymatchFn, AnymatchPattern, Matcher } from '../dist/node'

package/types/chokidar.d.ts

@@ -1,11 +0,0 @@
-export type {
-  FSWatcher,
-  WatchOptions,
-  AwaitWriteFinishOptions
-} from '../dist/node'
-
-import type { FSWatcher, WatchOptions } from '../dist/node'
-export function watch(
-  paths: string | ReadonlyArray<string>,
-  options?: WatchOptions
-): FSWatcher

package/types/commonjs.d.ts

@@ -1 +0,0 @@
-export type { RollupCommonJSOptions } from '../dist/node'

package/types/connect.d.ts

@@ -1 +0,0 @@
-export type { Connect } from '../dist/node'

package/types/dynamicImportVars.d.ts

@@ -1 +0,0 @@
-export type { RollupDynamicImportVarsOptions } from '../dist/node'

package/types/http-proxy.d.ts

@@ -1 +0,0 @@
-export type { HttpProxy } from '../dist/node'

package/types/terser.d.ts

@@ -1 +0,0 @@
-export type { Terser } from '../dist/node'

package/types/ws.d.ts

@@ -1 +0,0 @@
-export type { WebSocket, WebSocketAlias } from '../dist/node'