vite 3.0.0-alpha.5 → 3.0.0-alpha.8

package/dist/node/chunks/{dep-0232e200.js → dep-8250f392.js}

@@ -11567,7 +11567,7 @@ function writeFile(filename, content) {
     fs__default.writeFileSync(filename, content);
 }
 /**
- * Use instead of fs.existsSync(filename)
+ * 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)
@@ -11939,6 +11939,14 @@ function normalizeSingleAlias({ find, replacement, customResolver }) {
     }
     return alias;
 }
+function transformResult(s, id, config) {
+    const isBuild = config.command === 'build';
+    const needSourceMap = !isBuild || config.build.sourcemap;
+    return {
+        code: s.toString(),
+        map: needSourceMap ? s.generateMap({ hires: true, source: id }) : null
+    };
+}
 
 /* eslint no-console: 0 */
 const LogLevels = {
@@ -14682,7 +14690,7 @@ const debug$c = createDebugger('vite:resolve-details', {
     onlyWhenFocused: true
 });
 function resolvePlugin(baseOptions) {
-    const { root, isProduction, asSrc, ssrConfig, preferRelative = false } = baseOptions;
+    const { root, isBuild, isProduction, asSrc, ssrConfig, preferRelative = false } = baseOptions;
     const { target: ssrTarget, noExternal: ssrNoExternal } = ssrConfig ?? {};
     return {
         name: 'vite:resolve',
@@ -14809,18 +14817,20 @@ function resolvePlugin(baseOptions) {
             }
             // bare package imports, perform node resolve
             if (bareImportRE.test(id)) {
-                if (asSrc &&
+                const external = options.shouldExternalize?.(id);
+                if (!external &&
+                    asSrc &&
                     depsOptimizer &&
-                    !ssr &&
+                    (isBuild || !ssr) &&
                     !options.scan &&
                     (res = await tryOptimizedResolve(depsOptimizer, id, importer))) {
                     return res;
                 }
                 if (targetWeb &&
-                    (res = tryResolveBrowserMapping(id, importer, options, false))) {
+                    (res = tryResolveBrowserMapping(id, importer, options, false, external))) {
                     return res;
                 }
-                if ((res = tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr))) {
+                if ((res = tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, external))) {
                     return res;
                 }
                 // node built-ins.
@@ -14951,7 +14961,7 @@ function tryResolveFile(file, postfix, options, tryIndex, targetWeb, tryPrefix,
     }
 }
 const idToPkgMap = new Map();
-function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr) {
+function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, externalize) {
     const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
     // split id by last '>' for nested selected packages, for example:
     // 'foo > bar > baz' => 'foo > bar' & 'baz'
@@ -15005,7 +15015,8 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr) {
     }
     let resolveId = resolvePackageEntry;
     let unresolvedId = pkgId;
-    if (unresolvedId !== nestedPath) {
+    const isDeepImport = unresolvedId !== nestedPath;
+    if (isDeepImport) {
         resolveId = resolveDeepImport;
         unresolvedId = '.' + nestedPath.slice(pkgId.length);
     }
@@ -15029,15 +15040,23 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr) {
     if (!resolved) {
         return;
     }
+    const processResult = (resolved) => {
+        if (!externalize) {
+            return resolved;
+        }
+        const resolvedExt = path$p.extname(resolved.id);
+        const resolvedId = isDeepImport && path$p.extname(id) !== resolvedExt ? id + resolvedExt : id;
+        return { ...resolved, id: resolvedId, external: true };
+    };
     // link id to pkg for browser field mapping check
     idToPkgMap.set(resolved, pkg);
-    if (isBuild && !depsOptimizer) {
+    if ((isBuild && !depsOptimizer) || externalize) {
         // Resolve package side effects for build so that rollup can better
         // perform tree-shaking
-        return {
+        return processResult({
             id: resolved,
             moduleSideEffects: pkg.hasSideEffects(resolved)
-        };
+        });
     }
     if (!resolved.includes('node_modules') || // linked
         !depsOptimizer || // resolving before listening to the server
@@ -15053,7 +15072,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr) {
         exclude?.includes(pkgId) ||
         exclude?.includes(nestedPath) ||
         SPECIAL_QUERY_RE.test(resolved) ||
-        ssr) {
+        (!isBuild && ssr)) {
         // excluded from optimization
         // Inject a version query to npm deps so that the browser
         // can cache it without re-validation, but only do so for known js types.
@@ -15067,7 +15086,6 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr) {
         }
     }
     else {
-        // TODO: depsBuild
         // this is a missing import, queue optimize-deps re-run and
         // get a resolved its optimized info
         const optimizedInfo = depsOptimizer.registerMissingImport(id, resolved);
@@ -15282,7 +15300,7 @@ function resolveDeepImport(id, { webResolvedImports, setResolvedCache, getResolv
         }
     }
 }
-function tryResolveBrowserMapping(id, importer, options, isFilePath) {
+function tryResolveBrowserMapping(id, importer, options, isFilePath, externalize) {
     let res;
     const pkg = importer && idToPkgMap.get(importer);
     if (pkg && isObject$2(pkg.data.browser)) {
@@ -15294,10 +15312,11 @@ function tryResolveBrowserMapping(id, importer, options, isFilePath) {
                 isDebug$4 &&
                     debug$c(`[browser mapped] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
                 idToPkgMap.set(res, pkg);
-                return {
+                const result = {
                     id: res,
                     moduleSideEffects: pkg.hasSideEffects(res)
                 };
+                return externalize ? { ...result, external: true } : result;
             }
         }
         else if (browserMappedPath === false) {
@@ -15464,9 +15483,8 @@ function esbuildDepPlugin(qualified, exportsData, config) {
                     relativePath = `./${relativePath}`;
                 }
                 let contents = '';
-                const data = exportsData[id];
-                const [imports, exports] = data;
-                if (!imports.length && !exports.length) {
+                const { hasImports, exports, hasReExports } = exportsData[id];
+                if (!hasImports && !exports.length) {
                     // cjs
                     contents += `export default require("${relativePath}");`;
                 }
@@ -15474,9 +15492,7 @@ function esbuildDepPlugin(qualified, exportsData, config) {
                     if (exports.includes('default')) {
                         contents += `import d from "${relativePath}";export default d;`;
                     }
-                    if (data.hasReExports ||
-                        exports.length > 1 ||
-                        exports[0] !== 'default') {
+                    if (hasReExports || exports.length > 1 || exports[0] !== 'default') {
                         contents += `\nexport * from "${relativePath}"`;
                     }
                 }
@@ -26231,10 +26247,7 @@ function importGlobPlugin(config) {
                         server.watcher.add(dirname(file));
                     });
                 }
-                return {
-                    code: result.s.toString(),
-                    map: config.build.sourcemap ? result.s.generateMap() : null
-                };
+                return transformResult(result.s, id, config);
             }
         }
     };
@@ -26773,9 +26786,18 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                             (loader.startsWith('ts') ? extractImportPaths(content) : '');
                         const key = `${path}?id=${scriptId++}`;
                         if (contents.includes('import.meta.glob')) {
+                            let transpiledContents;
+                            // transpile because `transformGlobImport` only expects js
+                            if (loader !== 'js') {
+                                transpiledContents = (await transform$2(contents, { loader }))
+                                    .code;
+                            }
+                            else {
+                                transpiledContents = contents;
+                            }
                             scripts[key] = {
                                 loader: 'js',
-                                contents: (await transformGlobImport(contents, path, config.root, resolve))?.s.toString() || contents
+                                contents: (await transformGlobImport(transpiledContents, path, config.root, resolve))?.s.toString() || transpiledContents
                             };
                         }
                         else {
@@ -26962,6 +26984,7 @@ function getDepsOptimizer(config) {
 async function initDepsOptimizer(config, server) {
     const { logger } = config;
     const isBuild = config.command === 'build';
+    const scan = config.command !== 'build' && config.optimizeDeps.devScan;
     const sessionTimestamp = Date.now().toString();
     const cachedMetadata = loadCachedDepOptimizationMetadata(config);
     let handle;
@@ -27000,7 +27023,7 @@ async function initDepsOptimizer(config, server) {
     // If there wasn't a cache or it is outdated, we need to prepare a first run
     let firstRunCalled = !!cachedMetadata;
     if (!cachedMetadata) {
-        if (isBuild) {
+        if (!scan) {
             // Initialize discovered deps with manually added optimizeDeps.include info
             const discovered = await initialProjectDependencies(config, sessionTimestamp);
             const { metadata } = depsOptimizer;
@@ -27267,9 +27290,13 @@ async function initDepsOptimizer(config, server) {
             processing: depOptimizationProcessing.promise,
             exportsData: extractExportsData(resolved, config)
         });
-        // Debounced rerun, let other missing dependencies be discovered before
-        // the running next optimizeDeps
-        if (!isBuild) {
+        // Until the first optimize run is called, avoid triggering processing
+        // We'll wait until the user codebase is eagerly processed by Vite so
+        // we can get a list of every missing dependency before giving to the
+        // browser a dependency that may be outdated, thus avoiding full page reloads
+        if (scan || firstRunCalled) {
+            // Debounced rerun, let other missing dependencies be discovered before
+            // the running next optimizeDeps
             debouncedProcessing();
         }
         // Return the path for the optimized bundle, this path is known before
@@ -27506,7 +27533,7 @@ async function runOptimizeDeps(resolvedConfig, depsInfo) {
         splitting: true,
         sourcemap: true,
         outdir: processingCacheDir,
-        ignoreAnnotations: true,
+        ignoreAnnotations: resolvedConfig.command !== 'build',
         metafile: true,
         define,
         plugins: [
@@ -27592,12 +27619,22 @@ function depsFromOptimizedDepInfo(depsInfo) {
 function getOptimizedDepPath(id, config) {
     return normalizePath$3(path$p.resolve(getDepsCacheDir(config), flattenId(id) + '.js'));
 }
+function getDepsCacheSuffix(config) {
+    let suffix = '';
+    if (config.command === 'build') {
+        suffix += '_build';
+        if (config.build.ssr) {
+            suffix += '_ssr';
+        }
+    }
+    return suffix;
+}
 function getDepsCacheDir(config) {
-    const dirName = config.command === 'build' ? 'depsBuild' : 'deps';
+    const dirName = 'deps' + getDepsCacheSuffix(config);
     return normalizePath$3(path$p.resolve(config.cacheDir, dirName));
 }
 function getProcessingDepsCacheDir(config) {
-    const dirName = config.command === 'build' ? 'processingBuild' : 'processing';
+    const dirName = 'deps' + getDepsCacheSuffix(config) + '_temp';
     return normalizePath$3(path$p.resolve(config.cacheDir, dirName));
 }
 function isOptimizedDepFile(id, config) {
@@ -27694,7 +27731,6 @@ function esbuildOutputFromId(outputs, id, cacheDirOutputPath) {
 }
 async function extractExportsData(filePath, config) {
     await init;
-    let exportsData;
     const esbuildOptions = config.optimizeDeps?.esbuildOptions ?? {};
     if (config.optimizeDeps.extensions?.some((ext) => filePath.endsWith(ext))) {
         // For custom supported extensions, build the entry file to transform it into JS,
@@ -27706,35 +27742,45 @@ async function extractExportsData(filePath, config) {
             write: false,
             format: 'esm'
         });
-        exportsData = parse$h(result.outputFiles[0].text);
+        const [imports, exports, facade] = parse$h(result.outputFiles[0].text);
+        return {
+            hasImports: imports.length > 0,
+            exports,
+            facade
+        };
+    }
+    let parseResult;
+    let usedJsxLoader = false;
+    const entryContent = fs__default.readFileSync(filePath, 'utf-8');
+    try {
+        parseResult = parse$h(entryContent);
+    }
+    catch {
+        const loader = esbuildOptions.loader?.[path$p.extname(filePath)] || 'jsx';
+        debug$a(`Unable to parse: ${filePath}.\n Trying again with a ${loader} transform.`);
+        const transformed = await transformWithEsbuild(entryContent, filePath, {
+            loader
+        });
+        // Ensure that optimization won't fail by defaulting '.js' to the JSX parser.
+        // This is useful for packages such as Gatsby.
+        esbuildOptions.loader = {
+            '.js': 'jsx',
+            ...esbuildOptions.loader
+        };
+        parseResult = parse$h(transformed.code);
+        usedJsxLoader = true;
     }
-    else {
-        const entryContent = fs__default.readFileSync(filePath, 'utf-8');
-        try {
-            exportsData = parse$h(entryContent);
-        }
-        catch {
-            const loader = esbuildOptions.loader?.[path$p.extname(filePath)] || 'jsx';
-            debug$a(`Unable to parse: ${filePath}.\n Trying again with a ${loader} transform.`);
-            const transformed = await transformWithEsbuild(entryContent, filePath, {
-                loader
-            });
-            // Ensure that optimization won't fail by defaulting '.js' to the JSX parser.
-            // This is useful for packages such as Gatsby.
-            esbuildOptions.loader = {
-                '.js': 'jsx',
-                ...esbuildOptions.loader
-            };
-            exportsData = parse$h(transformed.code);
-            exportsData.jsxLoader = true;
-        }
-        for (const { ss, se } of exportsData[0]) {
+    const [imports, exports, facade] = parseResult;
+    const exportsData = {
+        hasImports: imports.length > 0,
+        exports,
+        facade,
+        hasReExports: imports.some(({ ss, se }) => {
             const exp = entryContent.slice(ss, se);
-            if (/export\s+\*\s+from/.test(exp)) {
-                exportsData.hasReExports = true;
-            }
-        }
-    }
+            return /export\s+\*\s+from/.test(exp);
+        }),
+        jsxLoader: usedJsxLoader
+    };
     return exportsData;
 }
 // https://github.com/vitejs/vite/issues/1724#issuecomment-767619642
@@ -27746,9 +27792,9 @@ function needsInterop(config, id, exportsData, output) {
         KNOWN_INTEROP_IDS.has(id)) {
         return true;
     }
-    const [imports, exports] = exportsData;
+    const { hasImports, exports } = exportsData;
     // entry has no ESM syntax - likely CJS or UMD
-    if (!exports.length && !imports.length) {
+    if (!exports.length && !hasImports) {
         return true;
     }
     if (output) {
@@ -35858,7 +35904,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await import('./dep-13a14c32.js').then(function (n) { return n.c; });
+    const { parse, transform } = await import('./dep-cfa39351.js').then(function (n) { return n.c; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -36963,7 +37009,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-21067347.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-6b269949.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -37935,7 +37981,7 @@ function lexAcceptedHmrDeps(code, start, urls) {
     return false;
 }
 function error$1(pos) {
-    const err = new Error(`import.meta.accept() can only accept string literals or an ` +
+    const err = new Error(`import.meta.hot.accept() can only accept string literals or an ` +
         `Array of string literals.`);
     err.pos = pos;
     throw err;
@@ -37982,7 +38028,7 @@ function stripNesting(packages) {
  * Heuristics for determining whether a dependency should be externalized for
  * server-side rendering.
  */
-function resolveSSRExternal(config, knownImports) {
+function cjsSsrResolveExternals(config, knownImports) {
     // strip nesting since knownImports may be passed in from optimizeDeps which
     // supports a "parent > child" syntax
     knownImports = stripNesting(knownImports);
@@ -37996,7 +38042,7 @@ function resolveSSRExternal(config, knownImports) {
         ssrExternals.add(id);
         seen.add(id);
     });
-    collectExternals(config.root, config.resolve.preserveSymlinks, ssrExternals, seen, config.logger);
+    cjsSsrCollectExternals(config.root, config.resolve.preserveSymlinks, ssrExternals, seen, config.logger);
     const importedDeps = knownImports.map(getNpmPackageName).filter(isDefined);
     for (const dep of importedDeps) {
         // Assume external if not yet seen
@@ -38018,8 +38064,71 @@ function resolveSSRExternal(config, knownImports) {
 const CJS_CONTENT_RE = /\bmodule\.exports\b|\bexports[.\[]|\brequire\s*\(|\bObject\.(defineProperty|defineProperties|assign)\s*\(\s*exports\b/;
 // TODO: use import()
 const _require$2 = createRequire$1(import.meta.url);
-// do we need to do this ahead of time or could we do it lazily?
-function collectExternals(root, preserveSymlinks, ssrExternals, seen, logger) {
+const isSsrExternalCache = new WeakMap();
+function shouldExternalizeForSSR(id, config) {
+    let isSsrExternal = isSsrExternalCache.get(config);
+    if (!isSsrExternal) {
+        isSsrExternal = createIsSsrExternal(config);
+        isSsrExternalCache.set(config, isSsrExternal);
+    }
+    return isSsrExternal(id);
+}
+function createIsSsrExternal(config) {
+    const processedIds = new Map();
+    const { ssr, root } = config;
+    const noExternal = ssr?.noExternal;
+    const noExternalFilter = noExternal !== 'undefined' &&
+        typeof noExternal !== 'boolean' &&
+        createFilter$1(undefined, noExternal, { resolve: false });
+    const isConfiguredAsExternal = (id) => {
+        const { ssr } = config;
+        if (!ssr || ssr.external?.includes(id)) {
+            return true;
+        }
+        if (typeof noExternal === 'boolean') {
+            return !noExternal;
+        }
+        if (noExternalFilter) {
+            return noExternalFilter(id);
+        }
+        return true;
+    };
+    const resolveOptions = {
+        root,
+        preserveSymlinks: config.resolve.preserveSymlinks,
+        isProduction: false,
+        isBuild: true
+    };
+    const isPackageEntry = (id) => {
+        if (!bareImportRE.test(id) || id.includes('\0')) {
+            return false;
+        }
+        if (tryNodeResolve(id, undefined, resolveOptions, ssr?.target === 'webworker', undefined, true)) {
+            return true;
+        }
+        try {
+            // no main entry, but deep imports may be allowed
+            if (resolveFrom(`${id}/package.json`, root)) {
+                return true;
+            }
+        }
+        catch { }
+        return false;
+    };
+    return (id) => {
+        if (processedIds.has(id)) {
+            return processedIds.get(id);
+        }
+        const external = !id.startsWith('.') &&
+            !path$p.isAbsolute(id) &&
+            (isBuiltin(id) || (isConfiguredAsExternal(id) && isPackageEntry(id)));
+        processedIds.set(id, external);
+        return external;
+    };
+}
+// When ssr.format is 'cjs', this function is used reverting to the Vite 2.9
+// SSR externalization heuristics
+function cjsSsrCollectExternals(root, preserveSymlinks, ssrExternals, seen, logger) {
     const rootPkgContent = lookupFile(root, ['package.json']);
     if (!rootPkgContent) {
         return;
@@ -38103,10 +38212,13 @@ function collectExternals(root, preserveSymlinks, ssrExternals, seen, logger) {
         }
     }
     for (const depRoot of depsToTrace) {
-        collectExternals(depRoot, preserveSymlinks, ssrExternals, seen, logger);
+        cjsSsrCollectExternals(depRoot, preserveSymlinks, ssrExternals, seen, logger);
     }
 }
-function shouldExternalizeForSSR(id, externals) {
+function cjsShouldExternalizeForSSR(id, externals) {
+    if (!externals) {
+        return false;
+    }
     const should = externals.some((e) => {
         if (id === e) {
             return true;
@@ -39643,6 +39755,19 @@ function runOptimizerWhenIdle(config) {
 function optimizedDepsPlugin(config) {
     return {
         name: 'vite:optimized-deps',
+        buildStart() {
+            if (!config.isWorker) {
+                initRunProcessingInfo(config);
+            }
+        },
+        async resolveId(id) {
+            if (getDepsOptimizer(config)?.isOptimizedDepFile(id)) {
+                return id;
+            }
+        },
+        // this.load({ id }) isn't implemented in PluginContainer
+        // The logic to register an id to wait until it is processed
+        // is in importAnalysis, see call to delayDepsOptimizerUntil
         async load(id) {
             const depsOptimizer = getDepsOptimizer(config);
             if (depsOptimizer?.isOptimizedDepFile(id)) {
@@ -40005,8 +40130,12 @@ function importAnalysisPlugin(config) {
                     }
                     // skip ssr external
                     if (ssr) {
-                        if (server._ssrExternals &&
-                            shouldExternalizeForSSR(specifier, server._ssrExternals)) {
+                        if (config.ssr?.format === 'cjs') {
+                            if (cjsShouldExternalizeForSSR(specifier, server._ssrExternals)) {
+                                continue;
+                            }
+                        }
+                        else if (shouldExternalizeForSSR(specifier, config)) {
                             continue;
                         }
                         if (isBuiltin(specifier)) {
@@ -40082,7 +40211,7 @@ function importAnalysisPlugin(config) {
                     importedUrls.add(urlWithoutBase);
                     if (!isDynamicImport) {
                         // for pre-transforming
-                        staticImportedUrls.add(urlWithoutBase);
+                        staticImportedUrls.add({ url: urlWithoutBase, id: resolvedId });
                     }
                 }
                 else if (!importer.startsWith(clientDir) && !ssr) {
@@ -40171,10 +40300,11 @@ function importAnalysisPlugin(config) {
             isDebug$1 &&
                 debug$7(`${timeFrom(start)} ${colors$1.dim(`[${importedUrls.size} imports rewritten] ${prettyImporter}`)}`);
             // pre-transform known direct imports
+            // TODO: we should also crawl dynamic imports
             if (config.server.preTransformRequests && staticImportedUrls.size) {
-                staticImportedUrls.forEach((url) => {
+                staticImportedUrls.forEach(({ url, id }) => {
                     url = unwrapId(removeImportQuery(url)).replace(NULL_BYTE_PLACEHOLDER, '\0');
-                    transformRequest(url, server, { ssr }).catch((e) => {
+                    const request = transformRequest(url, server, { ssr }).catch((e) => {
                         if (e?.code === ERR_OUTDATED_OPTIMIZED_DEP) {
                             // This are expected errors
                             return;
@@ -40182,13 +40312,13 @@ function importAnalysisPlugin(config) {
                         // Unexpected error, log the issue but avoid an unhandled exception
                         config.logger.error(e.message);
                     });
+                    if (!config.optimizeDeps.devScan) {
+                        delayDepsOptimizerUntil(config, id, () => request);
+                    }
                 });
             }
             if (s) {
-                return {
-                    code: s.toString(),
-                    map: config.build.sourcemap ? s.generateMap({ hires: true }) : null
-                };
+                return transformResult(s, importer, config);
             }
             else {
                 return source;
@@ -40702,7 +40832,7 @@ function ssrManifestPlugin(config) {
                                     const chunk = bundle[filename];
                                     if (chunk) {
                                         chunk.viteMetadata.importedCss.forEach((file) => {
-                                            deps.push(`/${file}`);
+                                            deps.push(join$1(config.base, file));
                                         });
                                         chunk.imports.forEach(addDeps);
                                     }
@@ -40781,10 +40911,7 @@ function assetImportMetaUrlPlugin(config) {
                     s.overwrite(index, index + exp.length, `new URL(${JSON.stringify(builtUrl)}, self.location)`, { contentOnly: true });
                 }
                 if (s) {
-                    return {
-                        code: s.toString(),
-                        map: config.build.sourcemap ? s.generateMap({ hires: true }) : null
-                    };
+                    return transformResult(s, id, config);
                 }
             }
             return null;
@@ -40911,7 +41038,7 @@ function resolveBuildPlugins(config) {
         pre: [
             ...(options.watch ? [ensureWatchPlugin()] : []),
             watchPackageDataPlugin(config),
-            ...(!isDepsOptimizerEnabled(config) || options.ssr
+            ...(!isDepsOptimizerEnabled(config)
                 ? [commonjs(options.commonjsOptions)]
                 : []),
             dataURIPlugin(),
@@ -40975,25 +41102,15 @@ async function doBuild(inlineConfig = {}) {
     const outDir = resolve(options.outDir);
     // inject ssr arg to plugin load/transform hooks
     const plugins = (ssr ? config.plugins.map((p) => injectSsrFlagToHooks(p)) : config.plugins);
-    // inject ssrExternal if present
     const userExternal = options.rollupOptions?.external;
     let external = userExternal;
-    if (ssr) {
-        // see if we have cached deps data available
-        let knownImports;
-        const dataPath = path$p.join(getDepsCacheDir(config), '_metadata.json');
-        try {
-            const data = JSON.parse(fs__default.readFileSync(dataPath, 'utf-8'));
-            knownImports = Object.keys(data.optimized);
-        }
-        catch (e) { }
-        if (!knownImports) {
-            // no dev deps optimization data, do a fresh scan
-            knownImports = await findKnownImports(config);
-        }
-        external = resolveExternal(resolveSSRExternal(config, knownImports), userExternal);
+    // In CJS, we can pass the externals to rollup as is. In ESM, we need to
+    // do it in the resolve plugin so we can add the resolved extension for
+    // deep node_modules imports
+    if (ssr && config.ssr?.format === 'cjs') {
+        external = await cjsSsrResolveExternal(config, userExternal);
     }
-    if (isDepsOptimizerEnabled(config) && !ssr) {
+    if (isDepsOptimizerEnabled(config)) {
         await initDepsOptimizer(config);
     }
     const rollupOptions = {
@@ -41023,20 +41140,26 @@ async function doBuild(inlineConfig = {}) {
     };
     try {
         const buildOutputOptions = (output = {}) => {
+            const cjsSsrBuild = ssr && config.ssr?.format === 'cjs';
+            const format = output.format || (cjsSsrBuild ? 'cjs' : 'es');
+            const jsExt = (ssr && config.ssr?.target !== 'webworker') || libOptions
+                ? resolveOutputJsExtension(format, getPkgJson(config.root)?.type)
+                : 'js';
             return {
                 dir: outDir,
-                format: ssr ? 'cjs' : 'es',
-                exports: ssr ? 'named' : 'auto',
+                // Default format is 'es' for regular and for SSR builds
+                format,
+                exports: cjsSsrBuild ? 'named' : 'auto',
                 sourcemap: options.sourcemap,
                 name: libOptions ? libOptions.name : undefined,
                 generatedCode: 'es2015',
                 entryFileNames: ssr
-                    ? `[name].js`
+                    ? `[name].${jsExt}`
                     : libOptions
-                        ? resolveLibFilename(libOptions, output.format || 'es', config.root)
+                        ? resolveLibFilename(libOptions, format, config.root, jsExt)
                         : path$p.posix.join(options.assetsDir, `[name].[hash].js`),
                 chunkFileNames: libOptions
-                    ? `[name].[hash].js`
+                    ? `[name].[hash].${jsExt}`
                     : path$p.posix.join(options.assetsDir, `[name].[hash].js`),
                 assetFileNames: libOptions
                     ? `[name].[ext]`
@@ -41148,7 +41271,15 @@ function getPkgJson(root) {
 function getPkgName(name) {
     return name?.startsWith('@') ? name.split('/')[1] : name;
 }
-function resolveLibFilename(libOptions, format, root) {
+function resolveOutputJsExtension(format, type = 'commonjs') {
+    if (type === 'module') {
+        return format === 'cjs' || format === 'umd' ? 'cjs' : 'js';
+    }
+    else {
+        return format === 'es' ? 'mjs' : 'js';
+    }
+}
+function resolveLibFilename(libOptions, format, root, extension) {
     if (typeof libOptions.fileName === 'function') {
         return libOptions.fileName(format);
     }
@@ -41156,13 +41287,7 @@ function resolveLibFilename(libOptions, format, root) {
     const name = libOptions.fileName || getPkgName(packageJson.name);
     if (!name)
         throw new Error('Name in package.json is required if option "build.lib.fileName" is not provided.');
-    let extension;
-    if (packageJson?.type === 'module') {
-        extension = format === 'cjs' || format === 'umd' ? 'cjs' : 'js';
-    }
-    else {
-        extension = format === 'es' ? 'mjs' : 'js';
-    }
+    extension ?? (extension = resolveOutputJsExtension(format, packageJson.type));
     if (format === 'cjs' || format === 'es') {
         return `${name}.${extension}`;
     }
@@ -41224,24 +41349,41 @@ function onRollupWarning(warning, warn, config) {
         }
     }
 }
-function resolveExternal(ssrExternals, user) {
+async function cjsSsrResolveExternal(config, user) {
+    // see if we have cached deps data available
+    let knownImports;
+    const dataPath = path$p.join(getDepsCacheDir(config), '_metadata.json');
+    try {
+        const data = JSON.parse(fs__default.readFileSync(dataPath, 'utf-8'));
+        knownImports = Object.keys(data.optimized);
+    }
+    catch (e) { }
+    if (!knownImports) {
+        // no dev deps optimization data, do a fresh scan
+        knownImports = await findKnownImports(config);
+    }
+    const ssrExternals = cjsSsrResolveExternals(config, knownImports);
     return (id, parentId, isResolved) => {
-        if (shouldExternalizeForSSR(id, ssrExternals)) {
+        const isExternal = cjsShouldExternalizeForSSR(id, ssrExternals);
+        if (isExternal) {
             return true;
         }
         if (user) {
-            if (typeof user === 'function') {
-                return user(id, parentId, isResolved);
-            }
-            else if (Array.isArray(user)) {
-                return user.some((test) => isExternal(id, test));
-            }
-            else {
-                return isExternal(id, user);
-            }
+            return resolveUserExternal(user, id, parentId, isResolved);
         }
     };
 }
+function resolveUserExternal(user, id, parentId, isResolved) {
+    if (typeof user === 'function') {
+        return user(id, parentId, isResolved);
+    }
+    else if (Array.isArray(user)) {
+        return user.some((test) => isExternal(id, test));
+    }
+    else {
+        return isExternal(id, user);
+    }
+}
 function isExternal(id, test) {
     if (typeof test === 'string') {
         return id === test;
@@ -47250,12 +47392,21 @@ var guess = function guessEditor (specifiedEditor) {
   if (specifiedEditor) {
     return shellQuote.parse(specifiedEditor)
   }
+
+  if (process.versions.webcontainer) {
+    return [process.env.EDITOR || 'code']
+  }
+
   // We can find out which editor is currently running by:
   // `ps x` on macOS and Linux
   // `Get-Process` on Windows
   try {
     if (process.platform === 'darwin') {
-      const output = childProcess$2.execSync('ps x').toString();
+      const output = childProcess$2
+        .execSync('ps x', {
+          stdio: ['pipe', 'pipe', 'ignore']
+        })
+        .toString();
       const processNames = Object.keys(COMMON_EDITORS_OSX);
       for (let i = 0; i < processNames.length; i++) {
         const processName = processNames[i];
@@ -47288,7 +47439,9 @@ var guess = function guessEditor (specifiedEditor) {
       // x List all processes owned by you
       // -o comm Need only names column
       const output = childProcess$2
-        .execSync('ps x --no-heading -o comm --sort=comm')
+        .execSync('ps x --no-heading -o comm --sort=comm', {
+          stdio: ['pipe', 'pipe', 'ignore']
+        })
         .toString();
       const processNames = Object.keys(COMMON_EDITORS_LINUX);
       for (let i = 0; i < processNames.length; i++) {
@@ -47603,7 +47756,7 @@ async function getCertificate(cacheDir) {
         return content;
     }
     catch {
-        const content = (await import('./dep-cd161504.js')).createCertificate();
+        const content = (await import('./dep-8259d5f4.js')).createCertificate();
         promises
             .mkdir(cacheDir, { recursive: true })
             .then(() => promises.writeFile(cachePath, content))
@@ -47645,8 +47798,10 @@ async function httpServerStart(httpServer, serverOptions) {
  */
 function ssrRequireHookPlugin(config) {
     if (config.command !== 'build' ||
+        !config.build.ssr ||
         !config.resolve.dedupe?.length ||
         config.ssr?.noExternal === true ||
+        config.ssr?.format !== 'cjs' ||
         isBuildOutputEsm(config)) {
         return null;
     }
@@ -51128,6 +51283,7 @@ function initAsClient(websocket, address, protocols, options) {
 
   if (opts.followRedirects) {
     if (websocket._redirects === 0) {
+      websocket._originalSecure = isSecure;
       websocket._originalHost = parsedUrl.host;
 
       const headers = options && options.headers;
@@ -51143,18 +51299,21 @@ function initAsClient(websocket, address, protocols, options) {
           options.headers[key.toLowerCase()] = value;
         }
       }
-    } else if (
-      websocket.listenerCount('redirect') === 0 &&
-      parsedUrl.host !== websocket._originalHost
-    ) {
-      //
-      // Match curl 7.77.0 behavior and drop the following headers. These
-      // headers are also dropped when following a redirect to a subdomain.
-      //
-      delete opts.headers.authorization;
-      delete opts.headers.cookie;
-      delete opts.headers.host;
-      opts.auth = undefined;
+    } else if (websocket.listenerCount('redirect') === 0) {
+      const isSameHost = parsedUrl.host === websocket._originalHost;
+
+      if (!isSameHost || (websocket._originalSecure && !isSecure)) {
+        //
+        // Match curl 7.77.0 behavior and drop the following headers. These
+        // headers are also dropped when following a redirect to a subdomain.
+        //
+        delete opts.headers.authorization;
+        delete opts.headers.cookie;
+
+        if (!isSameHost) delete opts.headers.host;
+
+        opts.auth = undefined;
+      }
     }
 
     //
@@ -51246,6 +51405,11 @@ function initAsClient(websocket, address, protocols, options) {
 
     req = websocket._req = null;
 
+    if (res.headers.upgrade.toLowerCase() !== 'websocket') {
+      abortHandshake$1(websocket, socket, 'Invalid Upgrade header');
+      return;
+    }
+
     const digest = createHash$1('sha1')
       .update(key + GUID$1)
       .digest('base64');
@@ -51931,21 +52095,36 @@ class WebSocketServer extends EventEmitter {
   handleUpgrade(req, socket, head, cb) {
     socket.on('error', socketOnError);
 
-    const key =
-      req.headers['sec-websocket-key'] !== undefined
-        ? req.headers['sec-websocket-key']
-        : false;
+    const key = req.headers['sec-websocket-key'];
     const version = +req.headers['sec-websocket-version'];
 
-    if (
-      req.method !== 'GET' ||
-      req.headers.upgrade.toLowerCase() !== 'websocket' ||
-      !key ||
-      !keyRegex.test(key) ||
-      (version !== 8 && version !== 13) ||
-      !this.shouldHandle(req)
-    ) {
-      return abortHandshake(socket, 400);
+    if (req.method !== 'GET') {
+      const message = 'Invalid HTTP method';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+      return;
+    }
+
+    if (req.headers.upgrade.toLowerCase() !== 'websocket') {
+      const message = 'Invalid Upgrade header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (!key || !keyRegex.test(key)) {
+      const message = 'Missing or invalid Sec-WebSocket-Key header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (version !== 8 && version !== 13) {
+      const message = 'Missing or invalid Sec-WebSocket-Version header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (!this.shouldHandle(req)) {
+      abortHandshake(socket, 400);
+      return;
     }
 
     const secWebSocketProtocol = req.headers['sec-websocket-protocol'];
@@ -51955,7 +52134,9 @@ class WebSocketServer extends EventEmitter {
       try {
         protocols = subprotocol.parse(secWebSocketProtocol);
       } catch (err) {
-        return abortHandshake(socket, 400);
+        const message = 'Invalid Sec-WebSocket-Protocol header';
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
       }
     }
 
@@ -51980,7 +52161,10 @@ class WebSocketServer extends EventEmitter {
           extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
         }
       } catch (err) {
-        return abortHandshake(socket, 400);
+        const message =
+          'Invalid or unacceptable Sec-WebSocket-Extensions header';
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
       }
     }
 
@@ -52147,7 +52331,7 @@ function emitClose(server) {
 }
 
 /**
- * Handle premature socket errors.
+ * Handle socket errors.
  *
  * @private
  */
@@ -52165,27 +52349,54 @@ function socketOnError() {
  * @private
  */
 function abortHandshake(socket, code, message, headers) {
-  if (socket.writable) {
-    message = message || http$2.STATUS_CODES[code];
-    headers = {
-      Connection: 'close',
-      'Content-Type': 'text/html',
-      'Content-Length': Buffer.byteLength(message),
-      ...headers
-    };
+  //
+  // The socket is writable unless the user destroyed or ended it before calling
+  // `server.handleUpgrade()` or in the `verifyClient` function, which is a user
+  // error. Handling this does not make much sense as the worst that can happen
+  // is that some of the data written by the user might be discarded due to the
+  // call to `socket.end()` below, which triggers an `'error'` event that in
+  // turn causes the socket to be destroyed.
+  //
+  message = message || http$2.STATUS_CODES[code];
+  headers = {
+    Connection: 'close',
+    'Content-Type': 'text/html',
+    'Content-Length': Buffer.byteLength(message),
+    ...headers
+  };
 
-    socket.write(
-      `HTTP/1.1 ${code} ${http$2.STATUS_CODES[code]}\r\n` +
-        Object.keys(headers)
-          .map((h) => `${h}: ${headers[h]}`)
-          .join('\r\n') +
-        '\r\n\r\n' +
-        message
-    );
-  }
+  socket.once('finish', socket.destroy);
 
-  socket.removeListener('error', socketOnError);
-  socket.destroy();
+  socket.end(
+    `HTTP/1.1 ${code} ${http$2.STATUS_CODES[code]}\r\n` +
+      Object.keys(headers)
+        .map((h) => `${h}: ${headers[h]}`)
+        .join('\r\n') +
+      '\r\n\r\n' +
+      message
+  );
+}
+
+/**
+ * Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least
+ * one listener for it, otherwise call `abortHandshake()`.
+ *
+ * @param {WebSocketServer} server The WebSocket server
+ * @param {http.IncomingMessage} req The request object
+ * @param {(net.Socket|tls.Socket)} socket The socket of the upgrade request
+ * @param {Number} code The HTTP response status code
+ * @param {String} message The HTTP response body
+ * @private
+ */
+function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
+  if (server.listenerCount('wsClientError')) {
+    const err = new Error(message);
+    Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
+
+    server.emit('wsClientError', err, socket, req);
+  } else {
+    abortHandshake(socket, code, message);
+  }
 }
 
 const HMR_HEADER = 'vite-hmr';
@@ -54780,8 +54991,19 @@ function transformMiddleware(server) {
                 const publicPath = `${publicDir.slice(rootDir.length)}/`;
                 // warn explicit public paths
                 if (url.startsWith(publicPath)) {
-                    logger.warn(colors$1.yellow(`files in the public directory are served at the root path.\n` +
-                        `Instead of ${colors$1.cyan(url)}, use ${colors$1.cyan(url.replace(publicPath, '/'))}.`));
+                    let warning;
+                    if (isImportRequest(url)) {
+                        const rawUrl = removeImportQuery(url);
+                        warning =
+                            'Assets in public cannot be imported from JavaScript.\n' +
+                                `Instead of ${colors$1.cyan(rawUrl)}, put the file in the src directory, and use ${colors$1.cyan(rawUrl.replace(publicPath, '/src/'))} instead.`;
+                    }
+                    else {
+                        warning =
+                            `files in the public directory are served at the root path.\n` +
+                                `Instead of ${colors$1.cyan(url)}, use ${colors$1.cyan(url.replace(publicPath, '/'))}.`;
+                    }
+                    logger.warn(colors$1.yellow(warning));
                 }
             }
             if (isJSRequest(url) ||
@@ -56422,18 +56644,7 @@ async function createServer(inlineConfig = {}) {
         },
         transformIndexHtml: null,
         async ssrLoadModule(url, opts) {
-            if (!server._ssrExternals) {
-                let knownImports = [];
-                const depsOptimizer = getDepsOptimizer(config);
-                if (depsOptimizer) {
-                    await depsOptimizer.scanProcessing;
-                    knownImports = [
-                        ...Object.keys(depsOptimizer.metadata.optimized),
-                        ...Object.keys(depsOptimizer.metadata.discovered)
-                    ];
-                }
-                server._ssrExternals = resolveSSRExternal(config, knownImports);
-            }
+            await updateCjsSsrExternals(server);
             return ssrLoadModule(url, server, undefined, undefined, opts?.fixStacktrace);
         },
         ssrFixStacktrace(e) {
@@ -56779,6 +56990,20 @@ async function restartServer(server) {
     // new server (the current server) can restart now
     newServer._restartPromise = null;
 }
+async function updateCjsSsrExternals(server) {
+    if (!server._ssrExternals) {
+        let knownImports = [];
+        const depsOptimizer = getDepsOptimizer(server.config);
+        if (depsOptimizer) {
+            await depsOptimizer.scanProcessing;
+            knownImports = [
+                ...Object.keys(depsOptimizer.metadata.optimized),
+                ...Object.keys(depsOptimizer.metadata.discovered)
+            ];
+        }
+        server._ssrExternals = cjsSsrResolveExternals(server.config, knownImports);
+    }
+}
 
 var index = {
 	__proto__: null,
@@ -59001,10 +59226,7 @@ function workerImportMetaUrlPlugin(config) {
                     });
                 }
                 if (s) {
-                    return {
-                        code: s.toString(),
-                        map: config.build.sourcemap ? s.generateMap({ hires: true }) : null
-                    };
+                    return transformResult(s, id, config);
                 }
                 return null;
             }
@@ -59258,10 +59480,7 @@ function dynamicImportVarsPlugin(config) {
                 if (needDynamicImportHelper) {
                     s.prepend(`import __variableDynamicImportRuntimeHelper from "${dynamicImportHelperId}";`);
                 }
-                return {
-                    code: s.toString(),
-                    map: config.build.sourcemap ? s.generateMap({ hires: true }) : null
-                };
+                return transformResult(s, importer, config);
             }
         }
     };
@@ -59297,7 +59516,10 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
             packageCache: config.packageCache,
             ssrConfig: config.ssr,
             asSrc: true,
-            getDepsOptimizer: () => getDepsOptimizer(config)
+            getDepsOptimizer: () => getDepsOptimizer(config),
+            shouldExternalize: isBuild && config.build.ssr && config.ssr?.format !== 'cjs'
+                ? (id) => shouldExternalizeForSSR(id, config)
+                : undefined
         }),
         htmlInlineProxyPlugin(config),
         cssPlugin(config),