vite 3.0.0-beta.9 → 3.0.2

package/dist/node/chunks/{dep-58325dc2.js → dep-1513d487.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))) {
@@ -36116,7 +36137,7 @@ function getDepsOptimizer(config, ssr) {
 }
 async function initDepsOptimizer(config, server) {
     // Non Dev SSR Optimizer
-    const ssr = !!config.build.ssr;
+    const ssr = config.command === 'build' && !!config.build.ssr;
     if (!getDepsOptimizer(config, ssr)) {
         await createDepsOptimizer(config, server);
     }
@@ -36147,7 +36168,7 @@ async function initDevSsrDepsOptimizer(config, server) {
 async function createDepsOptimizer(config, server) {
     const { logger } = config;
     const isBuild = config.command === 'build';
-    const ssr = !!config.build.ssr; // safe as Dev SSR don't use this optimizer
+    const ssr = isBuild && !!config.build.ssr; // safe as Dev SSR don't use this optimizer
     const sessionTimestamp = Date.now().toString();
     const cachedMetadata = loadCachedDepOptimizationMetadata(config, ssr);
     let handle;
@@ -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,11 +36679,12 @@ 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;
-    const ssr = !!config.build.ssr;
+    const ssr = config.command === 'build' && !!config.build.ssr;
     const cachedMetadata = loadCachedDepOptimizationMetadata(config, ssr, force, asCommand);
     if (cachedMetadata) {
         return cachedMetadata;
@@ -36797,7 +36819,8 @@ function depsLogString(qualifiedIds) {
  * Internally, Vite uses this function to prepare a optimizeDeps run. When Vite starts, we can get
  * the metadata and start the server without waiting for the optimizeDeps processing to be completed
  */
-async function runOptimizeDeps(resolvedConfig, depsInfo, ssr = !!resolvedConfig.build.ssr) {
+async function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.command === 'build' &&
+    !!resolvedConfig.build.ssr) {
     const isBuild = resolvedConfig.command === 'build';
     const config = {
         ...resolvedConfig,
@@ -37023,7 +37046,7 @@ function newDepOptimizationProcessing() {
 function depsFromOptimizedDepInfo(depsInfo) {
     return Object.fromEntries(Object.entries(depsInfo).map((d) => [d[0], d[1].src]));
 }
-function getOptimizedDepPath(id, config, ssr = !!config.build.ssr) {
+function getOptimizedDepPath(id, config, ssr) {
     return normalizePath$3(path$n.resolve(getDepsCacheDir(config, ssr), flattenId(id) + '.js'));
 }
 function getDepsCacheSuffix(config, ssr) {
@@ -37963,13 +37986,17 @@ function createIsConfiguredAsSsrExternal(config) {
     return (id) => {
         const { ssr } = config;
         if (ssr) {
-            if (ssr.external?.includes(id)) {
+            const pkgName = getNpmPackageName(id);
+            if (!pkgName) {
+                return undefined;
+            }
+            if (ssr.external?.includes(pkgName)) {
                 return true;
             }
             if (typeof noExternal === 'boolean') {
                 return !noExternal;
             }
-            if (noExternalFilter && !noExternalFilter(id)) {
+            if (noExternalFilter && !noExternalFilter(pkgName)) {
                 return false;
             }
         }
@@ -38783,11 +38810,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 {
@@ -38797,7 +38824,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 {
@@ -38976,11 +39003,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(),
@@ -39472,32 +39501,36 @@ function serveStaticMiddleware(dir, server) {
             isInternalRequest(req.url)) {
             return next();
         }
-        const url = decodeURIComponent(req.url);
+        const url = new URL(req.url, 'http://example.com');
+        const pathname = decodeURIComponent(url.pathname);
         // apply aliases to static requests as well
-        let redirected;
+        let redirectedPathname;
         for (const { find, replacement } of server.config.resolve.alias) {
-            const matches = typeof find === 'string' ? url.startsWith(find) : find.test(url);
+            const matches = typeof find === 'string'
+                ? pathname.startsWith(find)
+                : find.test(pathname);
             if (matches) {
-                redirected = url.replace(find, replacement);
+                redirectedPathname = pathname.replace(find, replacement);
                 break;
             }
         }
-        if (redirected) {
+        if (redirectedPathname) {
             // dir is pre-normalized to posix style
-            if (redirected.startsWith(dir)) {
-                redirected = redirected.slice(dir.length);
+            if (redirectedPathname.startsWith(dir)) {
+                redirectedPathname = redirectedPathname.slice(dir.length);
             }
         }
-        const resolvedUrl = redirected || url;
-        let fileUrl = path$n.resolve(dir, resolvedUrl.replace(/^\//, ''));
-        if (resolvedUrl.endsWith('/') && !fileUrl.endsWith('/')) {
+        const resolvedPathname = redirectedPathname || pathname;
+        let fileUrl = path$n.resolve(dir, resolvedPathname.replace(/^\//, ''));
+        if (resolvedPathname.endsWith('/') && !fileUrl.endsWith('/')) {
             fileUrl = fileUrl + '/';
         }
         if (!ensureServingAccess(fileUrl, server, res, next)) {
             return;
         }
-        if (redirected) {
-            req.url = encodeURIComponent(redirected);
+        if (redirectedPathname) {
+            url.pathname = encodeURIComponent(redirectedPathname);
+            req.url = url.href.slice(url.origin.length);
         }
         serve(req, res, next);
     };
@@ -39506,20 +39539,22 @@ function serveRawFsMiddleware(server) {
     const serveFromRoot = sirv('/', sirvOptions(server.config.server.headers));
     // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
     return function viteServeRawFsMiddleware(req, res, next) {
-        let url = decodeURIComponent(req.url);
+        const url = new URL(req.url, 'http://example.com');
         // In some cases (e.g. linked monorepos) files outside of root will
         // reference assets that are also out of served root. In such cases
         // the paths are rewritten to `/@fs/` prefixed paths and must be served by
         // searching based from fs root.
-        if (url.startsWith(FS_PREFIX)) {
+        if (url.pathname.startsWith(FS_PREFIX)) {
+            const pathname = decodeURIComponent(url.pathname);
             // restrict files outside of `fs.allow`
-            if (!ensureServingAccess(slash$1(path$n.resolve(fsPathFromId(url))), server, res, next)) {
+            if (!ensureServingAccess(slash$1(path$n.resolve(fsPathFromId(pathname))), server, res, next)) {
                 return;
             }
-            url = url.slice(FS_PREFIX.length);
+            let newPathname = pathname.slice(FS_PREFIX.length);
             if (isWindows$4)
-                url = url.replace(/^[A-Z]:/i, '');
-            req.url = encodeURIComponent(url);
+                newPathname = newPathname.replace(/^[A-Z]:/i, '');
+            url.pathname = encodeURIComponent(newPathname);
+            req.url = url.href.slice(url.origin.length);
             serveFromRoot(req, res, next);
         }
         else {
@@ -39742,6 +39777,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
@@ -39760,7 +39796,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 }
         })
         : {
@@ -40106,7 +40142,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);
@@ -40652,7 +40688,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'`
@@ -41027,7 +41063,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await import('./dep-235df460.js').then(function (n) { return n.c; });
+    const { parse, transform } = await import('./dep-3f457808.js').then(function (n) { return n.c; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -42157,7 +42193,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-21ac9d2b.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-f07a4e2f.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -43353,10 +43389,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]`),
@@ -50247,7 +50283,8 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
         if (dep[0] !== '.' && dep[0] !== '/') {
             return nodeImport(dep, mod.file, resolveOptions);
         }
-        dep = unwrapId(dep);
+        // convert to rollup URL because `pendingImports`, `moduleGraph.urlToModuleMap` requires that
+        dep = unwrapId(dep).replace(NULL_BYTE_PLACEHOLDER, '\0');
         if (!isCircular(dep) && !pendingImports.get(dep)?.some(isCircular)) {
             pendingDeps.push(dep);
             if (pendingDeps.length === 1) {
@@ -53491,11 +53528,11 @@ function initAsClient(websocket, address, protocols, options) {
     ? parsedUrl.hostname.slice(1, -1)
     : parsedUrl.hostname;
   opts.headers = {
+    ...opts.headers,
     'Sec-WebSocket-Version': opts.protocolVersion,
     'Sec-WebSocket-Key': key,
     Connection: 'Upgrade',
-    Upgrade: 'websocket',
-    ...opts.headers
+    Upgrade: 'websocket'
   };
   opts.path = parsedUrl.pathname + parsedUrl.search;
   opts.timeout = opts.handshakeTimeout;
@@ -53549,8 +53586,11 @@ function initAsClient(websocket, address, protocols, options) {
 
   if (opts.followRedirects) {
     if (websocket._redirects === 0) {
+      websocket._originalUnixSocket = isUnixSocket;
       websocket._originalSecure = isSecure;
-      websocket._originalHost = parsedUrl.host;
+      websocket._originalHostOrSocketPath = isUnixSocket
+        ? opts.socketPath
+        : parsedUrl.host;
 
       const headers = options && options.headers;
 
@@ -53566,7 +53606,13 @@ function initAsClient(websocket, address, protocols, options) {
         }
       }
     } else if (websocket.listenerCount('redirect') === 0) {
-      const isSameHost = parsedUrl.host === websocket._originalHost;
+      const isSameHost = isUnixSocket
+        ? websocket._originalUnixSocket
+          ? opts.socketPath === websocket._originalHostOrSocketPath
+          : false
+        : websocket._originalUnixSocket
+        ? false
+        : parsedUrl.host === websocket._originalHostOrSocketPath;
 
       if (!isSameHost || (websocket._originalSecure && !isSecure)) {
         //
@@ -56933,16 +56979,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.headersSent && !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);
@@ -57724,10 +57783,14 @@ class ModuleGraph {
         url = removeImportQuery(removeTimestampQuery(url));
         const resolved = await this.resolveId(url, !!ssr);
         const resolvedId = resolved?.id || url;
-        const ext = extname$1(cleanUrl(resolvedId));
-        const { pathname, search, hash } = parse$k(url);
-        if (ext && !pathname.endsWith(ext)) {
-            url = pathname + ext + (search || '') + (hash || '');
+        if (url !== resolvedId &&
+            !url.includes('\0') &&
+            !url.startsWith(`virtual:`)) {
+            const ext = extname$1(cleanUrl(resolvedId));
+            const { pathname, search, hash } = new URL(url, 'relative://');
+            if (ext && !pathname.endsWith(ext)) {
+                url = pathname + ext + search + hash;
+            }
         }
         return [url, resolvedId, resolved?.meta];
     }
@@ -58930,8 +58993,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 }
             });
         },
@@ -58955,8 +59019,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) {
@@ -58971,14 +59039,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) {
@@ -59187,7 +59259,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) {
@@ -59494,6 +59565,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')
@@ -59503,8 +59575,9 @@ async function preview(inlineConfig = {}) {
     return {
         config,
         httpServer,
-        async printUrls() {
-            await printCommonServerUrls(httpServer, config.preview, config);
+        resolvedUrls,
+        printUrls() {
+            printServerUrls(resolvedUrls, options.host, logger.info);
         }
     };
 }
@@ -59527,6 +59600,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;
@@ -59539,9 +59616,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) {
@@ -59551,6 +59627,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))
@@ -61942,7 +62019,7 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
         wasmFallbackPlugin(),
         definePlugin(config),
         cssPostPlugin(config),
-        config.build.ssr ? ssrRequireHookPlugin(config) : null,
+        isBuild && config.build.ssr ? ssrRequireHookPlugin(config) : null,
         isBuild && buildHtmlPlugin(config),
         workerImportMetaUrlPlugin(config),
         ...buildPlugins.pre,
@@ -62244,7 +62321,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;
@@ -62254,6 +62330,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,
@@ -62308,6 +62388,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 = [
@@ -62407,15 +62495,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,
@@ -62574,7 +62653,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);
@@ -62610,41 +62688,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);
@@ -62654,7 +62700,7 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
         return {
             path: normalizePath$3(resolvedPath),
             config,
-            dependencies
+            dependencies: bundled.dependencies
         };
     }
     catch (e) {
@@ -62662,7 +62708,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(),
@@ -62675,19 +62723,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
+                                };
+                            }
+                        }
                     });
                 }
             },
@@ -62696,11 +62773,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
                         };
                     });
@@ -62715,22 +62792,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;