vite 3.0.0-beta.8 → 3.0.1

package/dist/node/chunks/{dep-5ccc5f38.js → dep-10d8d214.js}

@@ -22,7 +22,7 @@ import { createHash as createHash$2 } from 'node:crypto';
 import { promisify as promisify$4 } from 'node:util';
 import { promises } from 'node:dns';
 import resolve$5 from 'resolve';
-import { CLIENT_ENTRY, DEFAULT_EXTENSIONS as DEFAULT_EXTENSIONS$1, OPTIMIZABLE_ENTRY_RE, VALID_ID_PREFIX, FS_PREFIX, wildcardHosts, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, loopbackHosts, DEFAULT_MAIN_FIELDS, DEP_VERSION_RE, SPECIAL_QUERY_RE, KNOWN_ASSET_TYPES, JS_TYPES_RE, ESBUILD_MODULES_TARGET, CLIENT_DIR, NULL_BYTE_PLACEHOLDER, VERSION, VITE_PACKAGE_DIR, ENV_ENTRY, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
+import { CLIENT_ENTRY, DEFAULT_EXTENSIONS as DEFAULT_EXTENSIONS$1, OPTIMIZABLE_ENTRY_RE, VALID_ID_PREFIX, FS_PREFIX, wildcardHosts, loopbackHosts, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, DEFAULT_MAIN_FIELDS, DEP_VERSION_RE, SPECIAL_QUERY_RE, KNOWN_ASSET_TYPES, JS_TYPES_RE, ESBUILD_MODULES_TARGET, CLIENT_DIR, NULL_BYTE_PLACEHOLDER, VERSION, VITE_PACKAGE_DIR, ENV_ENTRY, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
 import require$$5 from 'crypto';
 import require$$0$a from 'buffer';
 import require$$0$8, { createRequire as createRequire$2 } from 'module';
@@ -12172,7 +12172,49 @@ async function resolveHostname(optionsHost) {
             name = localhostAddr;
         }
     }
-    return { host, name, implicit: optionsHost === undefined };
+    return { host, name };
+}
+async function resolveServerUrls(server, options, config) {
+    const address = server.address();
+    const isAddressInfo = (x) => x?.address;
+    if (!isAddressInfo(address)) {
+        return { local: [], network: [] };
+    }
+    const local = [];
+    const network = [];
+    const hostname = await resolveHostname(options.host);
+    const protocol = options.https ? 'https' : 'http';
+    const port = address.port;
+    const base = config.base === './' || config.base === '' ? '/' : config.base;
+    if (hostname.host && loopbackHosts.has(hostname.host)) {
+        let hostnameName = hostname.name;
+        if (hostnameName === '::1' ||
+            hostnameName === '0000:0000:0000:0000:0000:0000:0000:0001') {
+            hostnameName = `[${hostnameName}]`;
+        }
+        local.push(`${protocol}://${hostnameName}:${port}${base}`);
+    }
+    else {
+        Object.values(os$3.networkInterfaces())
+            .flatMap((nInterface) => nInterface ?? [])
+            .filter((detail) => detail &&
+            detail.address &&
+            // Node < v18
+            ((typeof detail.family === 'string' && detail.family === 'IPv4') ||
+                // Node >= v18
+                (typeof detail.family === 'number' && detail.family === 4)))
+            .forEach((detail) => {
+            const host = detail.address.replace('127.0.0.1', hostname.name);
+            const url = `${protocol}://${host}:${port}${base}`;
+            if (detail.address.includes('127.0.0.1')) {
+                local.push(url);
+            }
+            else {
+                network.push(url);
+            }
+        });
+    }
+    return { local, network };
 }
 function arraify(target) {
     return Array.isArray(target) ? target : [target];
@@ -12381,7 +12423,6 @@ function stripBomTag(content) {
     }
     return content;
 }
-const isTS = (filename) => /\.[cm]?ts$/.test(filename);
 const windowsDrivePathPrefixRE = /^[A-Za-z]:[/\\]/;
 /**
  * path.isAbsolute also returns true for drive relative paths on windows (e.g. /something)
@@ -12491,64 +12532,18 @@ function createLogger(level = 'info', options = {}) {
     };
     return logger;
 }
-async function printCommonServerUrls(server, options, config) {
-    const address = server.address();
-    const isAddressInfo = (x) => x?.address;
-    if (isAddressInfo(address)) {
-        const hostname = await resolveHostname(options.host);
-        const protocol = options.https ? 'https' : 'http';
-        const base = config.base === './' || config.base === '' ? '/' : config.base;
-        printServerUrls(hostname, protocol, address.port, base, config.logger.info);
+function printServerUrls(urls, optionsHost, info) {
+    const colorUrl = (url) => picocolors.exports.cyan(url.replace(/:(\d+)\//, (_, port) => `:${picocolors.exports.bold(port)}/`));
+    for (const url of urls.local) {
+        info(`  ${picocolors.exports.green('➜')}  ${picocolors.exports.bold('Local')}:   ${colorUrl(url)}`);
     }
-}
-function printServerUrls(hostname, protocol, port, base, info) {
-    const urls = [];
-    const notes = [];
-    if (hostname.host && loopbackHosts.has(hostname.host)) {
-        let hostnameName = hostname.name;
-        if (hostnameName === '::1' ||
-            hostnameName === '0000:0000:0000:0000:0000:0000:0000:0001') {
-            hostnameName = `[${hostnameName}]`;
-        }
-        urls.push({
-            label: 'Local',
-            url: picocolors.exports.cyan(`${protocol}://${hostnameName}:${picocolors.exports.bold(port)}${base}`)
-        });
-        if (hostname.implicit) {
-            urls.push({
-                label: 'Network',
-                url: `use ${picocolors.exports.white(picocolors.exports.bold('--host'))} to expose`,
-                disabled: true
-            });
-        }
+    for (const url of urls.network) {
+        info(`  ${picocolors.exports.green('➜')}  ${picocolors.exports.bold('Network')}: ${colorUrl(url)}`);
     }
-    else {
-        Object.values(os$3.networkInterfaces())
-            .flatMap((nInterface) => nInterface ?? [])
-            .filter((detail) => detail &&
-            detail.address &&
-            // Node < v18
-            ((typeof detail.family === 'string' && detail.family === 'IPv4') ||
-                // Node >= v18
-                (typeof detail.family === 'number' && detail.family === 4)))
-            .forEach((detail) => {
-            const host = detail.address.replace('127.0.0.1', hostname.name);
-            const url = `${protocol}://${host}:${picocolors.exports.bold(port)}${base}`;
-            const label = detail.address.includes('127.0.0.1') ? 'Local' : 'Network';
-            urls.push({ label, url: picocolors.exports.cyan(url) });
-        });
+    if (urls.network.length === 0 && optionsHost === undefined) {
+        const note = `use ${picocolors.exports.white(picocolors.exports.bold('--host'))} to expose`;
+        info(picocolors.exports.dim(`  ${picocolors.exports.green('➜')}  ${picocolors.exports.bold('Network')}: ${note}`));
     }
-    const length = Math.max(...[...urls, ...notes].map(({ label }) => label.length));
-    const print = (iconWithColor, label, messageWithColor, disabled) => {
-        const message = `  ${iconWithColor}  ${label ? picocolors.exports.bold(label) + ':' : ' '} ${' '.repeat(length - label.length)}${messageWithColor}`;
-        info(disabled ? picocolors.exports.dim(message) : message);
-    };
-    urls.forEach(({ label, url: text, disabled }) => {
-        print(picocolors.exports.green('➜'), label, text, disabled);
-    });
-    notes.forEach(({ label, message: text }) => {
-        print(picocolors.exports.white('❖'), label, text);
-    });
 }
 
 const writeColors = {
@@ -13343,7 +13338,11 @@ function esbuildPlugin(options = {}) {
         minifyIdentifiers: false,
         minifySyntax: false,
         minifyWhitespace: false,
-        treeShaking: false
+        treeShaking: false,
+        // keepNames is not needed when minify is disabled.
+        // Also transforming multiple times with keepNames enabled breaks
+        // tree-shaking. (#9164)
+        keepNames: false
     };
     return {
         name: 'vite:esbuild',
@@ -13438,10 +13437,19 @@ function resolveEsbuildTranspileOptions(config, format) {
     // pure annotations and break tree-shaking
     // https://github.com/vuejs/core/issues/2860#issuecomment-926882793
     const isEsLibBuild = config.build.lib && format === 'es';
+    const esbuildOptions = config.esbuild || {};
     const options = {
-        ...config.esbuild,
+        ...esbuildOptions,
         target: target || undefined,
-        format: rollupToEsbuildFormatMap[format]
+        format: rollupToEsbuildFormatMap[format],
+        // the final build should always support dynamic import and import.meta.
+        // if they need to be polyfilled, plugin-legacy should be used.
+        // plugin-legacy detects these two features when checking for modern code.
+        supported: {
+            'dynamic-import': true,
+            'import-meta': true,
+            ...esbuildOptions.supported
+        }
     };
     // If no minify, disable all minify options
     if (!minify) {
@@ -13560,11 +13568,14 @@ function reloadOnTsconfigChange(changedFile) {
         server.moduleGraph.invalidateAll();
         // reset tsconfck so that recompile works with up2date configs
         initTSConfck(server.config).finally(() => {
-            // force full reload
-            server.ws.send({
-                type: 'full-reload',
-                path: '*'
-            });
+            // server may not be available if vite config is updated at the same time
+            if (server) {
+                // force full reload
+                server.ws.send({
+                    type: 'full-reload',
+                    path: '*'
+                });
+            }
         });
     }
 }
@@ -33906,6 +33917,16 @@ function resolvePlugin(resolveOptions) {
                     return res;
                 }
             }
+            // drive relative fs paths (only windows)
+            if (isWindows$4 && id.startsWith('/')) {
+                const basedir = importer ? path$n.dirname(importer) : process.cwd();
+                const fsPath = path$n.resolve(basedir, id);
+                if ((res = tryFsResolve(fsPath, options))) {
+                    isDebug$4 &&
+                        debug$c(`[drive-relative] ${picocolors.exports.cyan(id)} -> ${picocolors.exports.dim(res)}`);
+                    return res;
+                }
+            }
             // absolute fs paths
             if (isNonDriveRelativeAbsolutePath(id) &&
                 (res = tryFsResolve(id, options))) {
@@ -36207,41 +36228,41 @@ async function createDepsOptimizer(config, server) {
         }
         if (!isBuild) {
             // Important, the scanner is dev only
-            runScanner();
-        }
-    }
-    async function runScanner() {
-        const scanPhaseProcessing = newDepOptimizationProcessing();
-        depsOptimizer.scanProcessing = scanPhaseProcessing.promise;
-        try {
-            debuggerViteDeps(picocolors.exports.green(`scanning for dependencies...`));
-            const deps = await discoverProjectDependencies(config);
-            debuggerViteDeps(picocolors.exports.green(Object.keys(deps).length > 0
-                ? `dependencies found by scanner: ${depsLogString(Object.keys(deps))}`
-                : `no dependencies found by scanner`));
-            // Add these dependencies to the discovered list, as these are currently
-            // used by the preAliasPlugin to support aliased and optimized deps.
-            // This is also used by the CJS externalization heuristics in legacy mode
-            for (const id of Object.keys(deps)) {
-                if (!metadata.discovered[id]) {
-                    addMissingDep(id, deps[id]);
-                }
-            }
-            if (!isBuild) {
-                const knownDeps = prepareKnownDeps();
-                // For dev, we run the scanner and the first optimization
-                // run on the background, but we wait until crawling has ended
-                // to decide if we send this result to the browser or we need to
-                // do another optimize step
-                postScanOptimizationResult = runOptimizeDeps(config, knownDeps);
-            }
-        }
-        catch (e) {
-            logger.error(e.message);
-        }
-        finally {
-            scanPhaseProcessing.resolve();
-            depsOptimizer.scanProcessing = undefined;
+            const scanPhaseProcessing = newDepOptimizationProcessing();
+            depsOptimizer.scanProcessing = scanPhaseProcessing.promise;
+            // Ensure server listen is called before the scanner
+            setTimeout(async () => {
+                try {
+                    debuggerViteDeps(picocolors.exports.green(`scanning for dependencies...`));
+                    const deps = await discoverProjectDependencies(config);
+                    debuggerViteDeps(picocolors.exports.green(Object.keys(deps).length > 0
+                        ? `dependencies found by scanner: ${depsLogString(Object.keys(deps))}`
+                        : `no dependencies found by scanner`));
+                    // Add these dependencies to the discovered list, as these are currently
+                    // used by the preAliasPlugin to support aliased and optimized deps.
+                    // This is also used by the CJS externalization heuristics in legacy mode
+                    for (const id of Object.keys(deps)) {
+                        if (!metadata.discovered[id]) {
+                            addMissingDep(id, deps[id]);
+                        }
+                    }
+                    if (!isBuild) {
+                        const knownDeps = prepareKnownDeps();
+                        // For dev, we run the scanner and the first optimization
+                        // run on the background, but we wait until crawling has ended
+                        // to decide if we send this result to the browser or we need to
+                        // do another optimize step
+                        postScanOptimizationResult = runOptimizeDeps(config, knownDeps);
+                    }
+                }
+                catch (e) {
+                    logger.error(e.message);
+                }
+                finally {
+                    scanPhaseProcessing.resolve();
+                    depsOptimizer.scanProcessing = undefined;
+                }
+            }, 0);
         }
     }
     async function startNextDiscoveredBatch() {
@@ -36658,7 +36679,8 @@ const isDebugEnabled = _debug('vite:deps').enabled;
 const jsExtensionRE = /\.js$/i;
 const jsMapExtensionRE = /\.js\.map$/i;
 /**
- * Used by Vite CLI when running `vite optimize`
+ * Scan and optimize dependencies within a project.
+ * Used by Vite CLI when running `vite optimize`.
  */
 async function optimizeDeps(config, force = config.optimizeDeps.force, asCommand = false) {
     const log = asCommand ? config.logger.info : debug$a;
@@ -37958,18 +37980,26 @@ function createIsConfiguredAsSsrExternal(config) {
     const noExternalFilter = noExternal !== 'undefined' &&
         typeof noExternal !== 'boolean' &&
         createFilter(undefined, noExternal, { resolve: false });
+    // Returns true if it is configured as external, false if it is filtered
+    // by noExternal and undefined if it isn't affected by the explicit config
     return (id) => {
         const { ssr } = config;
-        if (!ssr || ssr.external?.includes(id)) {
-            return true;
-        }
-        if (typeof noExternal === 'boolean') {
-            return !noExternal;
-        }
-        if (noExternalFilter) {
-            return noExternalFilter(id);
+        if (ssr) {
+            const pkgName = getNpmPackageName(id);
+            if (!pkgName) {
+                return undefined;
+            }
+            if (ssr.external?.includes(pkgName)) {
+                return true;
+            }
+            if (typeof noExternal === 'boolean') {
+                return !noExternal;
+            }
+            if (noExternalFilter && !noExternalFilter(pkgName)) {
+                return false;
+            }
         }
-        return true;
+        return undefined;
     };
 }
 function createIsSsrExternal(config) {
@@ -37993,9 +38023,11 @@ function createIsSsrExternal(config) {
         if (processedIds.has(id)) {
             return processedIds.get(id);
         }
-        const external = !id.startsWith('.') &&
-            !path$n.isAbsolute(id) &&
-            (isBuiltin(id) || (isConfiguredAsExternal(id) && isValidPackageEntry(id)));
+        let external = false;
+        if (!id.startsWith('.') && !path$n.isAbsolute(id)) {
+            external =
+                isBuiltin(id) || (isConfiguredAsExternal(id) ?? isValidPackageEntry(id));
+        }
         processedIds.set(id, external);
         return external;
     };
@@ -38777,11 +38809,11 @@ const ssrImportKey = `__vite_ssr_import__`;
 const ssrDynamicImportKey = `__vite_ssr_dynamic_import__`;
 const ssrExportAllKey = `__vite_ssr_exportAll__`;
 const ssrImportMetaKey = `__vite_ssr_import_meta__`;
-async function ssrTransform(code, inMap, url, options) {
+async function ssrTransform(code, inMap, url, originalCode, options) {
     if (options?.json?.stringify && isJSONRequest(url)) {
         return ssrTransformJSON(code, inMap);
     }
-    return ssrTransformScript(code, inMap, url);
+    return ssrTransformScript(code, inMap, url, originalCode);
 }
 async function ssrTransformJSON(code, inMap) {
     return {
@@ -38791,7 +38823,7 @@ async function ssrTransformJSON(code, inMap) {
         dynamicDeps: []
     };
 }
-async function ssrTransformScript(code, inMap, url) {
+async function ssrTransformScript(code, inMap, url, originalCode) {
     const s = new MagicString(code);
     let ast;
     try {
@@ -38970,11 +39002,13 @@ async function ssrTransformScript(code, inMap, url) {
                 sourcesContent: inMap.sourcesContent
             },
             inMap
-        ]);
+        ], false);
     }
     else {
         map.sources = [url];
-        map.sourcesContent = [code];
+        // needs to use originalCode instead of code
+        // because code might be already transformed even if map is null
+        map.sourcesContent = [originalCode];
     }
     return {
         code: s.toString(),
@@ -39736,6 +39770,7 @@ async function loadAndTransform(id, url, server, options, timestamp) {
         inMap: map,
         ssr
     });
+    const originalCode = code;
     if (transformResult == null ||
         (isObject$2(transformResult) && transformResult.code == null)) {
         // no transform applied, keep code as-is
@@ -39754,7 +39789,7 @@ async function loadAndTransform(id, url, server, options, timestamp) {
         }
     }
     const result = ssr
-        ? await ssrTransform(code, map, url, {
+        ? await ssrTransform(code, map, url, originalCode, {
             json: { stringify: !!server.config.json?.stringify }
         })
         : {
@@ -40100,7 +40135,7 @@ function importAnalysisPlugin(config) {
                     if (ssr) {
                         return [url, url];
                     }
-                    this.error(`Failed to resolve import "${url}" from "${path$n.relative(process.cwd(), importerFile)}". Does the file exist?`, pos);
+                    return this.error(`Failed to resolve import "${url}" from "${path$n.relative(process.cwd(), importerFile)}". Does the file exist?`, pos);
                 }
                 const isRelative = url.startsWith('.');
                 const isSelfImport = !isRelative && cleanUrl(url) === cleanUrl(importer);
@@ -40646,7 +40681,7 @@ function buildImportAnalysisPlugin(config) {
                     if (ssr) {
                         return [url, url];
                     }
-                    this.error(`Failed to resolve import "${url}" from "${path$n.relative(process.cwd(), importerFile)}". Does the file exist?`, pos);
+                    return this.error(`Failed to resolve import "${url}" from "${path$n.relative(process.cwd(), importerFile)}". Does the file exist?`, pos);
                 }
                 // normalize all imports into resolved URLs
                 // e.g. `import 'foo'` -> `import '/@fs/.../node_modules/foo/index.js'`
@@ -41021,7 +41056,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await import('./dep-001f95ce.js').then(function (n) { return n.c; });
+    const { parse, transform } = await import('./dep-7d66befd.js').then(function (n) { return n.c; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -42151,7 +42186,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-0921e73a.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-adbb28b2.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -43347,10 +43382,10 @@ async function doBuild(inlineConfig = {}) {
                     ? `[name].${jsExt}`
                     : libOptions
                         ? resolveLibFilename(libOptions, format, config.root, jsExt)
-                        : path$n.posix.join(options.assetsDir, `[name].[hash].js`),
+                        : path$n.posix.join(options.assetsDir, `[name].[hash].${jsExt}`),
                 chunkFileNames: libOptions
                     ? `[name].[hash].${jsExt}`
-                    : path$n.posix.join(options.assetsDir, `[name].[hash].js`),
+                    : path$n.posix.join(options.assetsDir, `[name].[hash].${jsExt}`),
                 assetFileNames: libOptions
                     ? `[name].[ext]`
                     : path$n.posix.join(options.assetsDir, `[name].[hash].[ext]`),
@@ -56927,16 +56962,29 @@ function proxyMiddleware(httpServer, options, config) {
             opts = { target: opts, changeOrigin: true };
         }
         const proxy = httpProxy.createProxyServer(opts);
-        proxy.on('error', (err, req, res) => {
-            config.logger.error(`${picocolors.exports.red(`http proxy error:`)}\n${err.stack}`, {
-                timestamp: true,
-                error: err
-            });
-            res
-                .writeHead(500, {
-                'Content-Type': 'text/plain'
-            })
-                .end();
+        proxy.on('error', (err, req, originalRes) => {
+            // When it is ws proxy, res is net.Socket
+            const res = originalRes;
+            if ('req' in res) {
+                config.logger.error(`${picocolors.exports.red(`http proxy error:`)}\n${err.stack}`, {
+                    timestamp: true,
+                    error: err
+                });
+                if (!res.writableEnded) {
+                    res
+                        .writeHead(500, {
+                        'Content-Type': 'text/plain'
+                    })
+                        .end();
+                }
+            }
+            else {
+                config.logger.error(`${picocolors.exports.red(`ws proxy error:`)}\n${err.stack}`, {
+                    timestamp: true,
+                    error: err
+                });
+                res.end();
+            }
         });
         if (opts.configure) {
             opts.configure(proxy, opts);
@@ -58924,8 +58972,9 @@ async function createServer(inlineConfig = {}) {
         pluginContainer: container,
         ws,
         moduleGraph,
+        resolvedUrls: null,
         ssrTransform(code, inMap, url) {
-            return ssrTransform(code, inMap, url, {
+            return ssrTransform(code, inMap, url, code, {
                 json: { stringify: server.config.json?.stringify }
             });
         },
@@ -58949,8 +58998,12 @@ async function createServer(inlineConfig = {}) {
         ssrRewriteStacktrace(stack) {
             return ssrRewriteStacktrace(stack, moduleGraph);
         },
-        listen(port, isRestart) {
-            return startServer(server, port, isRestart);
+        async listen(port, isRestart) {
+            await startServer(server, port, isRestart);
+            if (httpServer) {
+                server.resolvedUrls = await resolveServerUrls(httpServer, config.server, config);
+            }
+            return server;
         },
         async close() {
             if (!middlewareMode) {
@@ -58965,14 +59018,18 @@ async function createServer(inlineConfig = {}) {
                 container.close(),
                 closeHttpServer()
             ]);
+            server.resolvedUrls = null;
         },
-        async printUrls() {
-            if (httpServer) {
-                await printCommonServerUrls(httpServer, config.server, config);
+        printUrls() {
+            if (server.resolvedUrls) {
+                printServerUrls(server.resolvedUrls, serverConfig.host, config.logger.info);
             }
-            else {
+            else if (middlewareMode) {
                 throw new Error('cannot print server URLs in middleware mode.');
             }
+            else {
+                throw new Error('cannot print server URLs before server.listen is called.');
+            }
         },
         async restart(forceOptimize) {
             if (!server._restartPromise) {
@@ -59181,7 +59238,6 @@ async function startServer(server, inlinePort, isRestart = false) {
             ? path
             : `${protocol}://${hostname.name}:${serverPort}${path}`, true, server.config.logger);
     }
-    return server;
 }
 function createServerCloseFn(server) {
     if (!server) {
@@ -59488,6 +59544,7 @@ async function preview(inlineConfig = {}) {
         host: hostname.host,
         logger
     });
+    const resolvedUrls = await resolveServerUrls(httpServer, config.preview, config);
     if (options.open) {
         const path = typeof options.open === 'string' ? options.open : previewBase;
         openBrowser(path.startsWith('http')
@@ -59497,8 +59554,9 @@ async function preview(inlineConfig = {}) {
     return {
         config,
         httpServer,
-        async printUrls() {
-            await printCommonServerUrls(httpServer, config.preview, config);
+        resolvedUrls,
+        printUrls() {
+            printServerUrls(resolvedUrls, options.host, logger.info);
         }
     };
 }
@@ -59521,6 +59579,10 @@ function clientInjectionsPlugin(config) {
         name: 'vite:client-inject',
         async transform(code, id, options) {
             if (id === normalizedClientEntry || id === normalizedEnvEntry) {
+                const resolvedServerHostname = (await resolveHostname(config.server.host)).name;
+                const resolvedServerPort = config.server.port;
+                const devBase = config.base;
+                const serverHost = `${resolvedServerHostname}:${resolvedServerPort}${devBase}`;
                 let hmrConfig = config.server.hmr;
                 hmrConfig = isObject$2(hmrConfig) ? hmrConfig : undefined;
                 const host = hmrConfig?.host || null;
@@ -59533,9 +59595,8 @@ function clientInjectionsPlugin(config) {
                 if (config.server.middlewareMode) {
                     port || (port = 24678);
                 }
-                const devBase = config.base;
-                let directTarget = hmrConfig?.host || (await resolveHostname(config.server.host)).name;
-                directTarget += `:${hmrConfig?.port || config.server.port}`;
+                let directTarget = hmrConfig?.host || resolvedServerHostname;
+                directTarget += `:${hmrConfig?.port || resolvedServerPort}`;
                 directTarget += devBase;
                 let hmrBase = devBase;
                 if (hmrConfig?.path) {
@@ -59545,6 +59606,7 @@ function clientInjectionsPlugin(config) {
                     .replace(`__MODE__`, JSON.stringify(config.mode))
                     .replace(`__BASE__`, JSON.stringify(devBase))
                     .replace(`__DEFINES__`, serializeDefine(config.define || {}))
+                    .replace(`__SERVER_HOST__`, JSON.stringify(serverHost))
                     .replace(`__HMR_PROTOCOL__`, JSON.stringify(protocol))
                     .replace(`__HMR_HOSTNAME__`, JSON.stringify(host))
                     .replace(`__HMR_PORT__`, JSON.stringify(port))
@@ -62238,7 +62300,6 @@ function defineConfig(config) {
     return config;
 }
 async function resolveConfig(inlineConfig, command, defaultMode = 'development') {
-    var _a;
     let config = inlineConfig;
     let configFileDependencies = [];
     let mode = inlineConfig.mode || defaultMode;
@@ -62248,6 +62309,10 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
     if (mode === 'production') {
         process.env.NODE_ENV = 'production';
     }
+    // production env would not work in serve, fallback to development
+    if (command === 'serve' && process.env.NODE_ENV === 'production') {
+        process.env.NODE_ENV = 'development';
+    }
     const configEnv = {
         mode,
         command,
@@ -62302,6 +62367,14 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
             }
         }
     }
+    if (process.env.VITE_TEST_WITHOUT_PLUGIN_COMMONJS) {
+        config = mergeConfig(config, {
+            optimizeDeps: { disabled: false },
+            ssr: { optimizeDeps: { disabled: false } }
+        });
+        config.build ?? (config.build = {});
+        config.build.commonjsOptions = { include: [] };
+    }
     // resolve root
     const resolvedRoot = normalizePath$3(config.root ? path$n.resolve(config.root) : process.cwd());
     const clientAlias = [
@@ -62401,15 +62474,6 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
     const ssr = resolveSSROptions(config.ssr, config.legacy?.buildSsrCjsExternalHeuristics, config.resolve?.preserveSymlinks);
     const middlewareMode = config?.server?.middlewareMode;
     const optimizeDeps = config.optimizeDeps || {};
-    if (process.env.VITE_TEST_WITHOUT_PLUGIN_COMMONJS) {
-        config.build ?? (config.build = {});
-        config.build.commonjsOptions = { include: [] };
-        config.optimizeDeps ?? (config.optimizeDeps = {});
-        config.optimizeDeps.disabled = false;
-        config.ssr ?? (config.ssr = {});
-        (_a = config.ssr).optimizeDeps ?? (_a.optimizeDeps = {});
-        config.ssr.optimizeDeps.disabled = false;
-    }
     const BASE_URL = resolvedBase;
     const resolved = {
         ...config,
@@ -62568,7 +62632,6 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
     const start = performance.now();
     const getTime = () => `${(performance.now() - start).toFixed(2)}ms`;
     let resolvedPath;
-    let dependencies = [];
     if (configFile) {
         // explicit config path is always resolved from cwd
         resolvedPath = path$n.resolve(configFile);
@@ -62604,41 +62667,9 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
         catch (e) { }
     }
     try {
-        let userConfig;
-        if (isESM) {
-            const fileUrl = pathToFileURL(resolvedPath);
-            const bundled = await bundleConfigFile(resolvedPath, true);
-            dependencies = bundled.dependencies;
-            if (isTS(resolvedPath)) {
-                // before we can register loaders without requiring users to run node
-                // with --experimental-loader themselves, we have to do a hack here:
-                // bundle the config file w/ ts transforms first, write it to disk,
-                // load it with native Node ESM, then delete the file.
-                fs$l.writeFileSync(resolvedPath + '.mjs', bundled.code);
-                try {
-                    userConfig = (await dynamicImport(`${fileUrl}.mjs?t=${Date.now()}`))
-                        .default;
-                }
-                finally {
-                    fs$l.unlinkSync(resolvedPath + '.mjs');
-                }
-                debug(`TS + native esm config loaded in ${getTime()}`, fileUrl);
-            }
-            else {
-                // using Function to avoid this from being compiled away by TS/Rollup
-                // append a query so that we force reload fresh config in case of
-                // server restart
-                userConfig = (await dynamicImport(`${fileUrl}?t=${Date.now()}`)).default;
-                debug(`native esm config loaded in ${getTime()}`, fileUrl);
-            }
-        }
-        if (!userConfig) {
-            // Bundle config file and transpile it to cjs using esbuild.
-            const bundled = await bundleConfigFile(resolvedPath);
-            dependencies = bundled.dependencies;
-            userConfig = await loadConfigFromBundledFile(resolvedPath, bundled.code);
-            debug(`bundled config file loaded in ${getTime()}`);
-        }
+        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);
@@ -62648,7 +62679,7 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
         return {
             path: normalizePath$3(resolvedPath),
             config,
-            dependencies
+            dependencies: bundled.dependencies
         };
     }
     catch (e) {
@@ -62656,7 +62687,9 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
         throw e;
     }
 }
-async function bundleConfigFile(fileName, isESM = false) {
+async function bundleConfigFile(fileName, isESM) {
+    const dirnameVarName = '__vite_injected_original_dirname';
+    const filenameVarName = '__vite_injected_original_filename';
     const importMetaUrlVarName = '__vite_injected_original_import_meta_url';
     const result = await build$3({
         absWorkingDir: process.cwd(),
@@ -62669,19 +62702,48 @@ async function bundleConfigFile(fileName, isESM = false) {
         sourcemap: 'inline',
         metafile: true,
         define: {
+            __dirname: dirnameVarName,
+            __filename: filenameVarName,
             'import.meta.url': importMetaUrlVarName
         },
         plugins: [
             {
                 name: 'externalize-deps',
                 setup(build) {
-                    build.onResolve({ filter: /.*/ }, (args) => {
-                        const id = args.path;
+                    build.onResolve({ filter: /.*/ }, ({ path: id, importer }) => {
+                        // externalize bare imports
                         if (id[0] !== '.' && !path$n.isAbsolute(id)) {
                             return {
                                 external: true
                             };
                         }
+                        // bundle the rest and make sure that the we can also access
+                        // it's third-party dependencies. externalize if not.
+                        // monorepo/
+                        // ├─ package.json
+                        // ├─ utils.js -----------> bundle (share same node_modules)
+                        // ├─ vite-project/
+                        // │  ├─ vite.config.js --> entry
+                        // │  ├─ package.json
+                        // ├─ foo-project/
+                        // │  ├─ utils.js --------> external (has own node_modules)
+                        // │  ├─ package.json
+                        const idFsPath = path$n.resolve(path$n.dirname(importer), id);
+                        const idPkgPath = lookupFile(idFsPath, [`package.json`], {
+                            pathOnly: true
+                        });
+                        if (idPkgPath) {
+                            const idPkgDir = path$n.dirname(idPkgPath);
+                            // if this file needs to go up one or more directory to reach the vite config,
+                            // that means it has it's own node_modules (e.g. foo-project)
+                            if (path$n.relative(idPkgDir, fileName).startsWith('..')) {
+                                return {
+                                    // normalize actual import after bundled as a single vite config
+                                    path: idFsPath,
+                                    external: true
+                                };
+                            }
+                        }
                     });
                 }
             },
@@ -62690,11 +62752,11 @@ async function bundleConfigFile(fileName, isESM = false) {
                 setup(build) {
                     build.onLoad({ filter: /\.[cm]?[jt]s$/ }, async (args) => {
                         const contents = await fs$l.promises.readFile(args.path, 'utf8');
-                        const injectValues = `const __dirname = ${JSON.stringify(path$n.dirname(args.path))};` +
-                            `const __filename = ${JSON.stringify(args.path)};` +
+                        const injectValues = `const ${dirnameVarName} = ${JSON.stringify(path$n.dirname(args.path))};` +
+                            `const ${filenameVarName} = ${JSON.stringify(args.path)};` +
                             `const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(args.path).href)};`;
                         return {
-                            loader: isTS(args.path) ? 'ts' : 'js',
+                            loader: args.path.endsWith('ts') ? 'ts' : 'js',
                             contents: injectValues + contents
                         };
                     });
@@ -62709,22 +62771,40 @@ async function bundleConfigFile(fileName, isESM = false) {
     };
 }
 const _require = createRequire$1(import.meta.url);
-async function loadConfigFromBundledFile(fileName, bundledCode) {
-    const realFileName = fs$l.realpathSync(fileName);
-    const defaultLoader = _require.extensions['.js'];
-    _require.extensions['.js'] = (module, filename) => {
-        if (filename === realFileName) {
-            module._compile(bundledCode, filename);
+async function loadConfigFromBundledFile(fileName, bundledCode, isESM) {
+    // for esm, before we can register loaders without requiring users to run node
+    // with --experimental-loader themselves, we have to do a hack here:
+    // write it to disk, load it with native Node ESM, then delete the file.
+    if (isESM) {
+        const fileUrl = pathToFileURL(fileName);
+        fs$l.writeFileSync(fileName + '.mjs', bundledCode);
+        try {
+            return (await dynamicImport(`${fileUrl}.mjs?t=${Date.now()}`)).default;
         }
-        else {
-            defaultLoader(module, filename);
+        finally {
+            fs$l.unlinkSync(fileName + '.mjs');
         }
-    };
-    // clear cache in case of server restart
-    delete _require.cache[_require.resolve(fileName)];
-    const raw = _require(fileName);
-    _require.extensions['.js'] = defaultLoader;
-    return raw.__esModule ? raw.default : raw;
+    }
+    // for cjs, we can register a custom loader via `_require.extensions`
+    else {
+        const extension = path$n.extname(fileName);
+        const realFileName = fs$l.realpathSync(fileName);
+        const loaderExt = extension in _require.extensions ? extension : '.js';
+        const defaultLoader = _require.extensions[loaderExt];
+        _require.extensions[loaderExt] = (module, filename) => {
+            if (filename === realFileName) {
+                module._compile(bundledCode, filename);
+            }
+            else {
+                defaultLoader(module, filename);
+            }
+        };
+        // clear cache in case of server restart
+        delete _require.cache[_require.resolve(fileName)];
+        const raw = _require(fileName);
+        _require.extensions[loaderExt] = defaultLoader;
+        return raw.__esModule ? raw.default : raw;
+    }
 }
 function getDepOptimizationConfig(config, ssr) {
     return ssr ? config.ssr.optimizeDeps : config.optimizeDeps;